/data/eng/3d/3dsheart |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/eng/3d/3dspiral |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/eng/3d/cubeline |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/eng/3d/cubetext |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/eng/3d/flatwav |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/eng/3d/gears |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/eng/3d/house.3ds |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/eng/3d/logio.bmp |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/eng/@notify |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/eng/File Managers/buttons.bmp |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/eng/File Managers/eolite |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/eng/File Managers/eolite.ini |
---|
0,0 → 1,41 |
[Associations] |
rtf=/sys/htmlv |
asm=TinyPad |
inc=TinyPad |
ini=TinyPad |
txt=TinyPad |
gif=/sys/media/kiv |
bmp=/sys/media/kiv |
png=/sys/media/kiv |
tga=/sys/media/kiv |
jpg=/sys/media/kiv |
jpeg=/sys/media/kiv |
ico=/sys/media/kiv |
cur=/sys/media/kiv |
pcx=/sys/media/kiv |
3ds=/sys/3d/view3ds |
lif=/sys/demos/life2 |
skn=/sys/desktop |
htm=/sys/HTMLv |
html=/sys/HTMLv |
rtf=/sys/RtfRead |
obj=/sys/develop/cObj |
sna=/sys/e80 |
nes=/sys/games/fceu |
xm=/sys/media/AC97SND |
wav=/sys/media/AC97SND |
mp3=/sys/media/AC97SND |
mid=/sys/media/MIDAMP |
m3u=/sys/media/listplay |
lap=/sys/media/listplay |
asf=/sys/media/listplay |
mht=/sys/htmlv |
[Config] |
;åñëè ïîñòàâèòü 1 âìåñòî êíîïîê áóäåò ñòðîêà àäðåñà |
ShowEditBoxPath=0 |
;öâåò âûäåëåíîãî ýëåìåíòà è âûäåëåíèå åäèòáîêñà |
;ïî-óìîë÷àíèþ 94AECE, äëÿ òåñòà FEA4B7,8BCDFF,B8C9B8 |
BorderColor=94AECE |
/data/eng/File Managers/icons.bmp |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/eng/File Managers/icons.ini |
---|
0,0 → 1,141 |
asm=4 |
inc=4 |
txt=3 |
rtf=3 |
ini=3 |
log=3 |
dic=3 |
doc=3 |
exc=3 |
wtx=3 |
inf=3 |
xml=3 |
odt=3 |
jpg=6 |
jpe=6 |
jpeg=6 |
jif=6 |
jfif=6 |
jp2=6 |
jpx=6 |
jpk=6 |
j2k=6 |
jpc=6 |
j2c=6 |
bmp=6 |
dib=6 |
rle=6 |
pbm=6 |
wbm=6 |
wbmp=6 |
xbm=6 |
xpm=6 |
gif=6 |
png=6 |
ico=6 |
cur=6 |
ani=6 |
tif=6 |
tiff=6 |
xif=6 |
tga=6 |
pcx=6 |
dcx=6 |
ppm=6 |
psd=6 |
psp=6 |
raw=6 |
raf=6 |
x3f=6 |
orf=6 |
nef=6 |
mrw=6 |
dcr=6 |
crw=6 |
cr2=6 |
ras=6 |
pix=6 |
pict=6 |
pct=6 |
pic=6 |
pgm=6 |
pef=6 |
pcd=6 |
iff=6 |
lbm=6 |
ilbm=6 |
fpx=6 |
djv=6 |
djvu=6 |
iw4=6 |
wav=7 |
mp3=7 |
xm=7 |
mid=7 |
midi=7 |
aif=7 |
aifc=7 |
aiff=7 |
au=7 |
snd=7 |
wma=7 |
wm=7 |
avi=11 |
mpg=11 |
mpe=11 |
mpeg=11 |
flv=11 |
3gp=11 |
mkv=11 |
wmv=11 |
mov=11 |
mp4=11 |
img=5 |
ima=5 |
imz=5 |
bwz=5 |
dsk=5 |
vfd=5 |
wil=5 |
wlz=5 |
exe=8 |
com=8 |
bat=8 |
7z=9 |
rar=9 |
zip=9 |
cab=9 |
arj=9 |
lha=9 |
lzh=9 |
tar=9 |
taz=9 |
tbz=9 |
tbz2=9 |
bz=9 |
bz2=9 |
ice=9 |
gz=9 |
tgz=9 |
uue=9 |
uu=9 |
xxe=9 |
z=9 |
dat=10 |
ttf=12 |
ttc=12 |
chr=12 |
mt=12 |
htm=13 |
html=13 |
mht=13 |
eml=13 |
lif=14 |
3ds=15 |
kex=16 |
skn=17 |
obj=18 |
dll=18 |
ocx=18 |
so=18 |
drv=18 |
/data/eng/File Managers/kfar.ini |
---|
0,0 → 1,70 |
[Associations] |
asm=/sys/TinyPad; AsmMenu1,AsmMenu2 |
inc=/sys/TinyPad |
ini=/sys/TinyPad |
txt=/sys/TinyPad |
jpg=/sys/media/kiv |
jpeg=/sys/media/kiv |
gif=/sys/media/kiv; ViewGraph,MenuAnimage |
wav=/sys/media/AC97SND |
mp3=/sys/media/AC97SND |
xm=/sys/media/AC97SND |
mid=/sys/media/MIDAMP |
bmp=/sys/media/kiv; ViewGraph,MenuAnimage |
png=/sys/media/kiv |
ico=/sys/media/kiv |
cur=/sys/media/kiv |
pcx=/sys/media/kiv |
rtf=/sys/RtfRead |
3ds=/sys/3d/view3ds |
lif=/sys/demos/life2 |
skn=/sys/desktop |
m3u=/sys/media/listplay |
lap=/sys/media/listplay |
asf=/sys/media/listplay |
cvs=/sys/graph |
obj=/sys/develop/cObj |
nes=/sys/fceu |
sna=/sys/e80 |
htm=/sys/HTMLv |
html=/sys/HTMLv |
[Menu] |
AsmMenu1=&Edit,/sys/TinyPad |
AsmMenu2=&Compile,/sys/develop/fasm |
ViewGraph=&View,/sys/media/kiv |
MenuAnimage=&Edit,/sys/media/animage |
[Panels] |
; View modes for files on panels |
; values correspond to digits for LCtrl+<1-4> |
LeftViewMode=2 |
RightViewMode=2 |
; Sort modes for files on panels |
; values are 2 * N + M, where |
; M = 0 - normal sorting, M = 1 - reverse sorting |
; N = 0-6 correspond to sort mode for Ctrl+F<3-9> |
LeftSortMode=0 |
RightSortMode=0 |
[Editor] |
; Symbols for end-of-line, which will be added by kfar editor |
; when new line will be created: |
; DOS - like in DOS/Win (0D 0A), Unix - like in Unix (0A), |
; Mac - like in Mac (0D) |
EOLStyle=Unix |
[FolderShortcuts] |
; You can define up to 10 links to folders Shortcut0...Shortcut9, |
; the quick jump to such folders can be done with RCtrl+<digit> |
Shortcut0=/rd/1 |
[Confirmations] |
Delete=1 |
DeleteIncomplete=0 |
[Plugins] |
; On left of the equal sign any sensical or nonsensical name can appear; |
; on right - path to plugin. |
; If path is not absolute, it is counted from the folder with kfar binary. |
ArchiveReader=/sys/lib/archiver.obj |
/data/eng/File Managers/kfm |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/eng/File Managers/kfm.ini |
---|
0,0 → 1,171 |
start |
<>icons_associations |
asm 0004 |
inc 0004 |
txt 0003 |
rtf 0003 |
ini 0003 |
log 0003 |
dic 0003 |
doc 0003 |
exc 0003 |
wtx 0003 |
inf 0003 |
jpg 0006 |
jpe 0006 |
jpeg 0006 |
jif 0006 |
jfif 0006 |
jp2 0006 |
jpx 0006 |
jpk 0006 |
j2k 0006 |
jpc 0006 |
j2c 0006 |
bmp 0006 |
dib 0006 |
rle 0006 |
pbm 0006 |
wbm 0006 |
wbmp 0006 |
xbm 0006 |
xpm 0006 |
gif 0006 |
png 0006 |
ico 0006 |
cur 0006 |
ani 0006 |
tif 0006 |
tiff 0006 |
xif 0006 |
tga 0006 |
pcx 0006 |
dcx 0006 |
ppm 0006 |
psd 0006 |
psp 0006 |
raw 0006 |
raf 0006 |
x3f 0006 |
orf 0006 |
nef 0006 |
mrw 0006 |
dcr 0006 |
crw 0006 |
cr2 0006 |
ras 0006 |
pix 0006 |
pict 0006 |
pct 0006 |
pic 0006 |
pgm 0006 |
pef 0006 |
pcd 0006 |
iff 0006 |
lbm 0006 |
ilbm 0006 |
fpx 0006 |
djv 0006 |
djvu 0006 |
iw4 0006 |
wav 0007 |
mp3 0007 |
xm 0007 |
mid 0007 |
midi 0007 |
aif 0007 |
aifc 0007 |
aiff 0007 |
au 0007 |
snd 0007 |
wma 0007 |
wm 0007 |
avi 0011 |
mpg 0011 |
img 0005 |
ima 0005 |
imz 0005 |
bwz 0005 |
dsk 0005 |
vfd 0005 |
wil 0005 |
wlz 0005 |
exe 0008 |
com 0008 |
bat 0008 |
7z 0009 |
rar 0009 |
zip 0009 |
cab 0009 |
arj 0009 |
lha 0009 |
lzh 0009 |
tar 0009 |
taz 0009 |
tbz 0009 |
tbz2 0009 |
bz 0009 |
bz2 0009 |
ice 0009 |
gz 0009 |
tgz 0009 |
uue 0009 |
uu 0009 |
xxe 0009 |
z 0009 |
dat 0010 |
ttf 0012 |
ttc 0012 |
chr 0012 |
mt 0012 |
htm 0013 |
html 0013 |
lif 0014 |
3ds 0015 |
kex 0016 |
skn 0017 |
<>end |
<>files_associations |
asm /sys/tinypad |
inc /sys/tinypad |
txt /sys/tinypad |
ini /sys/tinypad |
log /sys/tinypad |
dat /sys/tinypad |
inf /sys/tinypad |
bat /sys/tinypad |
jpg /sys/media/kiv |
jpeg /sys/media/kiv |
jpe /sys/media/kiv |
gif /sys/media/kiv |
wav /sys/media/ac97snd |
mp3 /sys/media/ac97snd |
xm /sys/media/ac97snd |
mid /sys/media/midamp |
bmp /sys/media/kiv |
png /sys/media/kiv |
ico /sys/media/kiv |
cur /sys/media/kiv |
pcx /sys/media/kiv |
rtf /sys/rtfread |
3ds /sys/3d/view3ds |
lif /sys/demos/life2 |
skn /sys/desktop |
avi /sys/kvid.kex |
m3u /sys/media/listplay |
lap /sys/media/listplay |
asf /sys/media/listplay |
cvs /sys/graph |
obj /sys/develop/cObj |
nes /sys/fceu |
sna /sys/e80 |
htm /sys/HTMLv |
html /sys/HTMLv |
<>end |
<>files_association1 |
bmp /sys/media/animage |
<>end |
end |
/data/eng/File Managers/kfm_keys.txt |
---|
0,0 → 1,42 |
Controlling keyboard shortcuts in KFM - Kolibri File Manager v0.45f. |
In panels: |
1) Cursor update on the active panel: |
a) Up arrow and downwards (including keyboards, located in an additional part,) - cursor update on one position upwards or downwards. á) PageUp - page paging upwards. |
b) PageDown - page paging downwards. |
c) Home - in a beginning of the directory with files. |
d) End - in the end of the directory with files. |
2) Tab - change of the active panel. |
3) Enter - operation with the file on which position there is a selection cursor: à) an input(entrance) in a folder. |
a) Start of the program. |
b) To open the file in the registered application, according to a contents of the file kfm.ini, unit " < > files associations ". |
4) Alt+F1 - call of the menu of choice of the disk displayed on the left panel. |
5) Alt+F2 - call of the menu of choice of the disk displayed on the right panel. |
6) Sorting files in the active panel: |
a) Ctrl+F3 - sorting according names. |
b) Ctrl+F4 - sorting according extensions. |
c) Ctrl+F5 - sorting according a size. |
d) Ctrl+F6 - sorting by date of modification. |
7) Ctrl+R - repeated loading of contents of the directory in the active panel. |
8) Delete and F8 - the deleting of the file on which is the cursor. |
9) Insert - the selection by red colour of the file on which is the cursor and cursor update on 1 position downwards. |
10) F4 - to open the file for editing in the registered application, according to a contents of the file kfm.ini, unit " < > files association1 ". |
11) F7 - creation of the directory in the active panel. |
12) F5 - copying file from the active panel in opposite. |
13) F6 - moving of the file from the active panel in opposite. |
14) Ctrl+A and Ctrl + (NumPad (+) Up) - selection of all files and directories in the active panel, except for the directory '..' |
15) Ctrl + (NumPad (-) Up) - to deselect of all files and directories in the active panel, except for the directory '..' |
16) Ctrl + (NumPad (*) Up) - to invert selection of all files and directories in the active panel, except for the directory '..' |
17) F12 - program termination. |
18) F1 - help, hot shortcut keys. The presence of the file kfm_keys.txt in the directory is required where the application is located. |
19) Open file in other application with parameter: |
à) Shift + W - set background, mode: tile. |
á) Ctrl + W - set background, mode: stretch. |
In the menu of choice of the disk: |
1) Up arrow and down arrow (including keys, located in an additional part of keyboard) - cursor update on one position upwards or downwards. |
2) Enter - the choice of the disk on which position is a selection cursor. |
3) Home and PageUp - cursor in a beginning of the list |
4) End and PageDown - cursor in the end of the list. |
5) Insert - load tray of selected ATAPI device. |
6) Delete - eject tray of selected ATAPI device. |
/data/eng/Makefile |
---|
0,0 → 1,367 |
# General rule for naming: variables with CAPITALIZED names hold settings, |
# you can - and are expected - to modify it; variables with lowercase names |
# are intermediate variables and macroses not to be modified unless you |
# know what you're doing. |
# Define directories for destination, source repository, sources of kernel, sources of programs. |
BUILD_DIR:=build |
REPOSITORY:=../localcopy |
KERNEL:=$(REPOSITORY)/kernel/trunk |
PROGS:=$(REPOSITORY)/programs |
# Docpak requires some documents; we place them |
# into 'docs' subdir and communicate with FASM |
# through environment var DOCDIR. |
DOCDIR:=docs/ |
export DOCDIR |
# Because most programs are written in FASM and have |
# the common structure of one main .asm file possibly including |
# several .inc files, we handle this case separately. |
# Namely, we organize one big list of such programs |
# (FASM_PROGRAMS, see below) containing name of local binary file, |
# name of file inside kolibri.img and name of the source file. |
# This list is maintained by hand, and the rest is done with some macroses... |
# well, slightly complicated macroses - however, you do not need to |
# understand them in order to maintain the list. |
# To add a FASM program with one .asm file, just |
# add the corresponding item to the list and enjoy |
# the power of GNU make. |
# The list of all FASM programs with one main FASM file. |
# Every item consists of three parts, separated by ':'. |
# First part is the real name of binary file in $(BUILD_DIR) |
# as it should be produced by make. |
# Second part is the name of a file inside kolibri.img, |
# usually uppercased version of first part - to save space |
# for FAT filesystem. |
# Third part is the name of the source file. |
# Spaces separate items, so spaces in names should be |
# represented as '|'. |
FASM_PROGRAMS:=\ |
@clip:@CLIP:$(PROGS)/system/clip/trunk/@clip.ASM \ |
@menu:@MENU:$(PROGS)/system/menu/trunk/menu.asm \ |
@panel:@PANEL:$(PROGS)/system/panel/trunk/@PANEL.ASM \ |
@rb:@RB:$(PROGS)/system/rb/trunk/@RB.ASM \ |
@ss:@SS:$(PROGS)/system/ss/trunk/@SS.ASM \ |
calc:CALC:$(PROGS)/other/calc/trunk/calc.asm \ |
calendar:CALENDAR:$(PROGS)/system/calendar/trunk/calendar.asm \ |
commouse:COMMOUSE:$(PROGS)/system/commouse/trunk/commouse.asm \ |
copyr:COPYR:$(PROGS)/fs/copyr/trunk/copyr.asm \ |
cpu:CPU:$(PROGS)/system/cpu/trunk/cpu.asm \ |
cpuid:CPUID:$(PROGS)/system/cpuid/trunk/CPUID.ASM \ |
desktop:DESKTOP:$(PROGS)/system/desktop/trunk/desktop.asm \ |
disptest:DISPTEST:$(PROGS)/system/disptest/trunk/disptest.ASM \ |
docpak:DOCPAK:$(PROGS)/system/docpack/trunk/docpack.asm \ |
downloader:downloader:$(PROGS)/network/downloader/trunk/downloader.asm \ |
end:END:$(PROGS)/system/end/trunk/end.asm \ |
gmon:GMON:$(PROGS)/system/gmon/gmon.asm \ |
hdd_info:HDD_INFO:$(PROGS)/system/hdd_info/trunk/hdd_info.asm \ |
icon:ICON:$(PROGS)/system/icon/trunk/icon.asm \ |
kbd:KBD:$(PROGS)/system/kbd/trunk/kbd.ASM \ |
launcher:LAUNCHER:$(PROGS)/system/launcher/trunk/launcher.asm \ |
magnify:MAGNIFY:$(PROGS)/demos/magnify/trunk/magnify.asm \ |
mgb:MGB:$(PROGS)/system/mgb/trunk/mgb.asm \ |
mousemul:MOUSEMUL:$(PROGS)/system/mousemul/trunk/mousemul.asm \ |
pcidev:PCIDEV:$(PROGS)/system/pcidev/trunk/PCIDEV.ASM \ |
period:PERIOD:$(PROGS)/other/period/trunk/period.asm \ |
pic4:PIC4:$(PROGS)/media/pic4/trunk/pic4.asm \ |
rdsave:RDSAVE:$(PROGS)/system/rdsave/trunk/rdsave.asm \ |
rtfread:RTFREAD:$(PROGS)/other/rtfread/trunk/rtfread.asm \ |
run:RUN:$(PROGS)/system/run/trunk/run.asm \ |
scrshoot:SCRSHOOT:$(PROGS)/media/scrshoot/scrshoot.asm \ |
setup:SETUP:$(PROGS)/system/setup/trunk/setup.asm \ |
tinypad:TINYPAD:$(PROGS)/develop/tinypad/trunk/tinypad.asm \ |
vrr:VRR:$(PROGS)/system/vrr/trunk/vrr.asm \ |
vrr_m:VRR_M:$(PROGS)/system/vrr_m/trunk/vrr_m.asm \ |
zkey:ZKEY:$(PROGS)/system/zkey/trunk/ZKEY.ASM \ |
3d/3dcube2:3D/3DCUBE2:$(PROGS)/demos/3dcube2/trunk/3DCUBE2.ASM \ |
3d/3dtcub10:3D/3DTCUB10:$(PROGS)/demos/3dtcub10/trunk/3DTCUB10.ASM \ |
3d/crownscr:3D/CROWNSCR:$(PROGS)/demos/crownscr/trunk/crownscr.asm \ |
3d/free3d04:3D/FREE3D04:$(PROGS)/demos/free3d04/trunk/free3d04.asm \ |
3d/view3ds:3D/VIEW3DS:$(PROGS)/demos/3DS/VIEW3DS.ASM \ |
demos/bcdclk:DEMOS/BCDCLK:$(PROGS)/demos/bcdclk/bcdclk/bcdclk.asm \ |
demos/circle:DEMOS/CIRCLE:$(PROGS)/develop/examples/circle/trunk/circle.asm \ |
demos/colorref:DEMOS/COLORREF:$(PROGS)/demos/colorref/trunk/colorref.asm \ |
demos/cslide:DEMOS/CSLIDE:$(PROGS)/demos/cslide/trunk/cslide.asm \ |
demos/eyes:DEMOS/EYES:$(PROGS)/demos/eyes/trunk/eyes.asm \ |
demos/fire:DEMOS/FIRE:$(PROGS)/demos/fire/trunk/fire.asm \ |
demos/firework:DEMOS/FIREWORK:$(PROGS)/demos/firework/trunk/firework.asm \ |
demos/movback:DEMOS/MOVBACK:$(PROGS)/demos/movback/trunk/movback.asm \ |
demos/plasma:DEMOS/PLASMA:$(PROGS)/demos/plasma/trunk/plasma.asm \ |
demos/timer:DEMOS/TIMER:$(PROGS)/demos/timer/trunk/timer.asm \ |
demos/tinyfrac:DEMOS/TINYFRAC:$(PROGS)/demos/tinyfrac/trunk/tinyfrac.asm \ |
demos/trantest:DEMOS/TRANTEST:$(PROGS)/demos/trantest/trunk/trantest.asm \ |
demos/tube:DEMOS/TUBE:$(PROGS)/demos/tube/trunk/tube.asm \ |
demos/unvwater:DEMOS/UNVWATER:$(PROGS)/demos/unvwater/trunk/unvwater.asm \ |
develop/board:DEVELOP/BOARD:$(PROGS)/system/board/trunk/board.asm \ |
develop/cObj:DEVELOP/cObj:$(PROGS)/develop/cObj/trunk/cObj.asm \ |
develop/fasm:DEVELOP/FASM:$(PROGS)/develop/fasm/trunk/fasm.asm \ |
develop/h2d2b:DEVELOP/H2D2B:$(PROGS)/develop/h2d2b/trunk/h2d2b.asm \ |
develop/heed:DEVELOP/HEED:$(PROGS)/develop/heed/trunk/heed.asm \ |
develop/ipc:DEVELOP/IPC:$(PROGS)/network/ipc/trunk/ipc.asm \ |
develop/keyascii:DEVELOP/KEYASCII:$(PROGS)/develop/keyascii/trunk/keyascii.asm \ |
develop/mtdbg:DEVELOP/MTDBG:$(PROGS)/develop/mtdbg/mtdbg.asm \ |
develop/scancode:DEVELOP/SCANCODE:$(PROGS)/develop/scancode/trunk/scancode.asm \ |
develop/test_gets:DEVELOP/test_gets:$(PROGS)/develop/libraries/console/examples/test_gets.asm \ |
develop/testcon2:DEVELOP/TESTCON2:$(PROGS)/develop/libraries/console/examples/testcon2.asm \ |
develop/thread:DEVELOP/THREAD:$(PROGS)/develop/examples/thread/trunk/thread.asm \ |
drivers/atikms:DRIVERS/ATIKMS:$(REPOSITORY)/drivers/video/drm/radeon/atikms.asm \ |
drivers/com_mouse.obj:DRIVERS/COM_MOUSE.OBJ:$(KERNEL)/drivers/com_mouse.asm \ |
drivers/emu10k1x.obj:DRIVERS/EMU10K1X.OBJ:$(KERNEL)/drivers/emu10k1x.asm \ |
drivers/fm801.obj:DRIVERS/FM801.OBJ:$(KERNEL)/drivers/fm801.asm \ |
drivers/infinity.obj:DRIVERS/INFINITY.OBJ:$(KERNEL)/drivers/infinity.asm \ |
drivers/ps2mouse.obj:DRIVERS/PS2MOUSE.OBJ:$(REPOSITORY)/drivers/mouse/ps2mouse4d/trunk/ps2mouse.asm \ |
drivers/sb16.obj:DRIVERS/SB16.OBJ:$(KERNEL)/drivers/sb16/sb16.asm \ |
drivers/sound.obj:DRIVERS/SOUND.OBJ:$(KERNEL)/drivers/sound.asm \ |
drivers/vmode.mdr:DRIVERS/VMODE.MDR:$(KERNEL)/drivers/vmode.asm \ |
drivers/vt8235.obj:DRIVERS/VT8235.OBJ:$(KERNEL)/drivers/vt823x.asm \ |
File|Managers/kfar:File|Managers/KFAR:$(PROGS)/fs/kfar/trunk/kfar.asm \ |
File|Managers/OpenDial:File|Managers/OPENDIAL:$(PROGS)/develop/libraries/box_lib/asm/trunk/OpenDial.asm \ |
fonts/bgitest:FONTS/BGITEST:$(PROGS)/demos/bgitest/trunk/bgitest.asm \ |
games/15:GAMES/15:$(PROGS)/games/15/trunk/15.ASM \ |
games/arcanii:GAMES/ARCANII:$(PROGS)/games/arcanii/trunk/arcanii.asm \ |
games/freecell:GAMES/FREECELL:$(PROGS)/games/freecell/freecell.ASM \ |
games/invaders:GAMES/INVADERS:$(PROGS)/games/invaders/invaders.asm \ |
games/lines:GAMES/LINES:$(PROGS)/games/lines/lines.asm \ |
games/mblocks:GAMES/MBLOCKS:$(PROGS)/games/mblocks/trunk/mblocks.asm \ |
games/phenix:GAMES/PHENIX:$(PROGS)/games/phenix/trunk/phenix.asm \ |
games/pipes:GAMES/PIPES:$(PROGS)/games/pipes/pipes.asm \ |
games/pong:GAMES/PONG:$(PROGS)/games/pong/trunk/pong.asm \ |
games/pong3:GAMES/PONG3:$(PROGS)/games/pong3/trunk/pong3.asm \ |
games/rsquare:GAMES/RSQUARE:$(PROGS)/games/rsquare/trunk/rsquare.asm \ |
games/snake:GAMES/SNAKE:$(PROGS)/games/snake/trunk/snake.asm \ |
games/tetris:GAMES/TETRIS:$(PROGS)/games/tetris/trunk/tetris.asm \ |
lib/archiver.obj:LIB/ARCHIVER.OBJ:$(PROGS)/fs/kfar/trunk/kfar_arc/kfar_arc.asm \ |
lib/box_lib.obj:LIB/BOX_LIB.OBJ:$(PROGS)/develop/libraries/box_lib/trunk/box_lib.asm \ |
lib/console.obj:LIB/CONSOLE.OBJ:$(PROGS)/develop/libraries/console/console.asm \ |
lib/libgfx.obj:LIB/LIBGFX.OBJ:$(PROGS)/develop/libraries/libs-dev/libgfx/libgfx.asm \ |
lib/libimg.obj:LIB/LIBIMG.OBJ:$(PROGS)/develop/libraries/libs-dev/libimg/libimg.asm \ |
lib/libini.obj:LIB/LIBINI.OBJ:$(PROGS)/develop/libraries/libs-dev/libini/libini.asm \ |
lib/libio.obj:LIB/LIBIO.OBJ:$(PROGS)/develop/libraries/libs-dev/libio/libio.asm \ |
lib/network.obj:LIB/NETWORK.OBJ:$(PROGS)/develop/libraries/network/network.asm \ |
lib/proc_lib.obj:LIB/PROC_LIB.OBJ:$(PROGS)/develop/libraries/proc_lib/trunk/proc_lib.asm \ |
media/animage:MEDIA/ANIMAGE:$(PROGS)/media/animage/trunk/animage.asm \ |
media/cdp:MEDIA/CDP:$(PROGS)/media/cdp/trunk/cdp.asm \ |
media/kiv:MEDIA/KIV:$(PROGS)/media/kiv/trunk/kiv.asm \ |
media/midamp:MEDIA/MIDAMP:$(PROGS)/media/midamp/trunk/midamp.asm \ |
network/airc:NETWORK/AIRC:$(PROGS)/network/airc/trunk/airc.asm \ |
network/arpstat:NETWORK/ARPSTAT:$(PROGS)/network/arpstat/trunk/arpstat.asm \ |
network/chess:NETWORK/CHESS:$(PROGS)/network/chess/trunk/chess.asm \ |
network/ethstat:NETWORK/ETHSTAT:$(PROGS)/network/ethstat/trunk/ethstat.asm \ |
network/ftps:NETWORK/FTPS:$(PROGS)/network/ftps/trunk/FTPS.ASM \ |
network/httpc:NETWORK/HTTPC:$(PROGS)/network/httpc/trunk/httpc.asm \ |
network/https:NETWORK/HTTPS:$(PROGS)/network/https/trunk/https.asm \ |
network/nntpc:NETWORK/NNTPC:$(PROGS)/network/nntpc/trunk/nntpc.asm \ |
network/nslookup:NETWORK/NSLOOKUP:$(PROGS)/develop/libraries/network/examples/nslookup.asm \ |
network/popc:NETWORK/POPC:$(PROGS)/network/popc/trunk/popc.asm \ |
network/smtps:NETWORK/SMTPS:$(PROGS)/network/smtps/trunk/smtps.asm \ |
network/stackcfg:NETWORK/STACKCFG:$(PROGS)/network/stackcfg/trunk/stackcfg.asm \ |
network/telnet:NETWORK/TELNET:$(PROGS)/network/telnet/trunk/telnet.asm \ |
network/tftpc:NETWORK/TFTPC:$(PROGS)/network/tftpc/trunk/tftpc.asm \ |
network/VNCclient:NETWORK/VNCclient:$(PROGS)/network/VNCclient/VNCclient.asm \ |
network/ym:NETWORK/YM:$(PROGS)/network/ym/trunk/ym.asm \ |
network/zeroconf:NETWORK/ZEROCONF:$(PROGS)/network/zeroconf/trunk/zeroconf.asm \ |
# end of list |
# The list of files which should be copied from somewhere. |
# Format of an item is exactly the same as in the previous list. |
COPY_FILES:=\ |
macros.inc:MACROS.INC:$(PROGS)/macros.inc \ |
config.inc:CONFIG.INC:$(PROGS)/config.inc \ |
struct.inc:STRUCT.INC:$(PROGS)/struct.inc \ |
File|Managers/z_icons.png:File|Managers/Z_ICONS.PNG:$(PROGS)/develop/libraries/box_lib/asm/trunk/z_icons.png \ |
fonts/euro.chr:FONTS/EURO.CHR:$(PROGS)/demos/bgitest/trunk/FONTS/EURO.CHR \ |
fonts/goth.chr:FONTS/GOTH.CHR:$(PROGS)/demos/bgitest/trunk/FONTS/GOTH.CHR \ |
fonts/lcom.chr:FONTS/LCOM.CHR:$(PROGS)/demos/bgitest/trunk/FONTS/LCOM.CHR \ |
fonts/litt.chr:FONTS/LITT.CHR:$(PROGS)/demos/bgitest/trunk/FONTS/LITT.CHR \ |
fonts/sans.chr:FONTS/SANS.CHR:$(PROGS)/demos/bgitest/trunk/FONTS/SANS.CHR \ |
fonts/scri.chr:FONTS/SCRI.CHR:$(PROGS)/demos/bgitest/trunk/FONTS/SCRI.CHR \ |
fonts/simp.chr:FONTS/SIMP.CHR:$(PROGS)/demos/bgitest/trunk/FONTS/SIMP.CHR \ |
fonts/smal.chr:FONTS/SMAL.CHR:$(PROGS)/demos/bgitest/trunk/FONTS/SMAL.CHR \ |
fonts/trip.chr:FONTS/TRIP.CHR:$(PROGS)/demos/bgitest/trunk/FONTS/TRIP.CHR \ |
fonts/tscr.chr:FONTS/TSCR.CHR:$(PROGS)/demos/bgitest/trunk/FONTS/TSCR.CHR |
# List of other files to be included in the image file. |
# Some of them are auto-built with special rules, some just exist before build. |
# Each item is of the form <local name>:<name inside image>. |
# Spaces should be represented as |. |
OTHER_FILES:=asciivju:ASCIIVJU autorun.dat:AUTORUN.DAT \ |
background.gif:background.gif default.skn:DEFAULT.SKN \ |
e80:E80 graph:GRAPH hdread:HDREAD htmlv:HTMLV \ |
icons.dat:ICONS.DAT iconstrp.gif:ICONSTRP.GIF index_htm:INDEX.HTM \ |
kernel.mnt:KERNEL.MNT kerpack:KERPACK keymap.key:KEYMAP.KEY kpack:KPACK \ |
kuzkina.mid:KUZKINA.MID lang.inc:LANG.INC lang.ini:LANG.INI \ |
menu.dat:MENU.DAT mykey:MYKEY @notify:@NOTIFY \ |
panel.dat:PANEL.DAT setup.dat:SETUP.DAT \ |
shell:SHELL spanel:SPANEL table:TABLE test:TEST \ |
vmode:VMODE \ |
3d/3dsheart:3D/3DSHEART 3d/3dspiral:3D/3DSPIRAL 3d/cubeline:3D/CUBELINE \ |
3d/flatwav:3D/FLATWAV 3d/gears:3D/GEARS 3d/house.3ds:3D/HOUSE.3DS \ |
demos/aclock:DEMOS/ACLOCK demos/ak47.lif:DEMOS/AK47.LIF \ |
demos/barge.lif:DEMOS/BARGE.LIF demos/life2:DEMOS/LIFE2 \ |
demos/relay.lif:DEMOS/RELAY.LIF demos/rpento.lif:DEMOS/RPENTO.LIF \ |
demos/use_mb:DEMOS/USE_MB demos/web:DEMOS/WEB \ |
drivers/atikms.dll:DRIVERS/ATIKMS.DLL \ |
File|Managers/buttons.bmp:File|Managers/BUTTONS.BMP \ |
File|Managers/eolite:File|Managers/EOLITE \ |
File|Managers/eolite.ini:File|Managers/EOLITE.INI \ |
File|Managers/icons.bmp:File|Managers/ICONS.BMP \ |
File|Managers/icons.ini:File|Managers/ICONS.INI \ |
File|Managers/kfar.ini:File|Managers/KFAR.INI \ |
File|Managers/kfm:File|Managers/KFM \ |
File|Managers/kfm.ini:File|Managers/KFM.INI \ |
File|Managers/kfm_keys.txt:File|Managers/KFM_KEYS.TXT \ |
fonts/bold.chr:FONTS/BOLD.CHR fonts/char2.mt:FONTS/CHAR2.MT \ |
fonts/char.mt:FONTS/CHAR.MT \ |
games/bnc:GAMES/BNC games/c4:GAMES/C4 \ |
games/checkers:GAMES/CHECKERS games/clicks:GAMES/CLICKS \ |
games/FindNumbers:GAMES/FindNumbers games/gomoku:GAMES/GOMOKU \ |
games/klavisha:GAMES/KLAVISHA games/kosilka:GAMES/KOSILKA \ |
games/kosskin.gfx:GAMES/KOSSKIN.GFX games/kox:GAMES/KOX \ |
games/lights:GAMES/LIGHTS games/megamaze:GAMES/MEGAMAZE games/mine:GAMES/MINE \ |
games/msquare:GAMES/MSQUARE \ |
games/reversi:GAMES/REVERSI games/rforces:GAMES/RFORCES \ |
games/snake.ini:GAMES/SNAKE.INI games/sq_game:GAMES/SQ_GAME \ |
games/sudoku:GAMES/SUDOKU games/sw:GAMES/SW \ |
games/xonix:GAMES/XONIX \ |
lib/cnv_png.obj:LIB/CNV_PNG.OBJ lib/msgbox.obj:LIB/MSGBOX.OBJ \ |
lib/pixlib.obj:LIB/PIXLIB.OBJ lib/sort.obj:LIB/SORT.OBJ \ |
media/ac97snd:MEDIA/AC97SND media/kiv.ini:MEDIA/KIV.INI \ |
media/listplay:MEDIA/LISTPLAY media/startmus:MEDIA/STARTMUS \ |
network/jmail:NETWORK/JMAIL network/zeroconf.ini:NETWORK/ZEROCONF.INI \ |
#end of list |
#3d/logio.bmp:3D/LOGIO.BMP 3d/cubetext:3D/CUBETEXT |
# Some macro for convenient work. |
# Macros for replacing '|' to escaped space '\ '. |
space:=\ #plus space |
respace=$(subst |,$(space),$(1)) |
# Macro for selecting different parts of ':'-separated items. |
binarypart=$(word 1,$(subst :, ,$(1))) |
imagepart=$(word 2,$(subst :, ,$(1))) |
sourcepart=$(word 3,$(subst :, ,$(1))) |
# Get file names, possibly with spaces inside, from an item. |
# Here $(f) is an item - in fact, macro argument. |
fbinary=$(call respace,$(call binarypart,$(f))) |
fimage=$(call respace,$(call imagepart,$(f))) |
fsource=$(call respace,$(call sourcepart,$(f))) |
# Define targets for image file. |
# Join lists $(FASM_PROGRAMS), $(COPY_FILES) and $(OTHER_FILES); |
# for each item in the united list call fbinary. |
targets:=$(foreach f,$(COPY_FILES) $(FASM_PROGRAMS) $(OTHER_FILES),$(fbinary)) |
# Define a command for copying a file inside the image. |
# mcopy_command is a macro with two parameters, |
# local file name $(1) and image file name $(2). |
# Note that spaces in these have to be escaped with backslashes. |
mcopy_command=mcopy -mi $(BUILD_DIR)/kolibri.img $(1) ::$(2) |
# Specialize a previous command for an item $(f) in one of lists. |
mcopy_item_command=$(call mcopy_command,$(fbinary),$(fimage)) |
# Join all $(mcopy_item_command) for all items, |
# append newline after each item. |
# The first newline character after "define" line and |
# the last newline character before "endef" line get away |
# with define/endef, so we make three newline characters, |
# that is two empty lines, in order to get one in $(newline). |
define newline |
endef |
mcopy_all_items:=$(foreach f,$(FASM_PROGRAMS) $(COPY_FILES) $(OTHER_FILES),$(mcopy_item_command)$(newline)) |
# The main goal: image. |
$(BUILD_DIR)/kolibri.img: $(BUILD_DIR)/.dir \ |
Makefile \ |
$(BUILD_DIR)/boot_fat12.bin \ |
$(targets) |
# SYSXTREE |
# 3d/CUBETEXT |
# 3d/LOGIO.BMP |
dd if=/dev/zero of=$(BUILD_DIR)/kolibri.img count=2880 bs=512 |
mformat -f 1440 -i $(BUILD_DIR)/kolibri.img :: |
dd if=$(BUILD_DIR)/boot_fat12.bin of=$(BUILD_DIR)/kolibri.img count=1 bs=512 conv=notrunc |
mmd -i $(BUILD_DIR)/kolibri.img ::3D |
mmd -i $(BUILD_DIR)/kolibri.img ::DEMOS |
mmd -i $(BUILD_DIR)/kolibri.img ::DEVELOP |
mmd -i $(BUILD_DIR)/kolibri.img ::DRIVERS |
mmd -i $(BUILD_DIR)/kolibri.img ::File\ Managers |
mmd -i $(BUILD_DIR)/kolibri.img ::FONTS |
mmd -i $(BUILD_DIR)/kolibri.img ::GAMES |
mmd -i $(BUILD_DIR)/kolibri.img ::LIB |
mmd -i $(BUILD_DIR)/kolibri.img ::MEDIA |
mmd -i $(BUILD_DIR)/kolibri.img ::NETWORK |
$(mcopy_all_items) |
# Special target to modify behaviour of make. |
.DELETE_ON_ERROR: |
# The floppy bootsector. |
$(BUILD_DIR)/boot_fat12.bin: $(KERNEL)/bootloader/boot_fat12.asm $(KERNEL)/bootloader/floppy1440.inc |
fasm $(KERNEL)/bootloader/boot_fat12.asm $(BUILD_DIR)/boot_fat12.bin |
$(BUILD_DIR)/.dir 3d/.dir demos/.dir develop/.dir drivers/.dir fonts/.dir \ |
games/.dir lib/.dir media/.dir network/.dir .deps/.dir: |
mkdir -p $(dir $@) |
touch $@ |
File\ Managers/.dir: |
mkdir -p "File Managers" |
touch "File Managers/.dir" |
# Define the rule for all FASM programs. |
# Yes, this looks like a black magic. |
# But it is not so scary as it seems. |
# First, we define "meta-rule" as a rule which is |
# macro depending on $(fasmprog). |
# Second, the construction foreach+eval creates |
# usual rules, one for each $(fasmprog) in $(FASM_PROGRAMS). |
# Note that meta-rule is double-expanded, first |
# time as the arg of eval - it is the place where $(fasmprog) |
# gets expanded - and second time as the rule; |
# so all $ which are expected to expand at the second time should be escaped. |
# And all $ which are expected to be expanded by the shell should be escaped |
# twice, so they become $$$$. |
# The arguments of macro fasm_meta_rule: |
# $(1) = name of binary file, |
# $(2) = name of main source file. |
# $(3) = folder of binary file - without spaces. |
# $(4) = name of program - without path and extension, |
define fasm_meta_rule |
$(1): $(2) Makefile .deps/.dir $$(call respace,$$(addsuffix .dir,$(3))) |
fasm -m 65536 $$< "$$@" -s .deps/$(4).fas |
prepsrc .deps/$(4).fas /dev/null |
prepsrc .deps/$(4).fas /dev/stdout | (echo -n '$(1):' && \ |
perl -ne 's|\\|/|g;print " \\\n $$$$1" if /^;include \x27(.*?)\x27/' \ |
&& echo) > .deps/$(4).Po |
kpack --nologo "$$@" |
-include .deps/$(4).Po |
endef |
progname=$(call respace,$(basename $(notdir $(call binarypart,$(f))))) |
binarydir=$(subst ./,,$(dir $(call binarypart,$(f)))) |
$(foreach f,$(FASM_PROGRAMS),$(eval $(call fasm_meta_rule,$(fbinary),$(fsource),$(binarydir),$(progname)))) |
# Rule for the kernel differs: it uses kerpack instead of kpack. |
kernel.mnt: $(KERNEL)/kernel.asm Makefile .deps/.dir |
fasm -m 65536 $< "$@" -s .deps/kernel.fas |
prepsrc .deps/kernel.fas /dev/null |
prepsrc .deps/kernel.fas /dev/stdout | (echo -n 'kernel.mnt:' && \ |
perl -ne 's|\\|/|g;print " \\\n $$1" if /^;include \x27(.*?)\x27/' \ |
&& echo) > .deps/kernel.Po |
kerpack $@ |
-include .deps/kernel.Po |
# Rule for copying files is simpler, but similar to previous. |
define copy_meta_rule |
$(1): $(2) Makefile $$(call respace,$$(addsuffix .dir,$(3))) |
cp $$< "$$@" |
endef |
$(foreach f,$(COPY_FILES),$(eval $(call copy_meta_rule,$(fbinary),$(fsource),$(binarydir)))) |
# Special rules for copying sysfuncs.txt. |
docpak: $(DOCDIR)SYSFUNCS.TXT $(wildcard $(DOCDIR)*) |
$(DOCDIR)SYSFUNCS.TXT: $(KERNEL)/docs/sysfuncs.txt |
cp $(KERNEL)/docs/sysfuncs.txt $(DOCDIR)SYSFUNCS.TXT |
/data/eng/asciivju |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/eng/autorun.dat |
---|
0,0 → 1,12 |
# Program Parameters Delay |
/RD/1/COMMOUSE <NO> 1 # COM mice detector |
/RD/1/DRIVERS/ATIKMS -l/rd/1/drivers/ati.log -1 #ATI videodriver loader |
/RD/1/MEDIA/KIV \T__background.gif -1 # Desktop background image |
/RD/1/@CLIP <NO> 1 # Clipboard |
/RD/1/@RB <NO> 1 # Desktop right-click menu |
/RD/1/@SS <NO> 1 # Screensaver |
/RD/1/@PANEL <NO> 1 # Start panel |
/RD/1/SETUP BOOT 1 # Load device settings |
/RD/1/ICON BOOT 1 # Multithread icon |
/RD/1/NETWORK/ZEROCONF <NO> 1 # Network configuration |
### Hello, ASM World! ### |
/data/eng/background.gif |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/eng/default.skn |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/eng/demos/aclock |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/eng/demos/ak47.lif |
---|
0,0 → 1,71 |
#Life 1.05 |
#D AK47, a gun at 47 gens/shot. |
#D The AK47 reaction (middle) |
#D by Richard Schroeppel was |
#D known for years before |
#D stabilizers were found by |
#D Paul Callahan in July 1994. |
#D See also P94S. |
#N |
#P -23 -11 |
...** |
..*..* |
.*.*..* |
.*.*...* |
**.*.****** |
...*..*.* |
...***.*..* |
.**...*.*.* |
*..*.**.* |
.**...*.** |
...**....* |
...*.*...* |
**.*.....** |
.*.*.** |
.*.*..* |
..*..* |
...** |
#P -6 -12 |
**.......* |
**.....*** |
......* |
......** |
. |
...*** |
..*...* |
.*.....* |
.*.....* |
.*.....* |
..*...* |
...*** |
. |
. |
. |
. |
. |
. |
. |
. |
. |
....** |
.....* |
..***.....** |
..*.......** |
#P 12 -5 |
......** |
.....*..* |
....*.**.* |
.*...*.*.* |
.*...*.*.** |
*......* |
..*..*** |
..*.....** |
..*.**.*..* |
.**.*...** |
**...*** |
.**....* |
**..**.*.** |
....**.*.* |
....*..*.* |
.....*..* |
......** |
/data/eng/demos/barge.lif |
---|
0,0 → 1,406 |
#Life 1.05 |
#D c/3 spaceship extensible in 2 dimensions |
#D Hartmut Holzwart, David Bell |
#N |
#P -32 -50 |
...* |
..*.* |
.** |
..* |
.*.* |
.* |
* |
*.* |
*.* |
.**** |
...*.* |
...*.* |
..* |
..*** |
* |
*** |
.***.* |
...* |
...* |
...** |
#P -29 -29 |
** |
*..* |
*.** |
.*** |
.** |
...* |
.** |
..*.* |
...* |
. |
...* |
..*.* |
.** |
...* |
.** |
.*** |
*.** |
*..* |
** |
. |
** |
*..* |
*.** |
.*** |
.** |
...* |
.** |
..*.* |
...* |
. |
...* |
..*.* |
.** |
...* |
.** |
.*** |
*.** |
*..* |
** |
. |
** |
*..* |
*.** |
.*** |
.** |
...* |
.** |
..*.* |
...* |
. |
...* |
..*.* |
.** |
...* |
.** |
.*** |
*.** |
*..* |
** |
#P -32 31 |
...** |
...* |
...* |
.***.* |
*** |
* |
..*** |
..* |
...*.* |
...*.* |
.**** |
*.* |
*.* |
* |
.* |
.*.* |
..* |
.** |
..*.* |
...* |
#P -24 -29 |
..**.*.*.* |
.*...*..** |
*.....* |
.*......*.* |
...**..**.* |
..*...* |
..*.***...* |
..* |
...******** |
. |
...******** |
..* |
..*.***...* |
..*...* |
...**..**.* |
.*......*.* |
*.....* |
.*...*..** |
..**.*.*.* |
. |
..**.*.*.* |
.*...*..** |
*.....* |
.*......*.* |
...**..**.* |
..*...* |
..*.***...* |
..* |
...******** |
. |
...******** |
..* |
..*.***...* |
..*...* |
...**..**.* |
.*......*.* |
*.....* |
.*...*..** |
..**.*.*.* |
. |
..**.*.*.* |
.*...*..** |
*.....* |
.*......*.* |
...**..**.* |
..*...* |
..*.***...* |
..* |
...******** |
. |
...******** |
..* |
..*.***...* |
..*...* |
...**..**.* |
.*......*.* |
*.....* |
.*...*..** |
..**.*.*.* |
#P -12 -29 |
..**.*.*.* |
.*...*..** |
*.....* |
.*......*.* |
...**..**.* |
..*...* |
..*.***...* |
..* |
...******** |
. |
...******** |
..* |
..*.***...* |
..*...* |
...**..**.* |
.*......*.* |
*.....* |
.*...*..** |
..**.*.*.* |
. |
..**.*.*.* |
.*...*..** |
*.....* |
.*......*.* |
...**..**.* |
..*...* |
..*.***...* |
..* |
...******** |
. |
...******** |
..* |
..*.***...* |
..*...* |
...**..**.* |
.*......*.* |
*.....* |
.*...*..** |
..**.*.*.* |
. |
..**.*.*.* |
.*...*..** |
*.....* |
.*......*.* |
...**..**.* |
..*...* |
..*.***...* |
..* |
...******** |
. |
...******** |
..* |
..*.***...* |
..*...* |
...**..**.* |
.*......*.* |
*.....* |
.*...*..** |
..**.*.*.* |
#P 0 -29 |
..**.*.*.* |
.*...*..** |
*.....* |
.*......*.* |
...**..**.* |
..*...* |
..*.***...* |
..* |
...******** |
. |
...******** |
..* |
..*.***...* |
..*...* |
...**..**.* |
.*......*.* |
*.....* |
.*...*..** |
..**.*.*.* |
. |
..**.*.*.* |
.*...*..** |
*.....* |
.*......*.* |
...**..**.* |
..*...* |
..*.***...* |
..* |
...******** |
. |
...******** |
..* |
..*.***...* |
..*...* |
...**..**.* |
.*......*.* |
*.....* |
.*...*..** |
..**.*.*.* |
. |
..**.*.*.* |
.*...*..** |
*.....* |
.*......*.* |
...**..**.* |
..*...* |
..*.***...* |
..* |
...******** |
. |
...******** |
..* |
..*.***...* |
..*...* |
...**..**.* |
.*......*.* |
*.....* |
.*...*..** |
..**.*.*.* |
#P 12 -29 |
..**.*.*.* |
.*...*..** |
*.....* |
.*......*.* |
...**..**.* |
..*...* |
..*.***...* |
..* |
...******** |
. |
...******** |
..* |
..*.***...* |
..*...* |
...**..**.* |
.*......*.* |
*.....* |
.*...*..** |
..**.*.*.* |
. |
..**.*.*.* |
.*...*..** |
*.....* |
.*......*.* |
...**..**.* |
..*...* |
..*.***...* |
..* |
...******** |
. |
...******** |
..* |
..*.***...* |
..*...* |
...**..**.* |
.*......*.* |
*.....* |
.*...*..** |
..**.*.*.* |
. |
..**.*.*.* |
.*...*..** |
*.....* |
.*......*.* |
...**..**.* |
..*...* |
..*.***...* |
..* |
...******** |
. |
...******** |
..* |
..*.***...* |
..*...* |
...**..**.* |
.*......*.* |
*.....* |
.*...*..** |
..**.*.*.* |
#P 24 -29 |
..**.*.*.* |
.*...*..** |
*.....* |
.*......*.* |
...**..**.* |
..*...* |
..*.***...* |
..* |
...******** |
. |
...******** |
..* |
..*.***...* |
..*...* |
...**..**.* |
.*......*.* |
*.....* |
.*...*..** |
..**.*.*.* |
. |
..**.*.*.* |
.*...*..** |
*.....* |
.*......*.* |
...**..**.* |
..*...* |
..*.***...* |
..* |
...******** |
. |
...******** |
..* |
..*.***...* |
..*...* |
...**..**.* |
.*......*.* |
*.....* |
.*...*..** |
..**.*.*.* |
. |
..**.*.*.* |
.*...*..** |
*.....* |
.*......*.* |
...**..**.* |
..*...* |
..*.***...* |
..* |
...******** |
. |
...******** |
..* |
..*.***...* |
..*...* |
...**..**.* |
.*......*.* |
*.....* |
.*...*..** |
..**.*.*.* |
/data/eng/demos/life2 |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/eng/demos/relay.lif |
---|
0,0 → 1,12 |
#Life 1.05 |
#D Relay between two pentadecathlons |
#D Well known. |
#N |
#P -17 -2 |
********** |
#P -1 0 |
* |
.** |
** |
#P 8 2 |
********** |
/data/eng/demos/rpento.lif |
---|
0,0 → 1,13 |
#Life 1.05 |
#D r-pentomino |
#D A small, vigorous, common pattern. |
#D |
#D When the Game of Life was first |
#D introduced around 1970, this was |
#D proposed as the smallest pattern |
#D for which the outcome was unknown. |
#N |
#P 3 3 |
.** |
** |
.* |
/data/eng/demos/use_mb |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/eng/demos/web |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/eng/docs/COPYING.TXT |
---|
0,0 → 1,347 |
GNU GENERAL PUBLIC LICENSE |
Version 2, June 1991 |
Copyright (C) 1989, 1991 Free Software Foundation, Inc. |
675 Mass Ave, Cambridge, MA 02139, USA |
Everyone is permitted to copy and distribute verbatim copies |
of this license document, but changing it is not allowed. |
Preamble |
The licenses for most software are designed to take away your |
freedom to share and change it. By contrast, the GNU General Public |
License is intended to guarantee your freedom to share and change free |
software--to make sure the software is free for all its users. This |
General Public License applies to most of the Free Software |
Foundation's software and to any other program whose authors commit to |
using it. (Some other Free Software Foundation software is covered by |
the GNU Library General Public License instead.) You can apply it to |
your programs, too. |
When we speak of free software, we are referring to freedom, not |
price. Our General Public Licenses are designed to make sure that you |
have the freedom to distribute copies of free software (and charge for |
this service if you wish), that you receive source code or can get it |
if you want it, that you can change the software or use pieces of it |
in new free programs; and that you know you can do these things. |
To protect your rights, we need to make restrictions that forbid |
anyone to deny you these rights or to ask you to surrender the rights. |
These restrictions translate to certain responsibilities for you if you |
distribute copies of the software, or if you modify it. |
For example, if you distribute copies of such a program, whether |
gratis or for a fee, you must give the recipients all the rights that |
you have. You must make sure that they, too, receive or can get the |
source code. And you must show them these terms so they know their |
rights. |
We protect your rights with two steps: (1) copyright the software, and |
(2) offer you this license which gives you legal permission to copy, |
distribute and/or modify the software. |
Also, for each author's protection and ours, we want to make certain |
that everyone understands that there is no warranty for this free |
software. If the software is modified by someone else and passed on, we |
want its recipients to know that what they have is not the original, so |
that any problems introduced by others will not reflect on the original |
authors' reputations. |
Finally, any free program is threatened constantly by software |
patents. We wish to avoid the danger that redistributors of a free |
program will individually obtain patent licenses, in effect making the |
program proprietary. To prevent this, we have made it clear that any |
patent must be licensed for everyone's free use or not licensed at all. |
The precise terms and conditions for copying, distribution and |
modification follow. |
GNU GENERAL PUBLIC LICENSE |
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION |
0. This License applies to any program or other work which contains |
a notice placed by the copyright holder saying it may be distributed |
under the terms of this General Public License. The "Program", below, |
refers to any such program or work, and a "work based on the Program" |
means either the Program or any derivative work under copyright law: |
that is to say, a work containing the Program or a portion of it, |
either verbatim or with modifications and/or translated into another |
language. (Hereinafter, translation is included without limitation in |
the term "modification".) Each licensee is addressed as "you". |
Activities other than copying, distribution and modification are not |
covered by this License; they are outside its scope. The act of |
running the Program is not restricted, and the output from the Program |
is covered only if its contents constitute a work based on the |
Program (independent of having been made by running the Program). |
Whether that is true depends on what the Program does. |
1. You may copy and distribute verbatim copies of the Program's |
source code as you receive it, in any medium, provided that you |
conspicuously and appropriately publish on each copy an appropriate |
copyright notice and disclaimer of warranty; keep intact all the |
notices that refer to this License and to the absence of any warranty; |
and give any other recipients of the Program a copy of this License |
along with the Program. |
You may charge a fee for the physical act of transferring a copy, and |
you may at your option offer warranty protection in exchange for a fee. |
2. You may modify your copy or copies of the Program or any portion |
of it, thus forming a work based on the Program, and copy and |
distribute such modifications or work under the terms of Section 1 |
above, provided that you also meet all of these conditions: |
a) You must cause the modified files to carry prominent notices |
stating that you changed the files and the date of any change. |
b) You must cause any work that you distribute or publish, that in |
whole or in part contains or is derived from the Program or any |
part thereof, to be licensed as a whole at no charge to all third |
parties under the terms of this License. |
c) If the modified program normally reads commands interactively |
when run, you must cause it, when started running for such |
interactive use in the most ordinary way, to print or display an |
announcement including an appropriate copyright notice and a |
notice that there is no warranty (or else, saying that you provide |
a warranty) and that users may redistribute the program under |
these conditions, and telling the user how to view a copy of this |
License. (Exception: if the Program itself is interactive but |
does not normally print such an announcement, your work based on |
the Program is not required to print an announcement.) |
These requirements apply to the modified work as a whole. If |
identifiable sections of that work are not derived from the Program, |
and can be reasonably considered independent and separate works in |
themselves, then this License, and its terms, do not apply to those |
sections when you distribute them as separate works. But when you |
distribute the same sections as part of a whole which is a work based |
on the Program, the distribution of the whole must be on the terms of |
this License, whose permissions for other licensees extend to the |
entire whole, and thus to each and every part regardless of who wrote it. |
Thus, it is not the intent of this section to claim rights or contest |
your rights to work written entirely by you; rather, the intent is to |
exercise the right to control the distribution of derivative or |
collective works based on the Program. |
In addition, mere aggregation of another work not based on the Program |
with the Program (or with a work based on the Program) on a volume of |
a storage or distribution medium does not bring the other work under |
the scope of this License. |
3. You may copy and distribute the Program (or a work based on it, |
under Section 2) in object code or executable form under the terms of |
Sections 1 and 2 above provided that you also do one of the following: |
a) Accompany it with the complete corresponding machine-readable |
source code, which must be distributed under the terms of Sections |
1 and 2 above on a medium customarily used for software interchange; or, |
b) Accompany it with a written offer, valid for at least three |
years, to give any third party, for a charge no more than your |
cost of physically performing source distribution, a complete |
machine-readable copy of the corresponding source code, to be |
distributed under the terms of Sections 1 and 2 above on a medium |
customarily used for software interchange; or, |
c) Accompany it with the information you received as to the offer |
to distribute corresponding source code. (This alternative is |
allowed only for noncommercial distribution and only if you |
received the program in object code or executable form with such |
an offer, in accord with Subsection b above.) |
The source code for a work means the preferred form of the work for |
making modifications to it. For an executable work, complete source |
code means all the source code for all modules it contains, plus any |
associated interface definition files, plus the scripts used to |
control compilation and installation of the executable. However, as a |
special exception, the source code distributed need not include |
anything that is normally distributed (in either source or binary |
form) with the major components (compiler, kernel, and so on) of the |
operating system on which the executable runs, unless that component |
itself accompanies the executable. |
If distribution of executable or object code is made by offering |
access to copy from a designated place, then offering equivalent |
access to copy the source code from the same place counts as |
distribution of the source code, even though third parties are not |
compelled to copy the source along with the object code. |
4. You may not copy, modify, sublicense, or distribute the Program |
except as expressly provided under this License. Any attempt |
otherwise to copy, modify, sublicense or distribute the Program is |
void, and will automatically terminate your rights under this License. |
However, parties who have received copies, or rights, from you under |
this License will not have their licenses terminated so long as such |
parties remain in full compliance. |
5. You are not required to accept this License, since you have not |
signed it. However, nothing else grants you permission to modify or |
distribute the Program or its derivative works. These actions are |
prohibited by law if you do not accept this License. Therefore, by |
modifying or distributing the Program (or any work based on the |
Program), you indicate your acceptance of this License to do so, and |
all its terms and conditions for copying, distributing or modifying |
the Program or works based on it. |
6. Each time you redistribute the Program (or any work based on the |
Program), the recipient automatically receives a license from the |
original licensor to copy, distribute or modify the Program subject to |
these terms and conditions. You may not impose any further |
restrictions on the recipients' exercise of the rights granted herein. |
You are not responsible for enforcing compliance by third parties to |
this License. |
7. If, as a consequence of a court judgment or allegation of patent |
infringement or for any other reason (not limited to patent issues), |
conditions are imposed on you (whether by court order, agreement or |
otherwise) that contradict the conditions of this License, they do not |
excuse you from the conditions of this License. If you cannot |
distribute so as to satisfy simultaneously your obligations under this |
License and any other pertinent obligations, then as a consequence you |
may not distribute the Program at all. For example, if a patent |
license would not permit royalty-free redistribution of the Program by |
all those who receive copies directly or indirectly through you, then |
the only way you could satisfy both it and this License would be to |
refrain entirely from distribution of the Program. |
If any portion of this section is held invalid or unenforceable under |
any particular circumstance, the balance of the section is intended to |
apply and the section as a whole is intended to apply in other |
circumstances. |
It is not the purpose of this section to induce you to infringe any |
patents or other property right claims or to contest validity of any |
such claims; this section has the sole purpose of protecting the |
integrity of the free software distribution system, which is |
implemented by public license practices. Many people have made |
generous contributions to the wide range of software distributed |
through that system in reliance on consistent application of that |
system; it is up to the author/donor to decide if he or she is willing |
to distribute software through any other system and a licensee cannot |
impose that choice. |
This section is intended to make thoroughly clear what is believed to |
be a consequence of the rest of this License. |
8. If the distribution and/or use of the Program is restricted in |
certain countries either by patents or by copyrighted interfaces, the |
original copyright holder who places the Program under this License |
may add an explicit geographical distribution limitation excluding |
those countries, so that distribution is permitted only in or among |
countries not thus excluded. In such case, this License incorporates |
the limitation as if written in the body of this License. |
9. The Free Software Foundation may publish revised and/or new versions |
of the General Public License from time to time. Such new versions will |
be similar in spirit to the present version, but may differ in detail to |
address new problems or concerns. |
Each version is given a distinguishing version number. If the Program |
specifies a version number of this License which applies to it and "any |
later version", you have the option of following the terms and conditions |
either of that version or of any later version published by the Free |
Software Foundation. If the Program does not specify a version number of |
this License, you may choose any version ever published by the Free Software |
Foundation. |
10. If you wish to incorporate parts of the Program into other free |
programs whose distribution conditions are different, write to the author |
to ask for permission. For software which is copyrighted by the Free |
Software Foundation, write to the Free Software Foundation; we sometimes |
make exceptions for this. Our decision will be guided by the two goals |
of preserving the free status of all derivatives of our free software and |
of promoting the sharing and reuse of software generally. |
NO WARRANTY |
11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY |
FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN |
OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES |
PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED |
OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS |
TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE |
PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, |
REPAIR OR CORRECTION. |
12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING |
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR |
REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, |
INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING |
OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED |
TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY |
YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER |
PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE |
POSSIBILITY OF SUCH DAMAGES. |
END OF TERMS AND CONDITIONS |
Appendix: How to Apply These Terms to Your New Programs |
If you develop a new program, and you want it to be of the greatest |
possible use to the public, the best way to achieve this is to make it |
free software which everyone can redistribute and change under these terms. |
To do so, attach the following notices to the program. It is safest |
to attach them to the start of each source file to most effectively |
convey the exclusion of warranty; and each file should have at least |
the "copyright" line and a pointer to where the full notice is found. |
<one line to give the program's name and a brief idea of what it does.> |
Copyright (C) 19yy <name of author> |
This program is free software; you can redistribute it and/or modify |
it under the terms of the GNU General Public License as published by |
the Free Software Foundation; either version 2 of the License, or |
(at your option) any later version. |
This program is distributed in the hope that it will be useful, |
but WITHOUT ANY WARRANTY; without even the implied warranty of |
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
GNU General Public License for more details. |
You should have received a copy of the GNU General Public License |
along with this program; if not, write to the Free Software |
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. |
Also add information on how to contact you by electronic and paper mail. |
If the program is interactive, make it output a short notice like this |
when it starts in an interactive mode: |
Gnomovision version 69, Copyright (C) 19yy name of author |
Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. |
This is free software, and you are welcome to redistribute it |
under certain conditions; type `show c' for details. |
The hypothetical commands `show w' and `show c' should show the appropriate |
parts of the General Public License. Of course, the commands you use may |
be called something other than `show w' and `show c'; they could even be |
mouse-clicks or menu items--whatever suits your program. |
You should also get your employer (if you work as a programmer) or your |
school, if any, to sign a "copyright disclaimer" for the program, if |
necessary. Here is a sample; alter the names: |
Yoyodyne, Inc., hereby disclaims all copyright interest in the program |
`Gnomovision' (which makes passes at compilers) written by James Hacker. |
<signature of Ty Coon>, 1 April 1989 |
Ty Coon, President of Vice |
This General Public License does not permit incorporating your program into |
proprietary programs. If your program is a subroutine library, you may |
consider it more useful to permit linking proprietary applications with the |
library. If this is what you want to do, use the GNU Library General |
Public License instead of this License. |
/data/eng/docs/FARA.TXT |
---|
0,0 → 1,48 |
PHARAOH TOMB |
The purpose of the game is to open passage by moving hieroglyphs on entrance |
in the next room of the pharaoh tomb (8X8). You can exchange two hieroglyphs |
located near each other on vertical or horizontal if after such transposition |
a combination of three or more identical pictures abreast is generated. Such |
lines are disappeared immediately, and free place is filled by hieroglyphs |
which "falled" from top. Missing hieroglyphs are generated randomly. For |
disappearing hieroglyphs points are added. For combination of hieroglyphs |
number of points is calculated by formula L+(L+1)^(N-3), but no more than |
20*L*N, where N is number of hieroglyphs in combination, and L is level number. |
To pass to the next level it is required to remove certain number of |
hieroglyphs (different on each level). From below of panel with hieroglyphs is |
located field which indicates how many is passed and how many is remained. |
1st level - 500 |
2nd level - 450 |
3rd level - 400 |
4th level - 350 |
5th level - 300 |
6th level and further - 50*(L+1) |
On the first level combinations are composed from 6 states of hieroglyphs. |
With each new level one new hieroglyph is involved, but no more than 10 |
(i.e. starting from 5th level and further 10 different hieroglyphs are |
involved, not counting special ones). |
Starting from 2nd level for each combination from 4 and more hieroglyphs, |
and also for passing each fourth of level the player gets "free" hieroglyph - |
it is usual hieroglyph (generated randomly), which keeps "in pocket" of player |
and can be necessarily inserted by player to any place and replace thus |
located there hieroglyph. |
Starting from 3rd level for each combination from 5 and more hieroglyphs, |
and also for passing each third of level the player gets "universal key", |
which matches to any combination of hieroglyphs and to several different |
combination simultaneously. |
Starting from 4th level for each combination from 6 and more hieroglyphs, |
and also for passing a half of level the player gets "space crooker", |
which allows, when is used, to make 3 moves (not obligatory successive) at |
diagonal. |
The player can not have simultaneously more than 1 extra hieroglyph of each |
type (1 usual, 1 joker and 1 crooker). |
The game is ended, if the player can not make any combination with existing |
hieroglyphs. |
/data/eng/docs/FASM.TXT |
---|
0,0 → 1,3591 |
Üßßß |
ÜÜÛÜÜ ÜÜÜÜ ÜÜÜÜÜ ÜÜÜ ÜÜ |
Û Û Û Û Û Û |
Û ÜßßßßÛ ßßßßÜ Û Û Û |
Û ßÜÜÜÜÛÜ ÜÜÜÜÜß Û Û Û |
flat assembler 1.66 |
Programmer's Manual |
Table of contents |
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ |
Chapter 1 Introduction |
1.1 Compiler overview |
1.1.1 System requirements |
1.1.2 Executing compiler from command line |
1.1.3 Compiler messages |
1.1.4 Output formats |
1.2 Assembly syntax |
1.2.1 Instruction syntax |
1.2.2 Data definitions |
1.2.3 Constants and labels |
1.2.4 Numerical expressions |
1.2.5 Jumps and calls |
1.2.6 Size settings |
Chapter 2 Instruction set |
2.1 The x86 architecture instructions |
2.1.1 Data movement instructions |
2.1.2 Type conversion instructions |
2.1.3 Binary arithmetic instructions |
2.1.4 Decimal arithmetic instructions |
2.1.5 Logical instructions |
2.1.6 Control transfer instructions |
2.1.7 I/O instructions |
2.1.8 Strings operations |
2.1.9 Flag control instructions |
2.1.10 Conditional operations |
2.1.11 Miscellaneous instructions |
2.1.12 System instructions |
2.1.13 FPU instructions |
2.1.14 MMX instructions |
2.1.15 SSE instructions |
2.1.16 SSE2 instructions |
2.1.17 SSE3 instructions |
2.1.18 AMD 3DNow! instructions |
2.1.19 The x86-64 long mode instructions |
2.2 Control directives |
2.2.1 Numerical constants |
2.2.2 Conditional assembly |
2.2.3 Repeating blocks of instructions |
2.2.4 Addressing spaces |
2.2.5 Other directives |
2.2.6 Multiple passes |
2.3 Preprocessor directives |
2.3.1 Including source files |
2.3.2 Symbolic constants |
2.3.3 Macroinstructions |
2.3.4 Structures |
2.3.5 Repeating macroinstructions |
2.3.6 Conditional preprocessing |
2.3.7 Order of processing |
2.4 Formatter directives |
2.4.1 MZ executable |
2.4.2 Portable Executable |
2.4.3 Common Object File Format |
2.4.4 Executable and Linkable Format |
Chapter 1 Introduction |
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ |
This chapter contains all the most important information you need to begin |
using the flat assembler. If you are experienced assembly language programmer, |
you should read at least this chapter before using this compiler. |
1.1 Compiler overview |
Flat assembler is a fast assembly language compiler for the x86 architecture |
processors, which does multiple passes to optimize the size of generated |
machine code. It is self-compilable and versions for different operating |
systems are provided. All the versions are designed to be used from the system |
command line and they should not differ in behavior. |
1.1.1 System requirements |
All versions require the x86 architecture 32-bit processor (at least 80386), |
although they can produce programs for the x86 architecture 16-bit processors, |
too. DOS version requires an OS compatible with MS DOS 2.0 and either true |
real mode environment or DPMI. Windows version requires a Win32 console |
compatible with 3.1 version. |
1.1.2 Executing compiler from command line |
To execute flat assembler from the command line you need to provide two |
parameters - first should be name of source file, second should be name of |
destination file. If no second parameter is given, the name for output |
file will be guessed automatically. After displaying short information about |
the program name and version, compiler will read the data from source file and |
compile it. When the compilation is successful, compiler will write the |
generated code to the destination file and display the summary of compilation |
process; otherwise it will display the information about error that occurred. |
The source file should be a text file, and can be created in any text |
editor. Line breaks are accepted in both DOS and Unix standards, tabulators |
are treated as spaces. |
In the command line you can also include "-m" option followed by a number, |
which specifies how many kilobytes of memory flat assembler should maximally |
use. In case of DOS version this options limits only the usage of extended |
memory. The "-p" option followed by a number can be used to specify the limit |
for number of passes the assembler performs. If code cannot be generated |
within specified amount of passes, the assembly will be terminated with an |
error message. The maximum value of this setting is 65536, while the default |
limit, used when no such option is included in command line, is 100. |
It is also possible to limit the number of passes the assembler |
performs, with the "-p" option followed by a number specifying the maximum |
number of passes. |
There are no command line options that would affect the output of compiler, |
flat assembler requires only the source code to include the information it |
really needs. For example, to specify output format you specify it by using |
the "format" directive at the beginning of source. |
1.1.3 Compiler messages |
As it is stated above, after the successful compilation, the compiler displays |
the compilation summary. It includes the information of how many passes was |
done, how much time it took, and how many bytes were written into the |
destination file. |
The following is an example of the compilation summary: |
flat assembler version 1.66 |
38 passes, 5.3 seconds, 77824 bytes. |
In case of error during the compilation process, the program will display an |
error message. For example, when compiler can't find the input file, it will |
display the following message: |
flat assembler version 1.66 |
error: source file not found. |
If the error is connected with a specific part of source code, the source line |
that caused the error will be also displayed. Also placement of this line in |
the source is given to help you finding this error, for example: |
flat assembler version 1.66 |
example.asm [3]: |
mob ax,1 |
error: illegal instruction. |
It means that in the third line of the "example.asm" file compiler has |
encountered an unrecognized instruction. When the line that caused error |
contains a macroinstruction, also the line in macroinstruction definition |
that generated the erroneous instruction is displayed: |
flat assembler version 1.66 |
example.asm [6]: |
stoschar 7 |
example.asm [3] stoschar [1]: |
mob al,char |
error: illegal instruction. |
It means that the macroinstruction in the sixth line of the "example.asm" file |
generated an unrecognized instruction with the first line of its definition. |
1.1.4 Output formats |
By default, when there is no "format" directive in source file, flat |
assembler simply puts generated instruction codes into output, creating this |
way flat binary file. By default it generates 16-bit code, but you can always |
turn it into the 16-bit or 32-bit mode by using "use16" or "use32" directive. |
Some of the output formats switch into 32-bit mode, when selected - more |
information about formats which you can choose can be found in 2.4. |
All output code is always in the order in which it was entered into the |
source file. |
1.2 Assembly syntax |
The information provided below is intended mainly for the assembler |
programmers that have been using some other assembly compilers before. |
If you are beginner, you should look for the assembly programming tutorials. |
Flat assembler by default uses the Intel syntax for the assembly |
instructions, although you can customize it using the preprocessor |
capabilities (macroinstructions and symbolic constants). It also has its own |
set of the directives - the instructions for compiler. |
All symbols defined inside the sources are case-sensitive. |
1.2.1 Instruction syntax |
Instructions in assembly language are separated by line breaks, and one |
instruction is expected to fill the one line of text. If a line contains |
a semicolon, except for the semicolons inside the quoted strings, the rest of |
this line is the comment and compiler ignores it. If a line ends with "\" |
character (eventually the semicolon and comment may follow it), the next line |
is attached at this point. |
Each line in source is the sequence of items, which may be one of the three |
types. One type are the symbol characters, which are the special characters |
that are individual items even when are not spaced from the other ones. |
Any of the "+-*/=<>()[]{}:,|&~#`" is the symbol character. The sequence of |
other characters, separated from other items with either blank spaces or |
symbol characters, is a symbol. If the first character of symbol is either a |
single or double quote, it integrates the any sequence of characters following |
it, even the special ones, into a quoted string, which should end with the same |
character, with which it began (the single or double quote) - however if there |
are two such characters in a row (without any other character between them), |
they are integrated into quoted string as just one of them and the quoted |
string continues then. The symbols other than symbol characters and quoted |
strings can be used as names, so are also called the name symbols. |
Every instruction consists of the mnemonic and the various number of |
operands, separated with commas. The operand can be register, immediate value |
or a data addressed in memory, it can also be preceded by size operator to |
define or override its size (table 1.1). Names of available registers you can |
find in table 1.2, their sizes cannot be overridden. Immediate value can be |
specified by any numerical expression. |
When operand is a data in memory, the address of that data (also any |
numerical expression, but it may contain registers) should be enclosed in |
square brackets or preceded by "ptr" operator. For example instruction |
"mov eax,3" will put the immediate value 3 into the EAX register, instruction |
"mov eax,[7]" will put the 32-bit value from the address 7 into EAX and the |
instruction "mov byte [7],3" will put the immediate value 3 into the byte at |
address 7, it can also be written as "mov byte ptr 7,3". To specify which |
segment register should be used for addressing, segment register name followed |
by a colon should be put just before the address value (inside the square |
brackets or after the "ptr" operator). |
Table 1.1 Size operators |
ÚÄÄÄÄÄÄÄÄÄÄÂÄÄÄÄÄÄÂÄÄÄÄÄÄÄ¿ |
³ Operator ³ Bits ³ Bytes ³ |
ÆÍÍÍÍÍÍÍÍÍÍØÍÍÍÍÍÍØÍÍÍÍÍÍ͵ |
³ byte ³ 8 ³ 1 ³ |
³ word ³ 16 ³ 2 ³ |
³ dword ³ 32 ³ 4 ³ |
³ fword ³ 48 ³ 6 ³ |
³ pword ³ 48 ³ 6 ³ |
³ qword ³ 64 ³ 8 ³ |
³ tbyte ³ 80 ³ 10 ³ |
³ tword ³ 80 ³ 10 ³ |
³ dqword ³ 128 ³ 16 ³ |
ÀÄÄÄÄÄÄÄÄÄÄÁÄÄÄÄÄÄÁÄÄÄÄÄÄÄÙ |
Table 1.2 Registers |
ÚÄÄÄÄÄÄÄÄÄÂÄÄÄÄÄÄÂÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿ |
³ Type ³ Bits ³ ³ |
ÆÍÍÍÍÍÍÍÍÍØÍÍÍÍÍÍØÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ͵ |
³ ³ 8 ³ al cl dl bl ah ch dh bh ³ |
³ General ³ 16 ³ ax cx dx bx sp bp si di ³ |
³ ³ 32 ³ eax ecx edx ebx esp ebp esi edi ³ |
ÃÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´ |
³ Segment ³ 16 ³ es cs ss ds fs gs ³ |
ÃÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´ |
³ Control ³ 32 ³ cr0 cr2 cr3 cr4 ³ |
ÃÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´ |
³ Debug ³ 32 ³ dr0 dr1 dr2 dr3 dr6 dr7 ³ |
ÃÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´ |
³ FPU ³ 80 ³ st0 st1 st2 st3 st4 st5 st6 st7 ³ |
ÃÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´ |
³ MMX ³ 64 ³ mm0 mm1 mm2 mm3 mm4 mm5 mm6 mm7 ³ |
ÃÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´ |
³ SSE ³ 128 ³ xmm0 xmm1 xmm2 xmm3 xmm4 xmm5 xmm6 xmm7 ³ |
ÀÄÄÄÄÄÄÄÄÄÁÄÄÄÄÄÄÁÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ |
1.2.2 Data definitions |
To define data or reserve a space for it, use one of the directives listed in |
table 1.3. The data definition directive should be followed by one or more of |
numerical expressions, separated with commas. These expressions define the |
values for data cells of size depending on which directive is used. For |
example "db 1,2,3" will define the three bytes of values 1, 2 and 3 |
respectively. |
The "db" and "du" directives also accept the quoted string values of any |
length, which will be converted into chain of bytes when "db" is used and into |
chain of words with zeroed high byte when "du" is used. For example "db 'abc'" |
will define the three bytes of values 61, 62 and 63. |
The "dp" directive and its synonym "df" accept the values consisting of two |
numerical expressions separated with colon, the first value will become the |
high word and the second value will become the low double word of the far |
pointer value. Also "dd" accepts such pointers consisting of two word values |
separated with colon, and "dt" accepts the word and quad word value separated |
with colon, the quad word is stored first. The "dt" directive with single |
expression as parameter accepts only floating point values and creates data in |
FPU double extended precision format. |
Any of the above directive allows the usage of special "dup" operator to |
make multiple copies of given values. The count of duplicates should precede |
this operator and the value to duplicate should follow - it can even be the |
chain of values separated with commas, but such set of values needs to be |
enclosed with parenthesis, like "db 5 dup (1,2)", which defines five copies |
of the given two byte sequence. |
The "file" is a special directive and its syntax is different. This |
directive includes a chain of bytes from file and it should be followed by the |
quoted file name, then optionally numerical expression specifying offset in |
file preceded by the colon, and - also optionally - comma and numerical |
expression specifying count of bytes to include (if no count is specified, all |
data up to the end of file is included). For example "file 'data.bin'" will |
include the whole file as binary data and "file 'data.bin':10h,4" will include |
only four bytes starting at offset 10h. |
The data reservation directive should be followed by only one numerical |
expression, and this value defines how many cells of the specified size should |
be reserved. All data definition directives also accept the "?" value, which |
means that this cell should not be initialized to any value and the effect is |
the same as by using the data reservation directive. The uninitialized data |
may not be included in the output file, so its values should be always |
considered unknown. |
Table 1.3 Data directives |
ÚÄÄÄÄÄÄÄÄÄÂÄÄÄÄÄÄÄÄÂÄÄÄÄÄÄÄÄÄ¿ |
³ Size ³ Define ³ Reserve ³ |
³ (bytes) ³ data ³ data ³ |
ÆÍÍÍÍÍÍÍÍÍØÍÍÍÍÍÍÍÍØÍÍÍÍÍÍÍÍ͵ |
³ 1 ³ db ³ rb ³ |
³ ³ file ³ ³ |
ÃÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄ´ |
³ 2 ³ dw ³ rw ³ |
³ ³ du ³ ³ |
ÃÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄ´ |
³ 4 ³ dd ³ rd ³ |
ÃÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄ´ |
³ 6 ³ dp ³ rp ³ |
³ ³ df ³ rf ³ |
ÃÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄ´ |
³ 8 ³ dq ³ rq ³ |
ÃÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄ´ |
³ 10 ³ dt ³ rt ³ |
ÀÄÄÄÄÄÄÄÄÄÁÄÄÄÄÄÄÄÄÁÄÄÄÄÄÄÄÄÄÙ |
1.2.3 Constants and labels |
In the numerical expressions you can also use constants or labels instead of |
numbers. To define the constant or label you should use the specific |
directives. Each label can be defined only once and it is accessible from the |
any place of source (even before it was defined). Constant can be redefined |
many times, but in this case it is accessible only after it was defined, and |
is always equal to the value from last definition before the place where it's |
used. When a constant is defined only once in source, it is - like the label - |
accessible from anywhere. |
The definition of constant consists of name of the constant followed by the |
"=" character and numerical expression, which after calculation will become |
the value of constant. This value is always calculated at the time the |
constant is defined. For example you can define "count" constant by using the |
directive "count = 17", and then use it in the assembly instructions, like |
"mov cx,count" - which will become "mov cx,17" during the compilation process. |
There are different ways to define labels. The simplest is to follow the |
name of label by the colon, this directive can even be followed by the other |
instruction in the same line. It defines the label whose value is equal to |
offset of the point where it's defined. This method is usually used to label |
the places in code. The other way is to follow the name of label (without a |
colon) by some data directive. It defines the label with value equal to |
offset of the beginning of defined data, and remembered as a label for data |
with cell size as specified for that data directive in table 1.3. |
The label can be treated as constant of value equal to offset of labeled |
code or data. For example when you define data using the labeled directive |
"char db 224", to put the offset of this data into BX register you should use |
"mov bx,char" instruction, and to put the value of byte addressed by "char" |
label to DL register, you should use "mov dl,[char]" (or "mov dl,ptr char"). |
But when you try to assemble "mov ax,[char]", it will cause an error, because |
fasm compares the sizes of operands, which should be equal. You can force |
assembling that instruction by using size override: "mov ax,word [char]", but |
remember that this instruction will read the two bytes beginning at "char" |
address, while it was defined as a one byte. |
The last and the most flexible way to define labels is to use "label" |
directive. This directive should be followed by the name of label, then |
optionally size operator (it can be preceded by a colon) and then - also |
optionally "at" operator and the numerical expression defining the address at |
which this label should be defined. For example "label wchar word at char" |
will define a new label for the 16-bit data at the address of "char". Now the |
instruction "mov ax,[wchar]" will be after compilation the same as |
"mov ax,word [char]". If no address is specified, "label" directive defines |
the label at current offset. Thus "mov [wchar],57568" will copy two bytes |
while "mov [char],224" will copy one byte to the same address. |
The label whose name begins with dot is treated as local label, and its name |
is attached to the name of last global label (with name beginning with |
anything but dot) to make the full name of this label. So you can use the |
short name (beginning with dot) of this label anywhere before the next global |
label is defined, and in the other places you have to use the full name. Label |
beginning with two dots are the exception - they are like global, but they |
don't become the new prefix for local labels. |
The "@@" name means anonymous label, you can have defined many of them in |
the source. Symbol "@b" (or equivalent "@r") references the nearest preceding |
anonymous label, symbol "@f" references the nearest following anonymous label. |
These special symbol are case-insensitive. |
1.2.4 Numerical expressions |
In the above examples all the numerical expressions were the simple numbers, |
constants or labels. But they can be more complex, by using the arithmetical |
or logical operators for calculations at compile time. All these operators |
with their priority values are listed in table 1.4. |
The operations with higher priority value will be calculated first, you can |
of course change this behavior by putting some parts of expression into |
parenthesis. The "+", "-", "*" and "/" are standard arithmetical operations, |
"mod" calculates the remainder from division. The "and", "or", "xor", "shl", |
"shr" and "not" perform the same logical operations as assembly instructions |
of those names. The "rva" performs the conversion of an address into the |
relocatable offset and is specific to some of the output formats (see 2.4). |
The numbers in the expression are by default treated as a decimal, binary |
numbers should have the "b" letter attached at the end, octal number should |
end with "o" letter, hexadecimal numbers should begin with "0x" characters |
(like in C language) or with the "$" character (like in Pascal language) or |
they should end with "h" letter. Also quoted string, when encountered in |
expression, will be converted into number - the first character will become |
the least significant byte of number. |
The numerical expression used as an address value can also contain any of |
general registers used for addressing, they can be added and multiplied by |
appropriate values, as it is allowed for the x86 architecture instructions. |
There are also some special symbols that can be used inside the numerical |
expression. First is "$", which is always equal to the value of current |
offset, while "$$" is equal to base address of current addressing space. The |
other one is "%", which is the number of current repeat in parts of code that |
are repeated using some special directives (see 2.2). There's also "%t" |
symbol, which is always equal to the current time stamp. |
Any numerical expression can also consist of single floating point value |
(flat assembler does not allow any floating point operations at compilation |
time) in the scientific notation, they can end with the "f" letter to be |
recognized, otherwise they should contain at least one of the "." or "E" |
characters. So "1.0", "1E0" and "1f" define the same floating point value, |
while simple "1" defines an integer value. |
Table 1.4 Arithmetical and logical operators by priority |
ÚÄÄÄÄÄÄÄÄÄÄÂÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿ |
³ Priority ³ Operators ³ |
ÆÍÍÍÍÍÍÍÍÍÍØÍÍÍÍÍÍÍÍÍÍÍÍÍ͵ |
³ 0 ³ + - ³ |
ÃÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´ |
³ 1 ³ * / ³ |
ÃÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´ |
³ 2 ³ mod ³ |
ÃÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´ |
³ 3 ³ and or xor ³ |
ÃÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´ |
³ 4 ³ shl shr ³ |
ÃÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´ |
³ 5 ³ not ³ |
ÃÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´ |
³ 6 ³ rva ³ |
ÀÄÄÄÄÄÄÄÄÄÄÁÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ |
1.2.5 Jumps and calls |
The operand of any jump or call instruction can be preceded not only by the |
size operator, but also by one of the operators specifying type of the jump: |
"short", "near" of "far". For example, when assembler is in 16-bit mode, |
instruction "jmp dword [0]" will become the far jump and when assembler is |
in 32-bit mode, it will become the near jump. To force this instruction to be |
treated differently, use the "jmp near dword [0]" or "jmp far dword [0]" form. |
When operand of near jump is the immediate value, assembler will generate |
the shortest variant of this jump instruction if possible (but won't create |
32-bit instruction in 16-bit mode nor 16-bit instruction in 32-bit mode, |
unless there is a size operator stating it). By specifying the jump type |
you can force it to always generate long variant (for example "jmp near 0") |
or to always generate short variant and terminate with an error when it's |
impossible (for example "jmp short 0"). |
1.2.6 Size settings |
When instruction uses some memory addressing, by default the smallest form of |
instruction is generated by using the short displacement if only address |
value fits in the range. This can be overridden using the "word" or "dword" |
operator before the address inside the square brackets (or after the "ptr" |
operator), which forces the long displacement of appropriate size to be made. |
In case when address is not relative to any registers, those operators allow |
also to choose the appropriate mode of absolute addressing. |
Instructions "adc", "add", "and", "cmp", "or", "sbb", "sub" and "xor" with |
first operand being 16-bit or 32-bit are by default generated in shortened |
8-bit form when the second operand is immediate value fitting in the range |
for signed 8-bit values. It also can be overridden by putting the "word" or |
"dword" operator before the immediate value. The similar rules applies to the |
"imul" instruction with the last operand being immediate value. |
Immediate value as an operand for "push" instruction without a size operator |
is by default treated as a word value if assembler is in 16-bit mode and as a |
double word value if assembler is in 32-bit mode, shorter 8-bit form of this |
instruction is used if possible, "word" or "dword" size operator forces the |
"push" instruction to be generated in longer form for specified size. "pushw" |
and "pushd" mnemonics force assembler to generate 16-bit or 32-bit code |
without forcing it to use the longer form of instruction. |
Chapter 2 Instruction set |
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ |
This chapter provides the detailed information about the instructions and |
directives supported by flat assembler. Directives for defining labels were |
already discussed in 1.2.3, all other directives will be described later in |
this chapter. |
2.1 The x86 architecture instructions |
In this section you can find both the information about the syntax and |
purpose the assembly language instructions. If you need more technical |
information, look for the Intel Architecture Software Developer's Manual. |
Assembly instructions consist of the mnemonic (instruction's name) and from |
zero to three operands. If there are two or more operands, usually first is |
the destination operand and second is the source operand. Each operand can be |
register, memory or immediate value (see 1.2 for details about syntax of |
operands). After the description of each instruction there are examples |
of different combinations of operands, if the instruction has any. |
Some instructions act as prefixes and can be followed by other instruction |
in the same line, and there can be more than one prefix in a line. Each name |
of the segment register is also a mnemonic of instruction prefix, altough it |
is recommended to use segment overrides inside the square brackets instead of |
these prefixes. |
2.1.1 Data movement instructions |
"mov" transfers a byte, word or double word from the source operand to the |
destination operand. It can transfer data between general registers, from |
the general register to memory, or from memory to general register, but it |
cannot move from memory to memory. It can also transfer an immediate value to |
general register or memory, segment register to general register or memory, |
general register or memory to segment register, control or debug register to |
general register and general register to control or debug register. The "mov" |
can be assembled only if the size of source operand and size of destination |
operand are the same. Below are the examples for each of the allowed |
combinations: |
mov bx,ax ; general register to general register |
mov [char],al ; general register to memory |
mov bl,[char] ; memory to general register |
mov dl,32 ; immediate value to general register |
mov [char],32 ; immediate value to memory |
mov ax,ds ; segment register to general register |
mov [bx],ds ; segment register to memory |
mov ds,ax ; general register to segment register |
mov ds,[bx] ; memory to segment register |
mov eax,cr0 ; control register to general register |
mov cr3,ebx ; general register to control register |
"xchg" swaps the contents of two operands. It can swap two byte operands, |
two word operands or two double word operands. Order of operands is not |
important. The operands may be two general registers, or general register |
with memory. For example: |
xchg ax,bx ; swap two general registers |
xchg al,[char] ; swap register with memory |
"push" decrements the stack frame pointer (ESP register), then transfers |
the operand to the top of stack indicated by ESP. The operand can be memory, |
general register, segment register or immediate value of word or double word |
size. If operand is an immediate value and no size is specified, it is by |
default treated as a word value if assembler is in 16-bit mode and as a double |
word value if assembler is in 32-bit mode. "pushw" and "pushd" mnemonics are |
variants of this instruction that store the values of word or double word size |
respectively. If more operands follow in the same line (separated only with |
spaces, not commas), compiler will assemble chain of the "push" instructions |
with these operands. The examples are with single operands: |
push ax ; store general register |
push es ; store segment register |
pushw [bx] ; store memory |
push 1000h ; store immediate value |
"pusha" saves the contents of the eight general register on the stack. |
This instruction has no operands. There are two version of this instruction, |
one 16-bit and one 32-bit, assembler automatically generates the appropriate |
version for current mode, but it can be overridden by using "pushaw" or |
"pushad" mnemonic to always get the 16-bit or 32-bit version. The 16-bit |
version of this instruction pushes general registers on the stack in the |
following order: AX, CX, DX, BX, the initial value of SP before AX was pushed, |
BP, SI and DI. The 32-bit version pushes equivalent 32-bit general registers |
in the same order. |
"pop" transfers the word or double word at the current top of stack to the |
destination operand, and then increments ESP to point to the new top of stack. |
The operand can be memory, general register or segment register. "popw" and |
"popd" mnemonics are variants of this instruction for restoring the values of |
word or double word size respectively. If more operands separated with spaces |
follow in the same line, compiler will assemble chain of the "pop" |
instructions with these operands. |
pop bx ; restore general register |
pop ds ; restore segment register |
popw [si] ; restore memory |
"popa" restores the registers saved on the stack by "pusha" instruction, |
except for the saved value of SP (or ESP), which is ignored. This instruction |
has no operands. To force assembling 16-bit or 32-bit version of this |
instruction use "popaw" or "popad" mnemonic. |
2.1.2 Type conversion instructions |
The type conversion instructions convert bytes into words, words into double |
words, and double words into quad words. These conversions can be done using |
the sign extension or zero extension. The sign extension fills the extra bits |
of the larger item with the value of the sign bit of the smaller item, the |
zero extension simply fills them with zeros. |
"cwd" and "cdq" double the size of value AX or EAX register respectively |
and store the extra bits into the DX or EDX register. The conversion is done |
using the sign extension. These instructions have no operands. |
"cbw" extends the sign of the byte in AL throughout AX, and "cwde" extends |
the sign of the word in AX throughout EAX. These instructions also have no |
operands. |
"movsx" converts a byte to word or double word and a word to double word |
using the sign extension. "movzx" does the same, but it uses the zero |
extension. The source operand can be general register or memory, while the |
destination operand must be a general register. For example: |
movsx ax,al ; byte register to word register |
movsx edx,dl ; byte register to double word register |
movsx eax,ax ; word register to double word register |
movsx ax,byte [bx] ; byte memory to word register |
movsx edx,byte [bx] ; byte memory to double word register |
movsx eax,word [bx] ; word memory to double word register |
2.1.3 Binary arithmetic instructions |
"add" replaces the destination operand with the sum of the source and |
destination operands and sets CF if overflow has occurred. The operands may |
be bytes, words or double words. The destination operand can be general |
register or memory, the source operand can be general register or immediate |
value, it can also be memory if the destination operand is register. |
add ax,bx ; add register to register |
add ax,[si] ; add memory to register |
add [di],al ; add register to memory |
add al,48 ; add immediate value to register |
add [char],48 ; add immediate value to memory |
"adc" sums the operands, adds one if CF is set, and replaces the destination |
operand with the result. Rules for the operands are the same as for the "add" |
instruction. An "add" followed by multiple "adc" instructions can be used to |
add numbers longer than 32 bits. |
"inc" adds one to the operand, it does not affect CF. The operand can be a |
general register or memory, and the size of the operand can be byte, word or |
double word. |
inc ax ; increment register by one |
inc byte [bx] ; increment memory by one |
"sub" subtracts the source operand from the destination operand and replaces |
the destination operand with the result. If a borrow is required, the CF is |
set. Rules for the operands are the same as for the "add" instruction. |
"sbb" subtracts the source operand from the destination operand, subtracts |
one if CF is set, and stores the result to the destination operand. Rules for |
the operands are the same as for the "add" instruction. A "sub" followed by |
multiple "sbb" instructions may be used to subtract numbers longer than 32 |
bits. |
"dec" subtracts one from the operand, it does not affect CF. Rules for the |
operand are the same as for the "inc" instruction. |
"cmp" subtracts the source operand from the destination operand. It updates |
the flags as the "sub" instruction, but does not alter the source and |
destination operands. Rules for the operands are the same as for the "sub" |
instruction. |
"neg" subtracts a signed integer operand from zero. The effect of this |
instructon is to reverse the sign of the operand from positive to negative or |
from negative to positive. Rules for the operand are the same as for the "inc" |
instruction. |
"xadd" exchanges the destination operand with the source operand, then loads |
the sum of the two values into the destination operand. Rules for the operands |
are the same as for the "add" instruction. |
All the above binary arithmetic instructions update SF, ZF, PF and OF flags. |
SF is always set to the same value as the result's sign bit, ZF is set when |
all the bits of result are zero, PF is set when low order eight bits of result |
contain an even number of set bits, OF is set if result is too large for a |
positive number or too small for a negative number (excluding sign bit) to fit |
in destination operand. |
"mul" performs an unsigned multiplication of the operand and the |
accumulator. If the operand is a byte, the processor multiplies it by the |
contents of AL and returns the 16-bit result to AH and AL. If the operand is a |
word, the processor multiplies it by the contents of AX and returns the 32-bit |
result to DX and AX. If the operand is a double word, the processor multiplies |
it by the contents of EAX and returns the 64-bit result in EDX and EAX. "mul" |
sets CF and OF when the upper half of the result is nonzero, otherwise they |
are cleared. Rules for the operand are the same as for the "inc" instruction. |
"imul" performs a signed multiplication operation. This instruction has |
three variations. First has one operand and behaves in the same way as the |
"mul" instruction. Second has two operands, in this case destination operand |
is multiplied by the source operand and the result replaces the destination |
operand. Destination operand must be a general register, it can be word or |
double word, source operand can be general register, memory or immediate |
value. Third form has three operands, the destination operand must be a |
general register, word or double word in size, source operand can be general |
register or memory, and third operand must be an immediate value. The source |
operand is multiplied by the immediate value and the result is stored in the |
destination register. All the three forms calculate the product to twice the |
size of operands and set CF and OF when the upper half of the result is |
nonzero, but second and third form truncate the product to the size of |
operands. So second and third forms can be also used for unsigned operands |
because, whether the operands are signed or unsigned, the lower half of the |
product is the same. Below are the examples for all three forms: |
imul bl ; accumulator by register |
imul word [si] ; accumulator by memory |
imul bx,cx ; register by register |
imul bx,[si] ; register by memory |
imul bx,10 ; register by immediate value |
imul ax,bx,10 ; register by immediate value to register |
imul ax,[si],10 ; memory by immediate value to register |
"div" performs an unsigned division of the accumulator by the operand. |
The dividend (the accumulator) is twice the size of the divisor (the operand), |
the quotient and remainder have the same size as the divisor. If divisor is |
byte, the dividend is taken from AX register, the quotient is stored in AL and |
the remainder is stored in AH. If divisor is word, the upper half of dividend |
is taken from DX, the lower half of dividend is taken from AX, the quotient is |
stored in AX and the remainder is stored in DX. If divisor is double word, |
the upper half of dividend is taken from EDX, the lower half of dividend is |
taken from EAX, the quotient is stored in EAX and the remainder is stored in |
EDX. Rules for the operand are the same as for the "mul" instruction. |
"idiv" performs a signed division of the accumulator by the operand. |
It uses the same registers as the "div" instruction, and the rules for |
the operand are the same. |
2.1.4 Decimal arithmetic instructions |
Decimal arithmetic is performed by combining the binary arithmetic |
instructions (already described in the prior section) with the decimal |
arithmetic instructions. The decimal arithmetic instructions are used to |
adjust the results of a previous binary arithmetic operation to produce a |
valid packed or unpacked decimal result, or to adjust the inputs to a |
subsequent binary arithmetic operation so the operation will produce a valid |
packed or unpacked decimal result. |
"daa" adjusts the result of adding two valid packed decimal operands in |
AL. "daa" must always follow the addition of two pairs of packed decimal |
numbers (one digit in each half-byte) to obtain a pair of valid packed |
decimal digits as results. The carry flag is set if carry was needed. |
This instruction has no operands. |
"das" adjusts the result of subtracting two valid packed decimal operands |
in AL. "das" must always follow the subtraction of one pair of packed decimal |
numbers (one digit in each half-byte) from another to obtain a pair of valid |
packed decimal digits as results. The carry flag is set if a borrow was |
needed. This instruction has no operands. |
"aaa" changes the contents of register AL to a valid unpacked decimal |
number, and zeroes the top four bits. "aaa" must always follow the addition |
of two unpacked decimal operands in AL. The carry flag is set and AH is |
incremented if a carry is necessary. This instruction has no operands. |
"aas" changes the contents of register AL to a valid unpacked decimal |
number, and zeroes the top four bits. "aas" must always follow the |
subtraction of one unpacked decimal operand from another in AL. The carry flag |
is set and AH decremented if a borrow is necessary. This instruction has no |
operands. |
"aam" corrects the result of a multiplication of two valid unpacked decimal |
numbers. "aam" must always follow the multiplication of two decimal numbers |
to produce a valid decimal result. The high order digit is left in AH, the |
low order digit in AL. The generalized version of this instruction allows |
adjustment of the contents of the AX to create two unpacked digits of any |
number base. The standard version of this instruction has no operands, the |
generalized version has one operand - an immediate value specifying the |
number base for the created digits. |
"aad" modifies the numerator in AH and AL to prepare for the division of two |
valid unpacked decimal operands so that the quotient produced by the division |
will be a valid unpacked decimal number. AH should contain the high order |
digit and AL the low order digit. This instruction adjusts the value and |
places the result in AL, while AH will contain zero. The generalized version |
of this instruction allows adjustment of two unpacked digits of any number |
base. Rules for the operand are the same as for the "aam" instruction. |
2.1.5 Logical instructions |
"not" inverts the bits in the specified operand to form a one's |
complement of the operand. It has no effect on the flags. Rules for the |
operand are the same as for the "inc" instruction. |
"and", "or" and "xor" instructions perform the standard |
logical operations. They update the SF, ZF and PF flags. Rules for the |
operands are the same as for the "add" instruction. |
"bt", "bts", "btr" and "btc" instructions operate on a single bit which can |
be in memory or in a general register. The location of the bit is specified |
as an offset from the low order end of the operand. The value of the offset |
is the taken from the second operand, it either may be an immediate byte or |
a general register. These instructions first assign the value of the selected |
bit to CF. "bt" instruction does nothing more, "bts" sets the selected bit to |
1, "btr" resets the selected bit to 0, "btc" changes the bit to its |
complement. The first operand can be word or double word. |
bt ax,15 ; test bit in register |
bts word [bx],15 ; test and set bit in memory |
btr ax,cx ; test and reset bit in register |
btc word [bx],cx ; test and complement bit in memory |
"bsf" and "bsr" instructions scan a word or double word for first set bit |
and store the index of this bit into destination operand, which must be |
general register. The bit string being scanned is specified by source operand, |
it may be either general register or memory. The ZF flag is set if the entire |
string is zero (no set bits are found); otherwise it is cleared. If no set bit |
is found, the value of the destination register is undefined. "bsf" scans from |
low order to high order (starting from bit index zero). "bsr" scans from high |
order to low order (starting from bit index 15 of a word or index 31 of a |
double word). |
bsf ax,bx ; scan register forward |
bsr ax,[si] ; scan memory reverse |
"shl" shifts the destination operand left by the number of bits specified |
in the second operand. The destination operand can be byte, word, or double |
word general register or memory. The second operand can be an immediate value |
or the CL register. The processor shifts zeros in from the right (low order) |
side of the operand as bits exit from the left side. The last bit that exited |
is stored in CF. "sal" is a synonym for "shl". |
shl al,1 ; shift register left by one bit |
shl byte [bx],1 ; shift memory left by one bit |
shl ax,cl ; shift register left by count from cl |
shl word [bx],cl ; shift memory left by count from cl |
"shr" and "sar" shift the destination operand right by the number of bits |
specified in the second operand. Rules for operands are the same as for the |
"shl" instruction. "shr" shifts zeros in from the left side of the operand as |
bits exit from the right side. The last bit that exited is stored in CF. |
"sar" preserves the sign of the operand by shifting in zeros on the left side |
if the value is positive or by shifting in ones if the value is negative. |
"shld" shifts bits of the destination operand to the left by the number |
of bits specified in third operand, while shifting high order bits from the |
source operand into the destination operand on the right. The source operand |
remains unmodified. The destination operand can be a word or double word |
general register or memory, the source operand must be a general register, |
third operand can be an immediate value or the CL register. |
shld ax,bx,1 ; shift register left by one bit |
shld [di],bx,1 ; shift memory left by one bit |
shld ax,bx,cl ; shift register left by count from cl |
shld [di],bx,cl ; shift memory left by count from cl |
"shrd" shifts bits of the destination operand to the right, while shifting |
low order bits from the source operand into the destination operand on the |
left. The source operand remains unmodified. Rules for operands are the same |
as for the "shld" instruction. |
"rol" and "rcl" rotate the byte, word or double word destination operand |
left by the number of bits specified in the second operand. For each rotation |
specified, the high order bit that exits from the left of the operand returns |
at the right to become the new low order bit. "rcl" additionally puts in CF |
each high order bit that exits from the left side of the operand before it |
returns to the operand as the low order bit on the next rotation cycle. Rules |
for operands are the same as for the "shl" instruction. |
"ror" and "rcr" rotate the byte, word or double word destination operand |
right by the number of bits specified in the second operand. For each rotation |
specified, the low order bit that exits from the right of the operand returns |
at the left to become the new high order bit. "rcr" additionally puts in CF |
each low order bit that exits from the right side of the operand before it |
returns to the operand as the high order bit on the next rotation cycle. |
Rules for operands are the same as for the "shl" instruction. |
"test" performs the same action as the "and" instruction, but it does not |
alter the destination operand, only updates flags. Rules for the operands are |
the same as for the "and" instruction. |
"bswap" reverses the byte order of a 32-bit general register: bits 0 through |
7 are swapped with bits 24 through 31, and bits 8 through 15 are swapped with |
bits 16 through 23. This instruction is provided for converting little-endian |
values to big-endian format and vice versa. |
bswap edx ; swap bytes in register |
2.1.6 Control transfer instructions |
"jmp" unconditionally transfers control to the target location. The |
destination address can be specified directly within the instruction or |
indirectly through a register or memory, the acceptable size of this address |
depends on whether the jump is near or far (it can be specified by preceding |
the operand with "near" or "far" operator) and whether the instruction is |
16-bit or 32-bit. Operand for near jump should be "word" size for 16-bit |
instruction or the "dword" size for 32-bit instruction. Operand for far jump |
should be "dword" size for 16-bit instruction or "pword" size for 32-bit |
instruction. A direct "jmp" instruction includes the destination address as |
part of the instruction (and can be preceded by "short", "near" or "far" |
operator), the operand specifying address should be the numerical expression |
for near or short jump, or two numerical expressions separated with colon for |
far jump, the first specifies selector of segment, the second is the offset |
within segment. The "pword" operator can be used to force the 32-bit far call, |
and "dword" to force the 16-bit far call. An indirect "jmp" instruction |
obtains the destination address indirectly through a register or a pointer |
variable, the operand should be general register or memory. See also 1.2.5 for |
some more details. |
jmp 100h ; direct near jump |
jmp 0FFFFh:0 ; direct far jump |
jmp ax ; indirect near jump |
jmp pword [ebx] ; indirect far jump |
"call" transfers control to the procedure, saving on the stack the address |
of the instruction following the "call" for later use by a "ret" (return) |
instruction. Rules for the operands are the same as for the "jmp" instruction, |
but the "call" has no short variant of direct instruction and thus it not |
optimized. |
"ret", "retn" and "retf" instructions terminate the execution of a procedure |
and transfers control back to the program that originally invoked the |
procedure using the address that was stored on the stack by the "call" |
instruction. "ret" is the equivalent for "retn", which returns from the |
procedure that was executed using the near call, while "retf" returns from |
the procedure that was executed using the far call. These instructions default |
to the size of address appropriate for the current code setting, but the size |
of address can be forced to 16-bit by using the "retw", "retnw" and "retfw" |
mnemonics, and to 32-bit by using the "retd", "retnd" and "retfd" mnemonics. |
All these instructions may optionally specify an immediate operand, by adding |
this constant to the stack pointer, they effectively remove any arguments that |
the calling program pushed on the stack before the execution of the "call" |
instruction. |
"iret" returns control to an interrupted procedure. It differs from "ret" in |
that it also pops the flags from the stack into the flags register. The flags |
are stored on the stack by the interrupt mechanism. It defaults to the size of |
return address appropriate for the current code setting, but it can be forced |
to use 16-bit or 32-bit address by using the "iretw" or "iretd" mnemonic. |
The conditional transfer instructions are jumps that may or may not transfer |
control, depending on the state of the CPU flags when the instruction |
executes. The mnemonics for conditional jumps may be obtained by attaching |
the condition mnemonic (see table 2.1) to the "j" mnemonic, |
for example "jc" instruction will transfer the control when the CF flag is |
set. The conditional jumps can be short or near, and direct only, and can be |
optimized (see 1.2.5), the operand should be an immediate value specifying |
target address. |
Table 2.1 Conditions |
ÚÄÄÄÄÄÄÄÄÄÄÂÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÂÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿ |
³ Mnemonic ³ Condition tested ³ Description ³ |
ÆÍÍÍÍÍÍÍÍÍÍØÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍØÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ͵ |
³ o ³ OF = 1 ³ overflow ³ |
ÃÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´ |
³ no ³ OF = 0 ³ not overflow ³ |
ÃÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´ |
³ c ³ ³ carry ³ |
³ b ³ CF = 1 ³ below ³ |
³ nae ³ ³ not above nor equal ³ |
ÃÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´ |
³ nc ³ ³ not carry ³ |
³ ae ³ CF = 0 ³ above or equal ³ |
³ nb ³ ³ not below ³ |
ÃÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´ |
³ e ³ ZF = 1 ³ equal ³ |
³ z ³ ³ zero ³ |
ÃÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´ |
³ ne ³ ZF = 0 ³ not equal ³ |
³ nz ³ ³ not zero ³ |
ÃÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´ |
³ be ³ CF or ZF = 1 ³ below or equal ³ |
³ na ³ ³ not above ³ |
ÃÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´ |
³ a ³ CF or ZF = 0 ³ above ³ |
³ nbe ³ ³ not below nor equal ³ |
ÃÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´ |
³ s ³ SF = 1 ³ sign ³ |
ÃÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´ |
³ ns ³ SF = 0 ³ not sign ³ |
ÃÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´ |
³ p ³ PF = 1 ³ parity ³ |
³ pe ³ ³ parity even ³ |
ÃÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´ |
³ np ³ PF = 0 ³ not parity ³ |
³ po ³ ³ parity odd ³ |
ÃÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´ |
³ l ³ SF xor OF = 1 ³ less ³ |
³ nge ³ ³ not greater nor equal ³ |
ÃÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´ |
³ ge ³ SF xor OF = 0 ³ greater or equal ³ |
³ nl ³ ³ not less ³ |
ÃÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´ |
³ le ³ (SF xor OF) or ZF = 1 ³ less or equal ³ |
³ ng ³ ³ not greater ³ |
ÃÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´ |
³ g ³ (SF xor OF) or ZF = 0 ³ greater ³ |
³ nle ³ ³ not less nor equal ³ |
ÀÄÄÄÄÄÄÄÄÄÄÁÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÁÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ |
The "loop" instructions are conditional jumps that use a value placed in |
CX (or ECX) to specify the number of repetitions of a software loop. All |
"loop" instructions automatically decrement CX (or ECX) and terminate the |
loop (don't transfer the control) when CX (or ECX) is zero. It uses CX or ECX |
whether the current code setting is 16-bit or 32-bit, but it can be forced to |
us CX with the "loopw" mnemonic or to use ECX with the "loopd" mnemonic. |
"loope" and "loopz" are the synonyms for the same instruction, which acts as |
the standard "loop", but also terminates the loop when ZF flag is set. |
"loopew" and "loopzw" mnemonics force them to use CX register while "looped" |
and "loopzd" force them to use ECX register. "loopne" and "loopnz" are the |
synonyms for the same instructions, which acts as the standard "loop", but |
also terminate the loop when ZF flag is not set. "loopnew" and "loopnzw" |
mnemonics force them to use CX register while "loopned" and "loopnzd" force |
them to use ECX register. Every "loop" instruction needs an operand being an |
immediate value specifying target address, it can be only short jump (in the |
range of 128 bytes back and 127 bytes forward from the address of instruction |
following the "loop" instruction). |
"jcxz" branches to the label specified in the instruction if it finds a |
value of zero in CX, "jecxz" does the same, but checks the value of ECX |
instead of CX. Rules for the operands are the same as for the "loop" |
instruction. |
"int" activates the interrupt service routine that corresponds to the |
number specified as an operand to the instruction, the number should be in |
range from 0 to 255. The interrupt service routine terminates with an "iret" |
instruction that returns control to the instruction that follows "int". |
"int3" mnemonic codes the short (one byte) trap that invokes the interrupt 3. |
"into" instruction invokes the interrupt 4 if the OF flag is set. |
"bound" verifies that the signed value contained in the specified register |
lies within specified limits. An interrupt 5 occurs if the value contained in |
the register is less than the lower bound or greater than the upper bound. It |
needs two operands, the first operand specifies the register being tested, |
the second operand should be memory address for the two signed limit values. |
The operands can be "word" or "dword" in size. |
bound ax,[bx] ; check word for bounds |
bound eax,[esi] ; check double word for bounds |
2.1.7 I/O instructions |
"in" transfers a byte, word, or double word from an input port to AL, AX, |
or EAX. I/O ports can be addressed either directly, with the immediate byte |
value coded in instruction, or indirectly via the DX register. The destination |
operand should be AL, AX, or EAX register. The source operand should be an |
immediate value in range from 0 to 255, or DX register. |
in al,20h ; input byte from port 20h |
in ax,dx ; input word from port addressed by dx |
"out" transfers a byte, word, or double word to an output port from AL, AX, |
or EAX. The program can specify the number of the port using the same methods |
as the "in" instruction. The destination operand should be an immediate value |
in range from 0 to 255, or DX register. The source operand should be AL, AX, |
or EAX register. |
out 20h,ax ; output word to port 20h |
out dx,al ; output byte to port addressed by dx |
2.1.8 Strings operations |
The string operations operate on one element of a string. A string element |
may be a byte, a word, or a double word. The string elements are addressed by |
SI and DI (or ESI and EDI) registers. After every string operation SI and/or |
DI (or ESI and/or EDI) are automatically updated to point to the next element |
of the string. If DF (direction flag) is zero, the index registers are |
incremented, if DF is one, they are decremented. The amount of the increment |
or decrement is 1, 2, or 4 depending on the size of the string element. Every |
string operation instruction has short forms which have no operands and use |
SI and/or DI when the code type is 16-bit, and ESI and/or EDI when the code |
type is 32-bit. SI and ESI by default address data in the segment selected |
by DS, DI and EDI always address data in the segment selected by ES. Short |
form is obtained by attaching to the mnemonic of string operation letter |
specifying the size of string element, it should be "b" for byte element, |
"w" for word element, and "d" for double word element. Full form of string |
operation needs operands providing the size operator and the memory addresses, |
which can be SI or ESI with any segment prefix, DI or EDI always with ES |
segment prefix. |
"movs" transfers the string element pointed to by SI (or ESI) to the |
location pointed to by DI (or EDI). Size of operands can be byte, word, or |
double word. The destination operand should be memory addressed by DI or EDI, |
the source operand should be memory addressed by SI or ESI with any segment |
prefix. |
movs byte [di],[si] ; transfer byte |
movs word [es:di],[ss:si] ; transfer word |
movsd ; transfer double word |
"cmps" subtracts the destination string element from the source string |
element and updates the flags AF, SF, PF, CF and OF, but it does not change |
any of the compared elements. If the string elements are equal, ZF is set, |
otherwise it is cleared. The first operand for this instruction should be the |
source string element addressed by SI or ESI with any segment prefix, the |
second operand should be the destination string element addressed by DI or |
EDI. |
cmpsb ; compare bytes |
cmps word [ds:si],[es:di] ; compare words |
cmps dword [fs:esi],[edi] ; compare double words |
"scas" subtracts the destination string element from AL, AX, or EAX |
(depending on the size of string element) and updates the flags AF, SF, ZF, |
PF, CF and OF. If the values are equal, ZF is set, otherwise it is cleared. |
The operand should be the destination string element addressed by DI or EDI. |
scas byte [es:di] ; scan byte |
scasw ; scan word |
scas dword [es:edi] ; scan double word |
"stos" places the value of AL, AX, or EAX into the destination string |
element. Rules for the operand are the same as for the "scas" instruction. |
"lods" places the source string element into AL, AX, or EAX. The operand |
should be the source string element addressed by SI or ESI with any segment |
prefix. |
lods byte [ds:si] ; load byte |
lods word [cs:si] ; load word |
lodsd ; load double word |
"ins" transfers a byte, word, or double word from an input port addressed |
by DX register to the destination string element. The destination operand |
should be memory addressed by DI or EDI, the source operand should be the DX |
register. |
insb ; input byte |
ins word [es:di],dx ; input word |
ins dword [edi],dx ; input double word |
"outs" transfers the source string element to an output port addressed by |
DX register. The destination operand should be the DX register and the source |
operand should be memory addressed by SI or ESI with any segment prefix. |
outs dx,byte [si] ; output byte |
outsw ; output word |
outs dx,dword [gs:esi] ; output double word |
The repeat prefixes "rep", "repe"/"repz", and "repne"/"repnz" specify |
repeated string operation. When a string operation instruction has a repeat |
prefix, the operation is executed repeatedly, each time using a different |
element of the string. The repetition terminates when one of the conditions |
specified by the prefix is satisfied. All three prefixes automatically |
decrease CX or ECX register (depending whether string operation instruction |
uses the 16-bit or 32-bit addressing) after each operation and repeat the |
associated operation until CX or ECX is zero. "repe"/"repz" and |
"repne"/"repnz" are used exclusively with the "scas" and "cmps" instructions |
(described below). When these prefixes are used, repetition of the next |
instruction depends on the zero flag (ZF) also, "repe" and "repz" terminate |
the execution when the ZF is zero, "repne" and "repnz" terminate the execution |
when the ZF is set. |
rep movsd ; transfer multiple double words |
repe cmpsb ; compare bytes until not equal |
2.1.9 Flag control instructions |
The flag control instructions provide a method for directly changing the |
state of bits in the flag register. All instructions described in this |
section have no operands. |
"stc" sets the CF (carry flag) to 1, "clc" zeroes the CF, "cmc" changes the |
CF to its complement. "std" sets the DF (direction flag) to 1, "cld" zeroes |
the DF, "sti" sets the IF (interrupt flag) to 1 and therefore enables the |
interrupts, "cli" zeroes the IF and therefore disables the interrupts. |
"lahf" copies SF, ZF, AF, PF, and CF to bits 7, 6, 4, 2, and 0 of the |
AH register. The contents of the remaining bits are undefined. The flags |
remain unaffected. |
"sahf" transfers bits 7, 6, 4, 2, and 0 from the AH register into SF, ZF, |
AF, PF, and CF. |
"pushf" decrements "esp" by two or four and stores the low word or |
double word of flags register at the top of stack, size of stored data |
depends on the current code setting. "pushfw" variant forces storing the |
word and "pushfd" forces storing the double word. |
"popf" transfers specific bits from the word or double word at the top |
of stack, then increments "esp" by two or four, this value depends on |
the current code setting. "popfw" variant forces restoring from the word |
and "popfd" forces restoring from the double word. |
2.1.10 Conditional operations |
The instructions obtained by attaching the condition mnemonic (see table |
2.1) to the "set" mnemonic set a byte to one if the condition is true and set |
the byte to zero otherwise. The operand should be an 8-bit be general register |
or the byte in memory. |
setne al ; set al if zero flag cleared |
seto byte [bx] ; set byte if overflow |
"salc" instruction sets the all bits of AL register when the carry flag is |
set and zeroes the AL register otherwise. This instruction has no arguments. |
The instructions obtained by attaching the condition mnemonic to the "cmov" |
mnemonic transfer the word or double word from the general register or memory |
to the general register only when the condition is true. The destination |
operand should be general register, the source operand can be general register |
or memory. |
cmove ax,bx ; move when zero flag set |
cmovnc eax,[ebx] ; move when carry flag cleared |
"cmpxchg" compares the value in the AL, AX, or EAX register with the |
destination operand. If the two values are equal, the source operand is |
loaded into the destination operand. Otherwise, the destination operand is |
loaded into the AL, AX, or EAX register. The destination operand may be a |
general register or memory, the source operand must be a general register. |
cmpxchg dl,bl ; compare and exchange with register |
cmpxchg [bx],dx ; compare and exchange with memory |
"cmpxchg8b" compares the 64-bit value in EDX and EAX registers with the |
destination operand. If the values are equal, the 64-bit value in ECX and EBX |
registers is stored in the destination operand. Otherwise, the value in the |
destination operand is loaded into EDX and EAX registers. The destination |
operand should be a quad word in memory. |
cmpxchg8b [bx] ; compare and exchange 8 bytes |
2.1.11 Miscellaneous instructions |
"nop" instruction occupies one byte but affects nothing but the instruction |
pointer. This instruction has no operands and doesn't perform any operation. |
"ud2" instruction generates an invalid opcode exception. This instruction |
is provided for software testing to explicitly generate an invalid opcode. |
This is instruction has no operands. |
"xlat" replaces a byte in the AL register with a byte indexed by its value |
in a translation table addressed by BX or EBX. The operand should be a byte |
memory addressed by BX or EBX with any segment prefix. This instruction has |
also a short form "xlatb" which has no operands and uses the BX or EBX address |
in the segment selected by DS depending on the current code setting. |
"lds" transfers a pointer variable from the source operand to DS and the |
destination register. The source operand must be a memory operand, and the |
destination operand must be a general register. The DS register receives the |
segment selector of the pointer while the destination register receives the |
offset part of the pointer. "les", "lfs", "lgs" and "lss" operate identically |
to "lds" except that rather than DS register the ES, FS, GS and SS is used |
respectively. |
lds bx,[si] ; load pointer to ds:bx |
"lea" transfers the offset of the source operand (rather than its value) |
to the destination operand. The source operand must be a memory operand, and |
the destination operand must be a general register. |
lea dx,[bx+si+1] ; load effective address to dx |
"cpuid" returns processor identification and feature information in the |
EAX, EBX, ECX, and EDX registers. The information returned is selected by |
entering a value in the EAX register before the instruction is executed. |
This instruction has no operands. |
"pause" instruction delays the execution of the next instruction an |
implementation specific amount of time. It can be used to improve the |
performance of spin wait loops. This instruction has no operands. |
"enter" creates a stack frame that may be used to implement the scope rules |
of block-structured high-level languages. A "leave" instruction at the end of |
a procedure complements an "enter" at the beginning of the procedure to |
simplify stack management and to control access to variables for nested |
procedures. The "enter" instruction includes two parameters. The first |
parameter specifies the number of bytes of dynamic storage to be allocated on |
the stack for the routine being entered. The second parameter corresponds to |
the lexical nesting level of the routine, it can be in range from 0 to 31. |
The specified lexical level determines how many sets of stack frame pointers |
the CPU copies into the new stack frame from the preceding frame. This list |
of stack frame pointers is sometimes called the display. The first word (or |
double word when code is 32-bit) of the display is a pointer to the last stack |
frame. This pointer enables a "leave" instruction to reverse the action of the |
previous "enter" instruction by effectively discarding the last stack frame. |
After "enter" creates the new display for a procedure, it allocates the |
dynamic storage space for that procedure by decrementing ESP by the number of |
bytes specified in the first parameter. To enable a procedure to address its |
display, "enter" leaves BP (or EBP) pointing to the beginning of the new stack |
frame. If the lexical level is zero, "enter" pushes BP (or EBP), copies SP to |
BP (or ESP to EBP) and then subtracts the first operand from ESP. For nesting |
levels greater than zero, the processor pushes additional frame pointers on |
the stack before adjusting the stack pointer. |
enter 2048,0 ; enter and allocate 2048 bytes on stack |
2.1.12 System instructions |
"lmsw" loads the operand into the machine status word (bits 0 through 15 of |
CR0 register), while "smsw" stores the machine status word into the |
destination operand. The operand for both those instructions can be 16-bit |
general register or memory, for "smsw" it can also be 32-bit general |
register. |
lmsw ax ; load machine status from register |
smsw [bx] ; store machine status to memory |
"lgdt" and "lidt" instructions load the values in operand into the global |
descriptor table register or the interrupt descriptor table register |
respectively. "sgdt" and "sidt" store the contents of the global descriptor |
table register or the interrupt descriptor table register in the destination |
operand. The operand should be a 6 bytes in memory. |
lgdt [ebx] ; load global descriptor table |
"lldt" loads the operand into the segment selector field of the local |
descriptor table register and "sldt" stores the segment selector from the |
local descriptor table register in the operand. "ltr" loads the operand into |
the segment selector field of the task register and "str" stores the segment |
selector from the task register in the operand. Rules for operand are the same |
as for the "lmsw" and "smsw" instructions. |
"lar" loads the access rights from the segment descriptor specified by |
the selector in source operand into the destination operand and sets the ZF |
flag. The destination operand can be a 16-bit or 32-bit general register. |
The source operand should be a 16-bit general register or memory. |
lar ax,[bx] ; load access rights into word |
lar eax,dx ; load access rights into double word |
"lsl" loads the segment limit from the segment descriptor specified by the |
selector in source operand into the destination operand and sets the ZF flag. |
Rules for operand are the same as for the "lar" instruction. |
"verr" and "verw" verify whether the code or data segment specified with |
the operand is readable or writable from the current privilege level. The |
operand should be a word, it can be general register or memory. If the segment |
is accessible and readable (for "verr") or writable (for "verw") the ZF flag |
is set, otherwise it's cleared. Rules for operand are the same as for the |
"lldt" instruction. |
"arpl" compares the RPL (requestor's privilege level) fields of two segment |
selectors. The first operand contains one segment selector and the second |
operand contains the other. If the RPL field of the destination operand is |
less than the RPL field of the source operand, the ZF flag is set and the RPL |
field of the destination operand is increased to match that of the source |
operand. Otherwise, the ZF flag is cleared and no change is made to the |
destination operand. The destination operand can be a word general register |
or memory, the source operand must be a general register. |
arpl bx,ax ; adjust RPL of selector in register |
arpl [bx],ax ; adjust RPL of selector in memory |
"clts" clears the TS (task switched) flag in the CR0 register. This |
instruction has no operands. |
"lock" prefix causes the processor's bus-lock signal to be asserted during |
execution of the accompanying instruction. In a multiprocessor environment, |
the bus-lock signal insures that the processor has exclusive use of any shared |
memory while the signal is asserted. The "lock" prefix can be prepended only |
to the following instructions and only to those forms of the instructions |
where the destination operand is a memory operand: "add", "adc", "and", "btc", |
"btr", "bts", "cmpxchg", "cmpxchg8b", "dec", "inc", "neg", "not", "or", "sbb", |
"sub", "xor", "xadd" and "xchg". If the "lock" prefix is used with one of |
these instructions and the source operand is a memory operand, an undefined |
opcode exception may be generated. An undefined opcode exception will also be |
generated if the "lock" prefix is used with any instruction not in the above |
list. The "xchg" instruction always asserts the bus-lock signal regardless of |
the presence or absence of the "lock" prefix. |
"hlt" stops instruction execution and places the processor in a halted |
state. An enabled interrupt, a debug exception, the BINIT, INIT or the RESET |
signal will resume execution. This instruction has no operands. |
"invlpg" invalidates (flushes) the TLB (translation lookaside buffer) entry |
specified with the operand, which should be a memory. The processor determines |
the page that contains that address and flushes the TLB entry for that page. |
"rdmsr" loads the contents of a 64-bit MSR (model specific register) of the |
address specified in the ECX register into registers EDX and EAX. "wrmsr" |
writes the contents of registers EDX and EAX into the 64-bit MSR of the |
address specified in the ECX register. "rdtsc" loads the current value of the |
processor's time stamp counter from the 64-bit MSR into the EDX and EAX |
registers. The processor increments the time stamp counter MSR every clock |
cycle and resets it to 0 whenever the processor is reset. "rdpmc" loads the |
contents of the 40-bit performance monitoring counter specified in the ECX |
register into registers EDX and EAX. These instructions have no operands. |
"wbinvd" writes back all modified cache lines in the processor's internal |
cache to main memory and invalidates (flushes) the internal caches. The |
instruction then issues a special function bus cycle that directs external |
caches to also write back modified data and another bus cycle to indicate that |
the external caches should be invalidated. This instruction has no operands. |
"rsm" return program control from the system management mode to the program |
that was interrupted when the processor received an SMM interrupt. This |
instruction has no operands. |
"sysenter" executes a fast call to a level 0 system procedure, "sysexit" |
executes a fast return to level 3 user code. The addresses used by these |
instructions are stored in MSRs. These instructions have no operands. |
2.1.13 FPU instructions |
The FPU (Floating-Point Unit) instructions operate on the floating-point |
values in three formats: single precision (32-bit), double precision (64-bit) |
and double extended precision (80-bit). The FPU registers form the stack and |
each of them holds the double extended precision floating-point value. When |
some values are pushed onto the stack or are removed from the top, the FPU |
registers are shifted, so ST0 is always the value on the top of FPU stack, ST1 |
is the first value below the top, etc. The ST0 name has also the synonym ST. |
"fld" pushes the floating-point value onto the FPU register stack. The |
operand can be 32-bit, 64-bit or 80-bit memory location or the FPU register, |
its value is then loaded onto the top of FPU register stack (the ST0 |
register) and is automatically converted into the double extended precision |
format. |
fld dword [bx] ; load single prevision value from memory |
fld st2 ; push value of st2 onto register stack |
"fld1", "fldz", "fldl2t", "fldl2e", "fldpi", "fldlg2" and "fldln2" load the |
commonly used contants onto the FPU register stack. The loaded constants are |
+1.0, +0.0, lb 10, lb e, pi, lg 2 and ln 2 respectively. These instructions |
have no operands. |
"fild" convert the singed integer source operand into double extended |
precision floating-point format and pushes the result onto the FPU register |
stack. The source operand can be a 16-bit, 32-bit or 64-bit memory location. |
fild qword [bx] ; load 64-bit integer from memory |
"fst" copies the value of ST0 register to the destination operand, which |
can be 32-bit or 64-bit memory location or another FPU register. "fstp" |
performs the same operation as "fst" and then pops the register stack, |
getting rid of ST0. "fstp" accepts the same operands as the "fst" instruction |
and can also store value in the 80-bit memory. |
fst st3 ; copy value of st0 into st3 register |
fstp tword [bx] ; store value in memory and pop stack |
"fist" converts the value in ST0 to a signed integer and stores the result |
in the destination operand. The operand can be 16-bit or 32-bit memory |
location. "fistp" performs the same operation and then pops the register |
stack, it accepts the same operands as the "fist" instruction and can also |
store integer value in the 64-bit memory, so it has the same rules for |
operands as "fild" instruction. |
"fbld" converts the packed BCD integer into double extended precision |
floating-point format and pushes this value onto the FPU stack. "fbstp" |
converts the value in ST0 to an 18-digit packed BCD integer, stores the result |
in the destination operand, and pops the register stack. The operand should be |
an 80-bit memory location. |
"fadd" adds the destination and source operand and stores the sum in the |
destination location. The destination operand is always an FPU register, if |
the source is a memory location, the destination is ST0 register and only |
source operand should be specified. If both operands are FPU registers, at |
least one of them should be ST0 register. An operand in memory can be a |
32-bit or 64-bit value. |
fadd qword [bx] ; add double precision value to st0 |
fadd st2,st0 ; add st0 to st2 |
"faddp" adds the destination and source operand, stores the sum in the |
destination location and then pops the register stack. The destination operand |
must be an FPU register and the source operand must be the ST0. When no |
operands are specified, ST1 is used as a destination operand. |
faddp ; add st0 to st1 and pop the stack |
faddp st2,st0 ; add st0 to st2 and pop the stack |
"fiadd" instruction converts an integer source operand into double extended |
precision floating-point value and adds it to the destination operand. The |
operand should be a 16-bit or 32-bit memory location. |
fiadd word [bx] ; add word integer to st0 |
"fsub", "fsubr", "fmul", "fdiv", "fdivr" instruction are similar to "fadd", |
have the same rules for operands and differ only in the perfomed computation. |
"fsub" substracts the source operand from the destination operand, "fsubr" |
substract the destination operand from the source operand, "fmul" multiplies |
the destination and source operands, "fdiv" divides the destination operand by |
the source operand and "fdivr" divides the source operand by the destination |
operand. "fsubp", "fsubrp", "fmulp", "fdivp", "fdivrp" perform the same |
operations and pop the register stack, the rules for operand are the same as |
for the "faddp" instruction. "fisub", "fisubr", "fimul", "fidiv", "fidivr" |
perform these operations after converting the integer source operand into |
floating-point value, they have the same rules for operands as "fiadd" |
instruction. |
"fsqrt" computes the square root of the value in ST0 register, "fsin" |
computes the sine of that value, "fcos" computes the cosine of that value, |
"fchs" complements its sign bit, "fabs" clears its sign to create the absolute |
value, "frndint" rounds it to the nearest integral value, depending on the |
current rounding mode. "f2xm1" computes the exponential value of 2 to the |
power of ST0 and substracts the 1.0 from it, the value of ST0 must lie in the |
range -1.0 to +1.0. All these instruction store the result in ST0 and have no |
operands. |
"fsincos" computes both the sine and the cosine of the value in ST0 |
register, stores the sine in ST0 and pushes the cosine on the top of FPU |
register stack. "fptan" computes the tangent of the value in ST0, stores the |
result in ST0 and pushes a 1.0 onto the FPU register stack. "fpatan" computes |
the arctangent of the value in ST1 divided by the value in ST0, stores the |
result in ST1 and pops the FPU register stack. "fyl2x" computes the binary |
logarithm of ST0, multiplies it by ST1, stores the result in ST1 and pops the |
FPU register stack; "fyl2xp1" performs the same operation but it adds 1.0 to |
ST0 before computing the logarithm. "fprem" computes the remainder obtained |
from dividing the value in ST0 by the value in ST1, and stores the result |
in ST0. "fprem1" performs the same operation as "fprem", but it computes the |
remainder in the way specified by IEEE Standard 754. "fscale" truncates the |
value in ST1 and increases the exponent of ST0 by this value. "fxtract" |
separates the value in ST0 into its exponent and significand, stores the |
exponent in ST0 and pushes the significand onto the register stack. "fnop" |
performs no operation. These instruction have no operands. |
"fxch" exchanges the contents of ST0 an another FPU register. The operand |
should be an FPU register, if no operand is specified, the contents of ST0 and |
ST1 are exchanged. |
"fcom" and "fcomp" compare the contents of ST0 and the source operand and |
set flags in the FPU status word according to the results. "fcomp" |
additionally pops the register stack after performing the comparison. The |
operand can be a single or double precision value in memory or the FPU |
register. When no operand is specified, ST1 is used as a source operand. |
fcom ; compare st0 with st1 |
fcomp st2 ; compare st0 with st2 and pop stack |
"fcompp" compares the contents of ST0 and ST1, sets flags in the FPU status |
word according to the results and pops the register stack twice. This |
instruction has no operands. |
"fucom", "fucomp" and "fucompp" performs an unordered comparison of two FPU |
registers. Rules for operands are the same as for the "fcom", "fcomp" and |
"fcompp", but the source operand must be an FPU register. |
"ficom" and "ficomp" compare the value in ST0 with an integer source operand |
and set the flags in the FPU status word according to the results. "ficomp" |
additionally pops the register stack after performing the comparison. The |
integer value is converted to double extended precision floating-point format |
before the comparison is made. The operand should be a 16-bit or 32-bit |
memory location. |
ficom word [bx] ; compare st0 with 16-bit integer |
"fcomi", "fcomip", "fucomi", "fucomip" perform the comparison of ST0 with |
another FPU register and set the ZF, PF and CF flags according to the results. |
"fcomip" and "fucomip" additionaly pop the register stack after performing the |
comparison. The instructions obtained by attaching the FPU condition mnemonic |
(see table 2.2) to the "fcmov" mnemonic transfer the specified FPU register |
into ST0 register if the fiven test condition is true. These instruction |
allow two different syntaxes, one with single operand specifying the source |
FPU register, and one with two operands, in that case destination operand |
should be ST0 register and the second operand specifies the source FPU |
register. |
fcomi st2 ; compare st0 with st2 and set flags |
fcmovb st0,st2 ; transfer st2 to st0 if below |
Table 2.2 FPU conditions |
ÚÄÄÄÄÄÄÄÄÄÄÂÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÂÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿ |
³ Mnemonic ³ Condition tested ³ Description ³ |
ÆÍÍÍÍÍÍÍÍÍÍØÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍØÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ͵ |
³ b ³ CF = 1 ³ below ³ |
³ e ³ ZF = 1 ³ equal ³ |
³ be ³ CF or ZF = 1 ³ below or equal ³ |
³ u ³ PF = 1 ³ unordered ³ |
³ nb ³ CF = 0 ³ not below ³ |
³ ne ³ ZF = 0 ³ not equal ³ |
³ nbe ³ CF and ZF = 0 ³ not below nor equal ³ |
³ nu ³ PF = 0 ³ not unordered ³ |
ÀÄÄÄÄÄÄÄÄÄÄÁÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÁÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ |
"ftst" compares the value in ST0 with 0.0 and sets the flags in the FPU |
status word according to the results. "fxam" examines the contents of the ST0 |
and sets the flags in FPU status word to indicate the class of value in the |
register. These instructions have no operands. |
"fstsw" and "fnstsw" store the current value of the FPU status word in the |
destination location. The destination operand can be either a 16-bit memory or |
the AX register. "fstsw" checks for pending umasked FPU exceptions before |
storing the status word, "fnstsw" does not. |
"fstcw" and "fnstcw" store the current value of the FPU control word at the |
specified destination in memory. "fstcw" checks for pending umasked FPU |
exceptions before storing the control word, "fnstcw" does not. "fldcw" loads |
the operand into the FPU control word. The operand should be a 16-bit memory |
location. |
"fstenv" and "fnstenv" store the current FPU operating environment at the |
memory location specified with the destination operand, and then mask all FPU |
exceptions. "fstenv" checks for pending umasked FPU exceptions before |
proceeding, "fnstenv" does not. "fldenv" loads the complete operating |
environment from memory into the FPU. "fsave" and "fnsave" store the current |
FPU state (operating environment and register stack) at the specified |
destination in memory and reinitializes the FPU. "fsave" check for pending |
unmasked FPU exceptions before proceeding, "fnsave" does not. "frstor" |
loads the FPU state from the specified memory location. All these instructions |
need an operand being a memory location. |
"finit" and "fninit" set the FPU operating environment into its default |
state. "finit" checks for pending unmasked FPU exception before proceeding, |
"fninit" does not. "fclex" and "fnclex" clear the FPU exception flags in the |
FPU status word. "fclex" checks for pending unmasked FPU exception before |
proceeding, "fnclex" does not. "wait" and "fwait" are synonyms for the same |
instruction, which causes the processor to check for pending unmasked FPU |
exceptions and handle them before proceeding. These instruction have no |
operands. |
"ffree" sets the tag associated with specified FPU register to empty. The |
operand should be an FPU register. |
"fincstp" and "fdecstp" rotate the FPU stack by one by adding or |
substracting one to the pointer of the top of stack. These instruction have no |
operands. |
2.1.14 MMX instructions |
The MMX instructions operate on the packed integer types and use the MMX |
registers, which are the low 64-bit parts of the 80-bit FPU registers. Because |
of this MMX instructions cannot be used at the same time as FPU instructions. |
They can operate on packed bytes (eight 8-bit integers), packed words (four |
16-bit integers) or packed double words (two 32-bit integers), use of packed |
formats allows to perform operations on multiple data at one time. |
"movq" copies a quad word from the source operand to the destination |
operand. At least one of the operands must be a MMX register, the second one |
can be also a MMX register or 64-bit memory location. |
movq mm0,mm1 ; move quad word from register to register |
movq mm2,[ebx] ; move quad word from memory to register |
"movd" copies a double word from the source operand to the destination |
operand. One of the operands must be a MMX register, the second one can be a |
general register or 32-bit memory location. Only low double word of MMX |
register is used. |
All general MMX operations have two operands, the destination operand should |
be a MMX register, the source operand can be a MMX register or 64-bit memory |
location. Operation is performed on the corresponding data elements of the |
source and destination operand and stored in the data elements of the |
destination operand. "paddb", "paddw" and "paddd" perform the addition of |
packed bytes, packed words, or packed double words. "psubb", "psubw" and |
"psubd" perform the substraction of appropriate types. "paddsb", "paddsw", |
"psubsb" and "psubsw" perform the addition or substraction of packed bytes |
or packed words with the signed saturation. "paddusb", "paddusw", "psubusb", |
"psubusw" are analoguous, but with unsigned saturation. "pmulhw" and "pmullw" |
performs a signed multiply of the packed words and store the high or low words |
of the results in the destination operand. "pmaddwd" performs a multiply of |
the packed words and adds the four intermediate double word products in pairs |
to produce result as a packed double words. "pand", "por" and "pxor" perform |
the logical operations on the quad words, "pandn" peforms also a logical |
negation of the destination operand before performing the "and" operation. |
"pcmpeqb", "pcmpeqw" and "pcmpeqd" compare for equality of packed bytes, |
packed words or packed double words. If a pair of data elements is equal, the |
corresponding data element in the destination operand is filled with bits of |
value 1, otherwise it's set to 0. "pcmpgtb", "pcmpgtw" and "pcmpgtd" perform |
the similar operation, but they check whether the data elements in the |
destination operand are greater than the correspoding data elements in the |
source operand. "packsswb" converts packed signed words into packed signed |
bytes, "packssdw" converts packed signed double words into packed signed |
words, using saturation to handle overflow conditions. "packuswb" converts |
packed signed words into packed unsigned bytes. Converted data elements from |
the source operand are stored in the low part of the destination operand, |
while converted data elements from the destination operand are stored in the |
high part. "punpckhbw", "punpckhwd" and "punpckhdq" interleaves the data |
elements from the high parts of the source and destination operands and |
stores the result into the destination operand. "punpcklbw", "punpcklwd" and |
"punpckldq" perform the same operation, but the low parts of the source and |
destination operand are used. |
paddsb mm0,[esi] ; add packed bytes with signed saturation |
pcmpeqw mm3,mm7 ; compare packed words for equality |
"psllw", "pslld" and "psllq" perform logical shift left of the packed words, |
packed double words or a single quad word in the destination operand by the |
amount specified in the source operand. "psrlw", "psrld" and "psrlq" perform |
logical shift right of the packed words, packed double words or a single quad |
word. "psraw" and "psrad" perform arithmetic shift of the packed words or |
double words. The destination operand should be a MMX register, while source |
operand can be a MMX register, 64-bit memory location, or 8-bit immediate |
value. |
psllw mm2,mm4 ; shift words left logically |
psrad mm4,[ebx] ; shift double words right arithmetically |
"emms" makes the FPU registers usable for the FPU instructions, it must be |
used before using the FPU instructions if any MMX instructions were used. |
2.1.15 SSE instructions |
The SSE extension adds more MMX instructions and also introduces the |
operations on packed single precision floating point values. The 128-bit |
packed single precision format consists of four single precision floating |
point values. The 128-bit SSE registers are designed for the purpose of |
operations on this data type. |
"movaps" and "movups" transfer a double quad word operand containing packed |
single precision values from source operand to destination operand. At least |
one of the operands have to be a SSE register, the second one can be also a |
SSE register or 128-bit memory location. Memory operands for "movaps" |
instruction must be aligned on boundary of 16 bytes, operands for "movups" |
instruction don't have to be aligned. |
movups xmm0,[ebx] ; move unaligned double quad word |
"movlps" moves packed two single precision values between the memory and the |
low quad word of SSE register. "movhps" moved packed two single precision |
values between the memory and the high quad word of SSE register. One of the |
operands must be a SSE register, and the other operand must be a 64-bit memory |
location. |
movlps xmm0,[ebx] ; move memory to low quad word of xmm0 |
movhps [esi],xmm7 ; move high quad word of xmm7 to memory |
"movlhps" moves packed two single precision values from the low quad word |
of source register to the high quad word of destination register. "movhlps" |
moves two packed single precision values from the high quad word of source |
register to the low quad word of destination register. Both operands have to |
be a SSE registers. |
"movmskps" transfers the most significant bit of each of the four single |
precision values in the SSE register into low four bits of a general register. |
The source operand must be a SSE register, the destination operand must be a |
general register. |
"movss" transfers a single precision value between source and destination |
operand (only the low double word is trasferred). At least one of the operands |
have to be a SSE register, the second one can be also a SSE register or 32-bit |
memory location. |
movss [edi],xmm3 ; move low double word of xmm3 to memory |
Each of the SSE arithmetic operations has two variants. When the mnemonic |
ends with "ps", the source operand can be a 128-bit memory location or a SSE |
register, the destination operand must be a SSE register and the operation is |
performed on packed four single precision values, for each pair of the |
corresponding data elements separately, the result is stored in the |
destination register. When the mnemonic ends with "ss", the source operand |
can be a 32-bit memory location or a SSE register, the destination operand |
must be a SSE register and the operation is performed on single precision |
values, only low double words of SSE registers are used in this case, the |
result is stored in the low double word of destination register. "addps" and |
"addss" add the values, "subps" and "subss" substract the source value from |
destination value, "mulps" and "mulss" multiply the values, "divps" and |
"divss" divide the destination value by the source value, "rcpps" and "rcpss" |
compute the approximate reciprocal of the source value, "sqrtps" and "sqrtss" |
compute the square root of the source value, "rsqrtps" and "rsqrtss" compute |
the approximate reciprocal of square root of the source value, "maxps" and |
"maxss" compare the source and destination values and return the greater one, |
"minps" and "minss" compare the source and destination values and return the |
lesser one. |
mulss xmm0,[ebx] ; multiply single precision values |
addps xmm3,xmm7 ; add packed single precision values |
"andps", "andnps", "orps" and "xorps" perform the logical operations on |
packed single precision values. The source operand can be a 128-bit memory |
location or a SSE register, the destination operand must be a SSE register. |
"cmpps" compares packed single precision values and returns a mask result |
into the destination operand, which must be a SSE register. The source operand |
can be a 128-bit memory location or SSE register, the third operand must be an |
immediate operand selecting code of one of the eight compare conditions |
(table 2.3). "cmpss" performs the same operation on single precision values, |
only low double word of destination register is affected, in this case source |
operand can be a 32-bit memory location or SSE register. These two |
instructions have also variants with only two operands and the condition |
encoded within mnemonic. Their mnemonics are obtained by attaching the |
mnemonic from table 2.3 to the "cmp" mnemonic and then attaching the "ps" or |
"ss" at the end. |
cmpps xmm2,xmm4,0 ; compare packed single precision values |
cmpltss xmm0,[ebx] ; compare single precision values |
Table 2.3 SSE conditions |
ÚÄÄÄÄÄÄÂÄÄÄÄÄÄÄÄÄÄÂÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿ |
³ Code ³ Mnemonic ³ Description ³ |
ÆÍÍÍÍÍÍØÍÍÍÍÍÍÍÍÍÍØÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ͵ |
³ 0 ³ eq ³ equal ³ |
³ 1 ³ lt ³ less than ³ |
³ 2 ³ le ³ less than or equal ³ |
³ 3 ³ unord ³ unordered ³ |
³ 4 ³ neq ³ not equal ³ |
³ 5 ³ nlt ³ not less than ³ |
³ 6 ³ nle ³ not less than nor equal ³ |
³ 7 ³ ord ³ ordered ³ |
ÀÄÄÄÄÄÄÁÄÄÄÄÄÄÄÄÄÄÁÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ |
"comiss" and "ucomiss" compare the single precision values and set the ZF, |
PF and CF flags to show the result. The destination operand must be a SSE |
register, the source operand can be a 32-bit memory location or SSE register. |
"shufps" moves any two of the four single precision values from the |
destination operand into the low quad word of the destination operand, and any |
two of the four values from the source operand into the high quad word of the |
destination operand. The destination operand must be a SSE register, the |
source operand can be a 128-bit memory location or SSE register, the third |
operand must be an 8-bit immediate value selecting which values will be moved |
into the destination operand. Bits 0 and 1 select the value to be moved from |
destination operand to the low double word of the result, bits 2 and 3 select |
the value to be moved from the destination operand to the second double word, |
bits 4 and 5 select the value to be moved from the source operand to the third |
double word, and bits 6 and 7 select the value to be moved from the source |
operand to the high double word of the result. |
shufps xmm0,xmm0,10010011b ; shuffle double words |
"unpckhps" performs an interleaved unpack of the values from the high parts |
of the source and destination operands and stores the result in the |
destination operand, which must be a SSE register. The source operand can be |
a 128-bit memory location or a SSE register. "unpcklps" performs an |
interleaved unpack of the values from the low parts of the source and |
destination operand and stores the result in the destination operand, |
the rules for operands are the same. |
"cvtpi2ps" converts packed two double word integers into the the packed two |
single precision floating point values and stores the result in the low quad |
word of the destination operand, which should be a SSE register. The source |
operand can be a 64-bit memory location or MMX register. |
cvtpi2ps xmm0,mm0 ; convert integers to single precision values |
"cvtsi2ss" converts a double word integer into a single precision floating |
point value and stores the result in the low double word of the destination |
operand, which should be a SSE register. The source operand can be a 32-bit |
memory location or 32-bit general register. |
cvtsi2ss xmm0,eax ; convert integer to single precision value |
"cvtps2pi" converts packed two single precision floating point values into |
packed two double word integers and stores the result in the destination |
operand, which should be a MMX register. The source operand can be a 64-bit |
memory location or SSE register, only low quad word of SSE register is used. |
"cvttps2pi" performs the similar operation, except that truncation is used to |
round a source values to integers, rules for the operands are the same. |
cvtps2pi mm0,xmm0 ; convert single precision values to integers |
"cvtss2si" convert a single precision floating point value into a double |
word integer and stores the result in the destination operand, which should be |
a 32-bit general register. The source operand can be a 32-bit memory location |
or SSE register, only low double word of SSE register is used. "cvttss2si" |
performs the similar operation, except that truncation is used to round a |
source value to integer, rules for the operands are the same. |
cvtss2si eax,xmm0 ; convert single precision value to integer |
"pextrw" copies the word in the source operand specified by the third |
operand to the destination operand. The source operand must be a MMX register, |
the destination operand must be a 32-bit general register (but only the low |
word of it is affected), the third operand must an 8-bit immediate value. |
pextrw eax,mm0,1 ; extract word into eax |
"pinsrw" inserts a word from the source operand in the destination operand |
at the location specified with the third operand, which must be an 8-bit |
immediate value. The destination operand must be a MMX register, the source |
operand can be a 16-bit memory location or 32-bit general register (only low |
word of the register is used). |
pinsrw mm1,ebx,2 ; insert word from ebx |
"pavgb" and "pavgw" compute average of packed bytes or words. "pmaxub" |
return the maximum values of packed unsigned bytes, "pminub" returns the |
minimum values of packed unsigned bytes, "pmaxsw" returns the maximum values |
of packed signed words, "pminsw" returns the minimum values of packed signed |
words. "pmulhuw" performs a unsigned multiply of the packed words and stores |
the high words of the results in the destination operand. "psadbw" computes |
the absolute differences of packed unsigned bytes, sums the differences, and |
stores the sum in the low word of destination operand. All these instructions |
follow the same rules for operands as the general MMX operations described in |
previous section. |
"pmovmskb" creates a mask made of the most significant bit of each byte in |
the source operand and stores the result in the low byte of destination |
operand. The source operand must be a MMX register, the destination operand |
must a 32-bit general register. |
"pshufw" inserts words from the source operand in the destination operand |
from the locations specified with the third operand. The destination operand |
must be a MMX register, the source operand can be a 64-bit memory location or |
MMX register, third operand must an 8-bit immediate value selecting which |
values will be moved into destination operand, in the similar way as the third |
operand of the "shufps" instruction. |
"movntq" moves the quad word from the source operand to memory using a |
non-temporal hint to minimize cache pollution. The source operand should be a |
MMX register, the destination operand should be a 64-bit memory location. |
"movntps" stores packed single precision values from the SSE register to |
memory using a non-temporal hint. The source operand should be a SSE register, |
the destination operand should be a 128-bit memory location. "maskmovq" stores |
selected bytes from the first operand into a 64-bit memory location using a |
non-temporal hint. Both operands should be a MMX registers, the second operand |
selects wich bytes from the source operand are written to memory. The |
memory location is pointed by DI (or EDI) register in the segment selected |
by DS. |
"prefetcht0", "prefetcht1", "prefetcht2" and "prefetchnta" fetch the line |
of data from memory that contains byte specified with the operand to a |
specified location in hierarchy. The operand should be an 8-bit memory |
location. |
"sfence" performs a serializing operation on all instruction storing to |
memory that were issued prior to it. This instruction has no operands. |
"ldmxcsr" loads the 32-bit memory operand into the MXCSR register. "stmxcsr" |
stores the contents of MXCSR into a 32-bit memory operand. |
"fxsave" saves the current state of the FPU, MXCSR register, and all the FPU |
and SSE registers to a 512-byte memory location specified in the destination |
operand. "fxrstor" reloads data previously stored with "fxsave" instruction |
from the specified 512-byte memory location. The memory operand for both those |
instructions must be aligned on 16 byte boundary, it should declare operand |
of no specified size. |
2.1.16 SSE2 instructions |
The SSE2 extension introduces the operations on packed double precision |
floating point values, extends the syntax of MMX instructions, and adds also |
some new instructions. |
"movapd" and "movupd" transfer a double quad word operand containing packed |
double precision values from source operand to destination operand. These |
instructions are analogous to "movaps" and "movups" and have the same rules |
for operands. |
"movlpd" moves double precision value between the memory and the low quad |
word of SSE register. "movhpd" moved double precision value between the memory |
and the high quad word of SSE register. These instructions are analogous to |
"movlps" and "movhps" and have the same rules for operands. |
"movmskpd" transfers the most significant bit of each of the two double |
precision values in the SSE register into low two bits of a general register. |
This instruction is analogous to "movmskps" and has the same rules for |
operands. |
"movsd" transfers a double precision value between source and destination |
operand (only the low quad word is trasferred). At least one of the operands |
have to be a SSE register, the second one can be also a SSE register or 64-bit |
memory location. |
Arithmetic operations on double precision values are: "addpd", "addsd", |
"subpd", "subsd", "mulpd", "mulsd", "divpd", "divsd", "sqrtpd", "sqrtsd", |
"maxpd", "maxsd", "minpd", "minsd", and they are analoguous to arithmetic |
operations on single precision values described in previous section. When the |
mnemonic ends with "pd" instead of "ps", the operation is performed on packed |
two double precision values, but rules for operands are the same. When the |
mnemonic ends with "sd" instead of "ss", the source operand can be a 64-bit |
memory location or a SSE register, the destination operand must be a SSE |
register and the operation is performed on double precision values, only low |
quad words of SSE registers are used in this case. |
"andpd", "andnpd", "orpd" and "xorpd" perform the logical operations on |
packed double precision values. They are analoguous to SSE logical operations |
on single prevision values and have the same rules for operands. |
"cmppd" compares packed double precision values and returns and returns a |
mask result into the destination operand. This instruction is analoguous to |
"cmpps" and has the same rules for operands. "cmpsd" performs the same |
operation on double precision values, only low quad word of destination |
register is affected, in this case source operand can be a 64-bit memory or |
SSE register. Variant with only two operands are obtained by attaching the |
condition mnemonic from table 2.3 to the "cmp" mnemonic and then attaching |
the "pd" or "sd" at the end. |
"comisd" and "ucomisd" compare the double precision values and set the ZF, |
PF and CF flags to show the result. The destination operand must be a SSE |
register, the source operand can be a 128-bit memory location or SSE register. |
"shufpd" moves any of the two double precision values from the destination |
operand into the low quad word of the destination operand, and any of the two |
values from the source operand into the high quad word of the destination |
operand. This instruction is analoguous to "shufps" and has the same rules for |
operand. Bit 0 of the third operand selects the value to be moved from the |
destination operand, bit 1 selects the value to be moved from the source |
operand, the rest of bits are reserved and must be zeroed. |
"unpckhpd" performs an unpack of the high quad words from the source and |
destination operands, "unpcklpd" performs an unpack of the low quad words from |
the source and destination operands. They are analoguous to "unpckhps" and |
"unpcklps", and have the same rules for operands. |
"cvtps2pd" converts the packed two single precision floating point values to |
two packed double precision floating point values, the destination operand |
must be a SSE register, the source operand can be a 64-bit memory location or |
SSE register. "cvtpd2ps" converts the packed two double precision floating |
point values to packed two single precision floating point values, the |
destination operand must be a SSE register, the source operand can be a |
128-bit memory location or SSE register. "cvtss2sd" converts the single |
precision floating point value to double precision floating point value, the |
destination operand must be a SSE register, the source operand can be a 32-bit |
memory location or SSE register. "cvtsd2ss" converts the double precision |
floating point value to single precision floating point value, the destination |
operand must be a SSE register, the source operand can be 64-bit memory |
location or SSE register. |
"cvtpi2pd" converts packed two double word integers into the the packed |
double precision floating point values, the destination operand must be a SSE |
register, the source operand can be a 64-bit memory location or MMX register. |
"cvtsi2sd" converts a double word integer into a double precision floating |
point value, the destination operand must be a SSE register, the source |
operand can be a 32-bit memory location or 32-bit general register. "cvtpd2pi" |
converts packed double precision floating point values into packed two double |
word integers, the destination operand should be a MMX register, the source |
operand can be a 128-bit memory location or SSE register. "cvttpd2pi" performs |
the similar operation, except that truncation is used to round a source values |
to integers, rules for operands are the same. "cvtsd2si" converts a double |
precision floating point value into a double word integer, the destination |
operand should be a 32-bit general register, the source operand can be a |
64-bit memory location or SSE register. "cvttsd2si" performs the similar |
operation, except that truncation is used to round a source value to integer, |
rules for operands are the same. |
"cvtps2dq" and "cvttps2dq" convert packed single precision floating point |
values to packed four double word integers, storing them in the destination |
operand. "cvtpd2dq" and "cvttpd2dq" convert packed double precision floating |
point values to packed two double word integers, storing the result in the low |
quad word of the destination operand. "cvtdq2ps" converts packed four |
double word integers to packed single precision floating point values. |
"cvtdq2pd" converts packed two double word integers from the low quad word |
of the source operand to packed double precision floating point values. |
For all these instruction destination operand must be a SSE register, the |
source operand can be a 128-bit memory location or SSE register. |
"movdqa" and "movdqu" transfer a double quad word operand containing packed |
integers from source operand to destination operand. At least one of the |
operands have to be a SSE register, the second one can be also a SSE register |
or 128-bit memory location. Memory operands for "movdqa" instruction must be |
aligned on boundary of 16 bytes, operands for "movdqu" instruction don't have |
to be aligned. |
"movq2dq" moves the contents of the MMX source register to the low quad word |
of destination SSE register. "movdq2q" moves the low quad word from the source |
SSE register to the destination MMX register. |
movq2dq xmm0,mm1 ; move from MMX register to SSE register |
movdq2q mm0,xmm1 ; move from SSE register to MMX register |
All MMX instructions operating on the 64-bit packed integers (those with |
mnemonics starting with "p") are extended to operate on 128-bit packed |
integers located in SSE registers. Additional syntax for these instructions |
needs an SSE register where MMX register was needed, and the 128-bit memory |
location or SSE register where 64-bit memory location of MMX register were |
needed. The exception is "pshufw" instruction, which doesn't allow extended |
syntax, but has two new variants: "pshufhw" and "pshuflw", which allow only |
the extended syntax, and perform the same operation as "pshufw" on the high |
or low quad words of operands respectively. Also the new instruction "pshufd" |
is introduced, which performs the same operation as "pshufw", but on the |
double words instead of words, it allows only the extended syntax. |
psubb xmm0,[esi] ; substract 16 packed bytes |
pextrw eax,xmm0,7 ; extract highest word into eax |
"paddq" performs the addition of packed quad words, "psubq" performs the |
substraction of packed quad words, "pmuludq" performs an unsigned multiply |
of low double words from each corresponding quad words and returns the results |
in packed quad words. These instructions follow the same rules for operands as |
the general MMX operations described in 2.1.14. |
"pslldq" and "psrldq" perform logical shift left or right of the double |
quad word in the destination operand by the amount of bits specified in the |
source operand. The destination operand should be a SSE register, source |
operand should be an 8-bit immediate value. |
"punpckhqdq" interleaves the high quad word of the source operand and the |
high quad word of the destination operand and writes them to the destination |
SSE register. "punpcklqdq" interleaves the low quad word of the source operand |
and the low quad word of the destination operand and writes them to the |
destination SSE register. The source operand can be a 128-bit memory location |
or SSE register. |
"movntdq" stores packed integer data from the SSE register to memory using |
non-temporal hint. The source operand should be a SSE register, the |
destination operand should be a 128-bit memory location. "movntpd" stores |
packed double precision values from the SSE register to memory using a |
non-temporal hint. Rules for operand are the same. "movnti" stores integer |
from a general register to memory using a non-temporal hint. The source |
operand should be a 32-bit general register, the destination operand should |
be a 32-bit memory location. "maskmovdqu" stores selected bytes from the first |
operand into a 128-bit memory location using a non-temporal hint. Both |
operands should be a SSE registers, the second operand selects wich bytes from |
the source operand are written to memory. The memory location is pointed by DI |
(or EDI) register in the segment selected by DS and does not need to be |
aligned. |
"clflush" writes and invalidates the cache line associated with the address |
of byte specified with the operand, which should be a 8-bit memory location. |
"lfence" performs a serializing operation on all instruction loading from |
memory that were issued prior to it. "mfence" performs a serializing operation |
on all instruction accesing memory that were issued prior to it, and so it |
combines the functions of "sfence" (described in previous section) and |
"lfence" instructions. These instructions have no operands. |
2.1.17 SSE3 instructions |
Prescott technology introduced some new instructions to improve the performance |
of SSE and SSE2 - this extension is called SSE3. |
"fisttp" behaves like the "fistp" instruction and accepts the same operands, |
the only difference is that it always used truncation, irrespective of the |
rounding mode. |
"movshdup" loads into destination operand the 128-bit value obtained from |
the source value of the same size by filling the each quad word with the two |
duplicates of the value in its high double word. "movsldup" performs the same |
action, except it duplicates the values of low double words. The destination |
operand should be SSE register, the source operand can be SSE register or |
128-bit memory location. |
"movddup" loads the 64-bit source value and duplicates it into high and low |
quad word of the destination operand. The destination operand should be SSE |
register, the source operand can be SSE register or 64-bit memory location. |
"lddqu" is functionally equivalent to "movdqu" instruction with memory as |
source operand, but it may improve performance when the source operand crosses |
a cacheline boundary. The destination operand has to be SSE register, the |
source operand must be 128-bit memory location. |
"addsubps" performs single precision addition of second and fourth pairs and |
single precision substracion of the first and third pairs of floating point |
values in the operands. "addsubpd" performs double precision addition of the |
second pair and double precision substraction of the first pair of floating |
point values in the operand. "haddps" performs the addition of two single |
precision values within the each quad word of source and destination operands, |
and stores the results of such horizontal addition of values from destination |
operand into low quad word of destination operand, and the results from the |
source operand into high quad word of destination operand. "haddpd" performs |
the addition of two double precision values within each operand, and stores |
the result from destination operand into low quad word of destination operand, |
and the result from source operand into high quad word of destination operand. |
All these instruction need the destination operand to be SSE register, source |
operand can be SSE register or 128-bit memory location. |
"monitor" sets up an address range for monitoring of write-back stores. It |
need its three operands to be EAX, ECX and EDX register in that order. "mwait" |
waits for a write-back store to the address range set up by the "monitor" |
instruction. It uses two operands with additional parameters, first being the |
EAX and second the ECX register. |
2.1.18 AMD 3DNow! instructions |
The 3DNow! extension adds a new MMX instructions to those described in 2.1.14, |
and introduces operation on the 64-bit packed floating point values, each |
consisting of two single precision floating point values. |
These instructions follow the same rules as the general MMX operations, the |
destination operand should be a MMX register, the source operand can be a MMX |
register or 64-bit memory location. "pavgusb" computes the rounded averages |
of packed unsigned bytes. "pmulhrw" performs a signed multiply of the packed |
words, round the high word of each double word results and stores them in the |
destination operand. "pi2fd" converts packed double word integers into |
packed floating point values. "pf2id" converts packed floating point values |
into packed double word integers using truncation. "pi2fw" converts packed |
word integers into packed floating point values, only low words of each |
double word in source operand are used. "pf2iw" converts packed floating |
point values to packed word integers, results are extended to double words |
using the sign extension. "pfadd" adds packed floating point values. "pfsub" |
and "pfsubr" substracts packed floating point values, the first one substracts |
source values from destination values, the second one substracts destination |
values from the source values. "pfmul" multiplies packed floating point |
values. "pfacc" adds the low and high floating point values of the destination |
operand, storing the result in the low double word of destination, and adds |
the low and high floating point values of the source operand, storing the |
result in the high double word of destination. "pfnacc" substracts the high |
floating point value of the destination operand from the low, storing the |
result in the low double word of destination, and substracts the high floating |
point value of the source operand from the low, storing the result in the high |
double word of destination. "pfpnacc" substracts the high floating point value |
of the destination operand from the low, storing the result in the low double |
word of destination, and adds the low and high floating point values of the |
source operand, storing the result in the high double word of destination. |
"pfmax" and "pfmin" compute the maximum and minimum of floating point values. |
"pswapd" reverses the high and low double word of the source operand. "pfrcp" |
returns an estimates of the reciprocals of floating point values from the |
source operand, "pfrsqrt" returns an estimates of the reciprocal square |
roots of floating point values from the source operand, "pfrcpit1" performs |
the first step in the Newton-Raphson iteration to refine the reciprocal |
approximation produced by "pfrcp" instruction, "pfrsqit1" performs the first |
step in the Newton-Raphson iteration to refine the reciprocal square root |
approximation produced by "pfrsqrt" instruction, "pfrcpit2" performs the |
second final step in the Newton-Raphson iteration to refine the reciprocal |
approximation or the reciprocal square root approximation. "pfcmpeq", |
"pfcmpge" and "pfcmpgt" compare the packed floating point values and sets |
all bits or zeroes all bits of the correspoding data element in the |
destination operand according to the result of comparison, first checks |
whether values are equal, second checks whether destination value is greater |
or equal to source value, third checks whether destination value is greater |
than source value. |
"prefetch" and "prefetchw" load the line of data from memory that contains |
byte specified with the operand into the data cache, "prefetchw" instruction |
should be used when the data in the cache line is expected to be modified, |
otherwise the "prefetch" instruction should be used. The operand should be an |
8-bit memory location. |
"femms" performs a fast clear of MMX state. This instruction has no |
operands. |
2.1.19 The x86-64 long mode instructions |
The AMD64 and EM64T architectures (we will use the common name x86-64 for them |
both) extend the x86 instruction set for the 64-bit processing. While legacy |
and compatibility modes use the same set of registers and instructions, the |
new long mode extends the x86 operations to 64 bits and introduces several new |
registers. You can turn on generating the code for this mode with the "use64" |
directive. |
Each of the general purpose registers is extended to 64 bits and the eight |
whole new general purpose registers and also eight new SSE registers are added. |
See table 2.4 for the summary of new registers (only the ones that was not |
listed in table 1.2). The general purpose registers of smallers sizes are the |
low order portions of the larger ones. You can still access the "ah", "bh", |
"ch" and "dh" registers in long mode, but you cannot use them in the same |
instruction with any of the new registers. |
Table 2.4 New registers in long mode |
ÚÄÄÄÄÄÄÂÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÂÄÄÄÄÄÄÄ¿ |
³ Type ³ General ³ SSE ³ |
ÃÄÄÄÄÄÄÅÄÄÄÄÄÄÂÄÄÄÄÄÄÂÄÄÄÄÄÄÂÄÄÄÄÄÄÅÄÄÄÄÄÄÄ´ |
³ Bits ³ 8 ³ 16 ³ 32 ³ 64 ³ 128 ³ |
ÆÍÍÍÍÍÍØÍÍÍÍÍÍØÍÍÍÍÍÍØÍÍÍÍÍÍØÍÍÍÍÍÍØÍÍÍÍÍÍ͵ |
³ ³ ³ ³ ³ rax ³ ³ |
³ ³ ³ ³ ³ rcx ³ ³ |
³ ³ ³ ³ ³ rdx ³ ³ |
³ ³ ³ ³ ³ rbx ³ ³ |
³ ³ spl ³ ³ ³ rsp ³ ³ |
³ ³ bpl ³ ³ ³ rbp ³ ³ |
³ ³ sil ³ ³ ³ rsi ³ ³ |
³ ³ dil ³ ³ ³ rdi ³ ³ |
³ ³ r8b ³ r8w ³ r8d ³ r8 ³ xmm8 ³ |
³ ³ r9b ³ r9w ³ r9d ³ r9 ³ xmm9 ³ |
³ ³ r10b ³ r10w ³ r10d ³ r10 ³ xmm10 ³ |
³ ³ r11b ³ r11w ³ r11d ³ r11 ³ xmm11 ³ |
³ ³ r12b ³ r12w ³ r12d ³ r12 ³ xmm12 ³ |
³ ³ r13b ³ r13w ³ r13d ³ r13 ³ xmm13 ³ |
³ ³ r14b ³ r14w ³ r14d ³ r14 ³ xmm14 ³ |
³ ³ r15b ³ r15w ³ r15d ³ r15 ³ xmm15 ³ |
ÀÄÄÄÄÄÄÁÄÄÄÄÄÄÁÄÄÄÄÄÄÁÄÄÄÄÄÄÁÄÄÄÄÄÄÁÄÄÄÄÄÄÄÙ |
In general any instruction from x86 architecture, which allowed 16-bit or |
32-bit operand sizes, in long mode allows also the 64-bit operands. The 64-bit |
registers should be used for addressing in long mode, the 32-bit addressing |
is also allowed, but it's not possible to use the addresses based on 16-bit |
registers. Below are the samples of new operations possible in long mode on the |
example of "mov" instruction: |
mov rax,r8 ; transfer 64-bit general register |
mov al,[rbx] ; transfer memory addressed by 64-bit register |
The long mode uses also the instruction pointer based addresses, you can |
specify it manually with the special RIP register symbol, but such addressing |
is also automatically generated by flat assembler, since there is no 64-bit |
absolute addressing in long mode. You can still force the assembler to use the |
32-bit absolute addressing by putting the "dword" size override for address |
inside the square brackets. There is also one exception, where the 64-bit |
absolute addressing is possible, it's the "mov" instruction with one of the |
operand being accumulator register, and second being the memory operand. |
To force the assembler to use the 64-bit absolute addressing there, use the |
"qword" size operator for address inside the square brackets. When no size |
operator is applied to address, assembler generates the optimal form |
automatically. |
mov [qword 0],rax ; absolute 64-bit addressing |
mov [dword 0],r15d ; absolute 32-bit addressing |
mov [0],rsi ; automatic RIP-relative addressing |
mov [rip+3],sil ; manual RIP-relative addressing |
Also as the immediate operands for 64-bit operations only the signed 32-bit |
values are possible, with the only exception being the "mov" instruction with |
destination operand being 64-bit general purpose register. Trying to force the |
64-bit immediate with any other instruction will cause an error. |
If any operation is performed on the 32-bit general registers in long mode, |
the upper 32 bits of the 64-bit registers containing them are filled with |
zeros. This is unlike the operations on 16-bit or 8-bit portions of those |
registers, which preserve the upper bits. |
Three new type conversion instructions are available. The "cdqe" sign extends |
the double word in EAX into quad word and stores the result in RAX register. |
"cqo" sign extends the quad word in RAX into double quad word and stores the |
extra bits in the RDX register. These instructions have no operands. "movsxd" |
sign extends the double word source operand, being either the 32-bit register |
or memory, into 64-bit destination operand, which has to be register. |
No analogous instruction is needed for the zero extension, since it is done |
automatically by any operations on 32-bit registers, as noted in previous |
paragraph. And the "movzx" and "movsx" instructions, conforming to the general |
rule, can be used with 64-bit destination operand, allowing extension of byte |
or word values into quad words. |
All the binary arithmetic and logical instruction are promoted to allow |
64-bit operands in long mode. The use of decimal arithmetic instructions in |
long mode is prohibited. |
The stack operations, like "push" and "pop" in long mode default to 64-bit |
operands and it's not possible to use 32-bit operands with them. The "pusha" |
and "popa" are disallowed in long mode. |
The indirect near jumps and calls in long mode default to 64-bit operands and |
it's not possible to use the 32-bit operands with them. On the other hand, the |
indirect far jumps and calls allow any operands that were allowed by the x86 |
architecture and also 80-bit memory operand is allowed (though only EM64T seems |
to implement such variant), with the first eight bytes defining the offset and |
two last bytes specifying the selector. The direct far jumps and calls are not |
allowed in long mode. |
The I/O instructions, "in", "out", "ins" and "outs" are the exceptional |
instructions that are not extended to accept quad word operands in long mode. |
But all other string operations are, and there are new short forms "movsq", |
"cmpsq", "scasq", "lodsq" and "stosq" introduced for the variants of string |
operations for 64-bit string elements. The RSI and RDI registers are used by |
default to address the string elements. |
The "lfs", "lgs" and "lss" instructions are extended to accept 80-bit source |
memory operand with 64-bit destination register (though only EM64T seems to |
implement such variant). The "lds" and "les" are disallowed in long mode. |
The system instructions like "lgdt" which required the 48-bit memory operand, |
in long mode require the 80-bit memory operand. |
The "cmpxchg16b" is the 64-bit equivalent of "cmpxchg8b" instruction, it uses |
the double quad word memory operand and 64-bit registers to perform the |
analoguous operation. |
"swapgs" is the new instruction, which swaps the contents of GS register and |
the KernelGSbase model-specific register (MSR address 0C0000102h). |
"syscall" and "sysret" is the pair of new instructions that provide the |
functionality similar to "sysenter" and "sysexit" in long mode, where the |
latter pair is disallowed. |
2.2 Control directives |
This section describes the directives that control the assembly process, they |
are processed during the assembly and may cause some blocks of instructions |
to be assembled differently or not assembled at all. |
2.2.1 Numerical constants |
The "=" directive allows to define the numerical constant. It should be |
preceded by the name for the constant and followed by the numerical expression |
providing the value. The value of such constants can be a number or an address, |
but - unlike labels - the numerical constants are not allowed to hold the |
register-based addresses. Besides this difference, in their basic variant |
numerical constants behave very much like labels and you can even |
forward-reference them (access their values before they actually get defined). |
There is, however, a second variant of numerical constants, which is |
recognized by assembler when you try to define the constant of name, under |
which there already was a numerical constant defined. In such case assembler |
treats that constant as an assembly-time variable and allows it to be assigned |
with new value, but forbids forward-referencing it (for obvious reasons). Let's |
see both the variant of numerical constants in one example: |
dd sum |
x = 1 |
x = x+2 |
sum = x |
Here the "x" is an assembly-time variable, and every time it is accessed, the |
value that was assigned to it the most recently is used. Thus if we tried to |
access the "x" before it gets defined the first time, like if we wrote "dd x" |
in place of the "dd sum" instruction, it would cause an error. And when it is |
re-defined with the "x = x+2" directive, the previous value of "x" is used to |
calculate the new one. So when the "sum" constant gets defined, the "x" has |
value of 3, and this value is assigned to the "sum". Since this one is defined |
only once in source, it is the standard numerical constant, and can be |
forward-referenced. So the "dd sum" is assembled as "dd 3". To read more about |
how the assembler is able to resolve this, see section 2.2.6. |
The value of numerical constant can be preceded by size operator, which can |
ensure that the value will fit in the range for the specified size, and can |
affect also how some of the calculations inside the numerical expression are |
performed. This example: |
c8 = byte -1 |
c32 = dword -1 |
defines two different constants, the first one fits in 8 bits, the second one |
fits in 32 bits. |
When you need to define constant with the value of address, which may be |
register-based (and thus you cannot employ numerical constant for this |
purpose), you can use the extended syntax of "label" directive (already |
described in section 1.2.3), like: |
label myaddr at ebp+4 |
which declares label placed at "ebp+4" address. However remember that labels, |
unlike numerical constants, cannot become assembly-time variables. |
2.2.2 Conditional assembly |
"if" directive causes come block of instructions to be assembled only under |
certain condition. It should be followed by logical expression specifying the |
condition, instructions in next lines will be assembled only when this |
condition is met, otherwise they will be skipped. The optional "else if" |
directive followed with logical expression specifying additional condition |
begins the next block of instructions that will be assembled if previous |
conditions were not met, and the additional condition is met. The optional |
"else" directive begins the block of instructions that will be assembled if |
all the conditions were not met. The "end if" directive ends the last block of |
instructions. |
You should note that "if" directive is processed at assembly stage and |
therefore it doesn't affect any preprocessor directives, like the definitions |
of symbolic constants and macroinstructions - when the assembler recognizes the |
"if" directive, all the preprocessing has been already finished. |
The logical expression consist of logical values and logical operators. The |
logical operators are "~" for logical negation, "&" for logical and, "|" for |
logical or. The negation has the highest priority. Logical value can be a |
numerical expression, it will be false if it is equal to zero, otherwise it |
will be true. Two numerical expression can be compared using one of the |
following operators to make the logical value: "=" (equal), "<" (less), |
">" (greater), "<=" (less or equal), ">=" (greater or equal), |
"<>" (not equal). |
The "used" operator followed by a symbol name, is the logical value that |
checks whether the given symbol is used somewhere (it returns correct result |
even if symbol is used only after this check). The "defined" operator can be |
followed by any expression, usually just by a single symbol name; it checks |
whether the given expression contains only symbols that are defined in the |
source and accessible from the current position. |
The following simple example uses the "count" constant that should be |
defined somewhere in source: |
if count>0 |
mov cx,count |
rep movsb |
end if |
These two assembly instructions will be assembled only if the "count" constant |
is greater than 0. The next sample shows more complex conditional structure: |
if count & ~ count mod 4 |
mov cx,count/4 |
rep movsd |
else if count>4 |
mov cx,count/4 |
rep movsd |
mov cx,count mod 4 |
rep movsb |
else |
mov cx,count |
rep movsb |
end if |
The first block of instructions gets assembled when the "count" is non zero and |
divisible by four, if this condition is not met, the second logical expression, |
which follows the "else if", is evaluated and if it's true, the second block |
of instructions get assembled, otherwise the last block of instructions, which |
follows the line containing only "else", is assembled. |
There are also operators that allow comparison of values being any chains of |
symbols. The "eq" compares two such values whether they are exactly the same. |
The "in" operator checks whether given value is a member of the list of values |
following this operator, the list should be enclosed between "<" and ">" |
characters, its members should be separated with commas. The symbols are |
considered the same when they have the same meaning for the assembler - for |
example "pword" and "fword" for assembler are the same and thus are not |
distinguished by the above operators. In the same way "16 eq 10h" is the true |
condition, however "16 eq 10+4" is not. |
The "eqtype" operator checks whether the two compared values have the same |
structure, and whether the structural elements are of the same type. The |
distinguished types include numerical expressions, individual quoted strings, |
floating point numbers, address expressions (the expressions enclosed in square |
brackets or preceded by "ptr" operator), instruction mnemonics, registers, size |
operators, jump type and code type operators. And each of the special |
characters that act as a separators, like comma or colon, is the separate type |
itself. For example, two values, each one consisting of register name followed |
by comma and numerical expression, will be regarded as of the same type, no |
matter what kind of register and how complicated numerical expression is used; |
with exception for the quoted strings and floating point values, which are the |
special kinds of numerical expressions and are treated as different types. Thus |
"eax,16 eqtype fs,3+7" condition is true, but "eax,16 eqtype eax,1.6" is false. |
2.2.3 Repeating blocks of instructions |
"times" directive repeats one instruction specified number of times. It |
should be followed by numerical expression specifying number of repeats and |
the instruction to repeat (optionally colon can be used to separate number and |
instruction). When special symbol "%" is used inside the instruction, it is |
equal to the number of current repeat. For example "times 5 db %" will define |
five bytes with values 1, 2, 3, 4, 5. Recursive use of "times" directive is |
also allowed, so "times 3 times % db %" will define six bytes with values |
1, 1, 2, 1, 2, 3. |
"repeat" directive repeats the whole block of instructions. It should be |
followed by numerical expression specifying number of repeats. Instructions |
to repeat are expected in next lines, ended with the "end repeat" directive, |
for example: |
repeat 8 |
mov byte [bx],% |
inc bx |
end repeat |
The generated code will store byte values from one to eight in the memory |
addressed by BX register. |
Number of repeats can be zero, in that case the instructions are not |
assembled at all. |
The "break" directive allows to stop repeating earlier and continue assembly |
from the first line after the "end repeat". Combined with the "if" directive it |
allows to stop repeating under some special condition, like: |
s = x/2 |
repeat 100 |
if x/s = s |
break |
end if |
s = (s+x/s)/2 |
end repeat |
The "while" directive repeats the block of instructions as long as the |
condition specified by the logical expression following it is true. The block |
of instructions to be repeated should end with the "end while" directive. |
Before each repetition the logical expression is evaluated and when its value |
is false, the assembly is continued starting from the first line after the |
"end while". Also in this case the "%" symbol holds the number of current |
repeat. The "break" directive can be used to stop this kind of loop in the same |
way as with "repeat" directive. The previous sample can be rewritten to use the |
"while" instead of "repeat" this way: |
s = x/2 |
while x/s <> s |
s = (s+x/s)/2 |
if % = 100 |
break |
end if |
end while |
The blocks defined with "if", "repeat" and "while" can be nested in any |
order, however they should be closed in the same order in which they were |
started. The "break" directive always stops processing the block that was |
started last with either the "repeat" or "while" directive. |
2.2.4 Addressing spaces |
"org" directive sets address at which the following code is expected to |
appear in memory. It should be followed by numerical expression specifying |
the address. This directive begins the new addressing space, the following |
code itself is not moved in any way, but all the labels defined within it |
and the value of "$" symbol are affected as if it was put at the given |
address. However it's the responsibility of programmer to put the code at |
correct address at run-time. |
The "load" directive allows to define constant with a binary value loaded |
from the already assembled code. This directive should be followed by the name |
of the constant, then optionally size operator, then "from" operator and a |
numerical expression specifying a valid address in current addressing space. |
The size operator has unusual meaning in this case - it states how many bytes |
(up to 8) have to be loaded to form the binary value of constant. If no size |
operator is specified, one byte is loaded (thus value is in range from 0 to |
255). The loaded data cannot exceed current offset. |
The "store" directive can modify the already generated code by replacing |
some of the previously generated data with the value defined by given |
numerical expression, which follow. The expression can be preceded by the |
optional size operator to specify how large value the expression defines, and |
therefore how much bytes will be stored, if there is no size operator, the |
size of one byte is assumed. Then the "at" operator and the numerical |
expression defining the valid address in current addressing code space, at |
which the given value have to be stored should follow. This is a directive for |
advanced appliances and should be used carefully. |
Both "load" and "store" directives are limited to operate on places in |
current addressing space. The "$$" symbol is always equal to the base address |
of current addressing space, and the "$" symbol is the address of current |
position in that addressing space, therefore these two values define limits |
of the area, where "load" and "store" can operate. |
Combining the "load" and "store" directives allows to do things like encoding |
some of the already generated code. For example to encode the whole code |
generated in current addressing space you can use such block of directives: |
repeat $-$$ |
load a byte from $$+%-1 |
store byte a xor c at $$+%-1 |
end repeat |
and each byte of code will be xored with the value defined by "c" constant. |
"virtual" defines virtual data at specified address. This data won't be |
included in the output file, but labels defined there can be used in other |
parts of source. This directive can be followed by "at" operator and the |
numerical expression specifying the address for virtual data, otherwise is |
uses current address, the same as "virtual at $". Instructions defining data |
are expected in next lines, ended with "end virtual" directive. The block of |
virtual instructions itself is an independent addressing space, after it's |
ended, the context of previous addressing space is restored. |
The "virtual" directive can be used to create union of some variables, for |
example: |
GDTR dp ? |
virtual at GDTR |
GDT_limit dw ? |
GDT_address dd ? |
end virtual |
It defines two labels for parts of the 48-bit variable at "GDTR" address. |
It can be also used to define labels for some structures addressed by a |
register, for example: |
virtual at bx |
LDT_limit dw ? |
LDT_address dd ? |
end virtual |
With such definition instruction "mov ax,[LDT_limit]" will be assembled |
to "mov ax,[bx]". |
Declaring defined data values or instructions inside the virtual block would |
also be useful, because the "load" directive can be used to load the values |
from the virtually generated code into a constants. This directive should be |
used after the code it loads but before the virtual block ends, because it can |
only load the values from the same addressing space. For example: |
virtual at 0 |
xor eax,eax |
and edx,eax |
load zeroq dword from 0 |
end virtual |
The above piece of code will define the "zeroq" constant containing four bytes |
of the machine code of the instructions defined inside the virtual block. |
This method can be also used to load some binary value from external file. |
For example this code: |
virtual at 0 |
file 'a.txt':10h,1 |
load char from 0 |
end virtual |
loads the single byte from offset 10h in file "a.txt" into the "char" |
constant. |
Any of the "section" directives described in 2.4 also begins a new |
addressing space. |
2.2.5 Other directives |
"align" directive aligns code or data to the specified boundary. It should |
be followed by a numerical expression specifying the number of bytes, to the |
multiply of which the current address has to be aligned. The boundary value |
has to be the power of two. |
The "align" directive fills the bytes that had to be skipped to perform the |
alignment with the "nop" instructions and at the same time marks this area as |
uninitialized data, so if it is placed among other uninitialized data that |
wouldn't take space in the output file, the alignment bytes will act the same |
way. If you need to fill the alignment area with some other values, you can |
combine "align" with "virtual" to get the size of alignment needed and then |
create the alignment yourself, like: |
virtual |
align 16 |
a = $ - $$ |
end virtual |
db a dup 0 |
The "a" constant is defined to be the difference between address after |
alignment and address of the "virtual" block (see previous section), so it is |
equal to the size of needed alignment space. |
"display" directive displays the message at the assembly time. It should |
be followed by the quoted strings or byte values, separated with commas. It |
can be used to display values of some constants, for example: |
bits = 16 |
display 'Current offset is 0x' |
repeat bits/4 |
d = '0' + $ shr (bits-%*4) and 0Fh |
if d > '9' |
d = d + 'A'-'9'-1 |
end if |
display d |
end repeat |
display 13,10 |
This block of directives calculates the four hexadecimal digits of 16-bit value |
and converts them into characters for displaying. Note that this won't work if |
the adresses in current addressing space are relocatable (as it might happen |
with PE or object output formats), since only absolute values can be used this |
way. The absolute value may be obtained by calculating the relative address, |
like "$-$$", or "rva $" in case of PE format. |
2.2.6 Multiple passes |
Because the assembler allows to reference some of the labels or constants |
before they get actually defined, it has to predict the values of such labels |
and if there is even a suspicion that prediction failed in at least one case, |
it does one more pass, assembling the whole source, this time doing better |
prediction based on the values the labels got in the previous pass. |
The changing values of labels can cause some instructions to have encodings |
of different length, and this can cause the change in values of labels again. |
And since the labels and constants can also be used inside the expressions that |
affect the behavior of control directives, the whole block of source can be |
processed completely differently during the new pass. Thus the assembler does |
more and more passes, each time trying to do better predictions to approach |
the final solution, when all the values get predicted correctly. It uses |
various method for predicting the values, which has been chosen to allow |
finding in a few passes the solution of possibly smallest length for the most |
of the programs. |
Some of the errors, like the values not fitting in required boundaries, are |
not signaled during those intermediate passes, since it may happen that when |
some of the values are predicted better, these errors will disappear. However |
if assembler meets some illegal syntax construction or unknown instruction, it |
always stops immediately. Also defining some label more than once causes such |
error, because it makes the predictions groundless. |
Only the messages created with the "display" directive during the last |
performed pass get actually displayed. In case when the assembly has been |
stopped due to an error, these messages may reflect the predicted values that |
are not yet resolved correctly. |
The solution may sometimes not exist and in such cases the assembler will |
never manage to make correct predictions - for this reason there is a limit for |
a number of passes, and when assembler reaches this limit, it stops and |
displays the message that it is not able to generate the correct output. |
Consider the following example: |
if ~ defined alpha |
alpha: |
end if |
The "defined" operator gives the true value when the expression following it |
could be calculated in this place, what in this case means that the "alpha" |
label is defined somewhere. But the above block causes this label to be defined |
only when the value given by "defined" operator is false, what leads to an |
antynomy and makes it impossible to resolve such code. When processing the "if" |
directive assembler has to predict whether the "alpha" label will be defined |
somewhere (it wouldn't have to predict only if the label was already defined |
earlier in this pass), and whatever the prediction is, the opposite always |
happens. Thus the assembly will fail, unless the "alpha" label is defined |
somewhere in source preceding the above block of instructions - in such case, |
as it was already noted, the prediction is not needed and the block will just |
get skipped. |
The above sample might have been written as a try to define the label only |
when it was not yet defined. It fails, because the "defined" operator does |
check whether the label is defined anywhere, and this includes the definition |
inside this conditionally processed block. However adding some additional |
condition may make it possible to get it resolved: |
if ~ defined alpha | defined @f |
alpha: |
@@: |
end if |
The "@f" is always the same label as the nearest "@@" symbol in the source |
following it, so the above sample would mean the same if any unique name was |
used instead of the anonymous label. When "alpha" is not defined in any other |
place in source, the only possible solution is when this block gets defined, |
and this time this doesn't lead to the antynomy, because of the anonymous |
label which makes this block self-establishing. To better understand this, |
look at the blocks that has nothing more than this self-establishing: |
if defined @f |
@@: |
end if |
This is an example of source that may have more than one solution, as both |
cases when this block gets processed or not are equally correct. Which one of |
those two solutions we get depends on the algorithm on the assembler, in case |
of flat assembler - on the algorithm of predictions. Back to the previous |
sample, when "alpha" is not defined anywhere else, the condition for "if" block |
cannot be false, so we are left with only one possible solution, and we can |
hope the assembler will arrive at it. On the other hand, when "alpha" is |
defined in some other place, we've got two possible solutions again, but one of |
them causes "alpha" to be defined twice, and such an error causes assembler to |
abort the assembly immediately, as this is the kind of error that deeply |
disturbs the process of resolving. So we can get such source either correctly |
resolved or causing an error, and what we get may depend on the internal |
choices made by the assembler. |
However there are some facts about such choices that are certain. When |
assembler has to check whether the given symbol is defined and it was already |
defined in the current pass, no prediction is needed - it was already noted |
above. And when the given symbol has been defined never before, including all |
the already finished passes, the assembler predicts it to be not defined. |
Knowing this, we can expect that the simple self-establishing block shown |
above will not be assembled at all and that the previous sample will resolve |
correctly when "alpha" is defined somewhere before our conditional block, |
while it will itself define "alpha" when it's not already defined earlier, thus |
potentially causing the error because of double definition if the "alpha" is |
also defined somewhere later. |
The "used" operator may be expected to behave in a similar manner in |
analogous cases, however any other kinds of predictions my not be so simple and |
you should never rely on them this way. |
2.3 Preprocessor directives |
All preprocessor directives are processed before the main assembly process, |
and therefore are not affected by the control directives. At this time also |
all comments are stripped out. |
2.3.1 Including source files |
"include" directive includes the specified source file at the position where |
it is used. It should be followed by the quoted name of file that should be |
included, for example: |
include 'macros.inc' |
The whole included file is preprocessed before preprocessing the lines next |
to the line containing the "include" directive. There are no limits to the |
number of included files as long as they fit in memory. |
The quoted path can contain environment variables enclosed within "%" |
characters, they will be replaced with their values inside the path, both the |
"\" and "/" characters are allowed as a path separators. If no absolute path |
is given, the file is first searched for in the directory containing file |
which included it and when it's not found there, in the directory containing |
the main source file (the one specified in command line). These rules concern |
also paths given with the "file" directive. |
2.3.2 Symbolic constants |
The symbolic constants are different from the numerical constants, before the |
assembly process they are replaced with their values everywhere in source |
lines after their definitions, and anything can become their values. |
The definition of symbolic constant consists of name of the constant |
followed by the "equ" directive. Everything that follows this directive will |
become the value of constant. If the value of symbolic constant contains |
other symbolic constants, they are replaced with their values before assigning |
this value to the new constant. For example: |
d equ dword |
NULL equ d 0 |
d equ edx |
After these three definitions the value of "NULL" constant is "dword 0" and |
the value of "d" is "edx". So, for example, "push NULL" will be assembled as |
"push dword 0" and "push d" will be assembled as "push edx". And if then the |
following line was put: |
d equ d,eax |
the "d" constant would get the new value of "edx,eax". This way the growing |
lists of symbols can be defined. |
"restore" directive allows to get back previous value of redefined symbolic |
constant. It should be followed by one more names of symbolic constants, |
separated with commas. So "restore d" after the above definitions will give |
"d" constant back the value "edx", the second one will restore it to value |
"dword", and one more will revert "d" to original meaning as if no such |
constant was defined. If there was no constant defined of given name, |
"restore" won't cause an error, it will be just ignored. |
Symbolic constant can be used to adjust the syntax of assembler to personal |
preferences. For example the following set of definitions provides the handy |
shortcuts for all the size operators: |
b equ byte |
w equ word |
d equ dword |
p equ pword |
f equ fword |
q equ qword |
t equ tword |
x equ dqword |
Because symbolic constant may also have an empty value, it can be used to |
allow the syntax with "offset" word before any address value: |
offset equ |
After this definition "mov ax,offset char" will be valid construction for |
copying the offset of "char" variable into "ax" register, because "offset" is |
replaced with an empty value, and therefore ignored. |
The "define" directive followed by the name of constant and then the value, |
is the alternative way of defining symbolic constant. The only difference |
between "define" and "equ" is that "define" assigns the value as it is, it does |
not replace the symbolic constants with their values inside it. |
Symbolic constants can also be defined with the "fix" directive, which has |
the same syntax as "equ", but defines constants of high priority - they are |
replaced with their symbolic values even before processing the preprocessor |
directives and macroinstructions, the only exception is "fix" directive |
itself, which has the highest possible priority, so it allows redefinition of |
constants defined this way. |
The "fix" directive can be used for syntax adjustments related to directives |
of preprocessor, what cannot be done with "equ" directive. For example: |
incl fix include |
defines a short name for "include" directive, while the similar definition done |
with "equ" directive wouldn't give such result, as standard symbolic constants |
are replaced with their values after searching the line for preprocessor |
directives. |
2.3.3 Macroinstructions |
"macro" directive allows you to define your own complex instructions, called |
macroinstructions, using which can greatly simplify the process of |
programming. In its simplest form it's similar to symbolic constant |
definition. For example the following definition defines a shortcut for the |
"test al,0xFF" instruction: |
macro tst {test al,0xFF} |
After the "macro" directive there is a name of macroinstruction and then its |
contents enclosed between the "{" and "}" characters. You can use "tst" |
instruction anywhere after this definition and it will be assembled as |
"test al,0xFF". Defining symbolic constant "tst" of that value would give the |
similar result, but the difference is that the name of macroinstruction is |
recognized only as an instruction mnemonic. Also, macroinstructions are |
replaced with corresponding code even before the symbolic constants are |
replaced with their values. So if you define macroinstruction and symbolic |
constant of the same name, and use this name as an instruction mnemonic, it |
will be replaced with the contents of macroinstruction, but it will be |
replaced with value if symbolic constant if used somewhere inside the |
operands. |
The definition of macroinstruction can consist of many lines, because |
"{" and "}" characters don't have to be in the same line as "macro" directive. |
For example: |
macro stos0 |
{ |
xor al,al |
stosb |
} |
The macroinstruction "stos0" will be replaced with these two assembly |
instructions anywhere it's used. |
Like instructions which needs some number of operands, the macroinstruction |
can be defined to need some number of arguments separated with commas. The |
names of needed argument should follow the name of macroinstruction in the |
line of "macro" directive and should be separated with commas if there is more |
than one. Anywhere one of these names occurs in the contents of |
macroinstruction, it will be replaced with corresponding value, provided when |
the macroinstruction is used. Here is an example of a macroinstruction that |
will do data alignment for binary output format: |
macro align value { rb (value-1)-($+value-1) mod value } |
When the "align 4" instruction is found after this macroinstruction is |
defined, it will be replaced with contents of this macroinstruction, and the |
"value" will there become 4, so the result will be "rb (4-1)-($+4-1) mod 4". |
If a macroinstruction is defined that uses an instruction with the same name |
inside its definition, the previous meaning of this name is used. Useful |
redefinition of macroinstructions can be done in that way, for example: |
macro mov op1,op2 |
{ |
if op1 in <ds,es,fs,gs,ss> & op2 in <cs,ds,es,fs,gs,ss> |
push op2 |
pop op1 |
else |
mov op1,op2 |
end if |
} |
This macroinstruction extends the syntax of "mov" instruction, allowing both |
operands to be segment registers. For example "mov ds,es" will be assembled as |
"push es" and "pop ds". In all other cases the standard "mov" instruction will |
be used. The syntax of this "mov" can be extended further by defining next |
macroinstruction of that name, which will use the previous macroinstruction: |
macro mov op1,op2,op3 |
{ |
if op3 eq |
mov op1,op2 |
else |
mov op1,op2 |
mov op2,op3 |
end if |
} |
It allows "mov" instruction to have three operands, but it can still have two |
operands only, because when macroinstruction is given less arguments than it |
needs, the rest of arguments will have empty values. When three operands are |
given, this macroinstruction will become two macroinstructions of the previous |
definition, so "mov es,ds,dx" will be assembled as "push ds", "pop es" and |
"mov ds,dx". |
By placing the "*" after the name of argument you can mark the argument as |
required - preprocessor won't allow it to have an empty value. For example the |
above macroinstruction could be declared as "macro mov op1*,op2*,op3" to make |
sure that first two arguments will always have to be given some non empty |
values. |
When it's needed to provide macroinstruction with argument that contains |
some commas, such argument should be enclosed between "<" and ">" characters. |
If it contains more than one "<" character, the same number of ">" should be |
used to tell that the value of argument ends. |
"purge" directive allows removing the last definition of specified |
macroinstruction. It should be followed by one or more names of |
macroinstructions, separated with commas. If such macroinstruction has not |
been defined, you won't get any error. For example after having the syntax of |
"mov" extended with the macroinstructions defined above, you can disable |
syntax with three operands back by using "purge mov" directive. Next |
"purge mov" will disable also syntax for two operands being segment registers, |
and all the next such directives will do nothing. |
If after the "macro" directive you enclose some group of arguments' names in |
square brackets, it will allow giving more values for this group of arguments |
when using that macroinstruction. Any more argument given after the last |
argument of such group will begin the new group and will become the first |
argument of it. That's why after closing the square bracket no more argument |
names can follow. The contents of macroinstruction will be processed for each |
such group of arguments separately. The simplest example is to enclose one |
argument name in square brackets: |
macro stoschar [char] |
{ |
mov al,char |
stosb |
} |
This macroinstruction accepts unlimited number of arguments, and each one |
will be processed into these two instructions separately. For example |
"stoschar 1,2,3" will be assembled as the following instructions: |
mov al,1 |
stosb |
mov al,2 |
stosb |
mov al,3 |
stosb |
There are some special directives available only inside the definitions of |
macroinstructions. "local" directive defines local names, which will be |
replaced with unique values each time the macroinstruction is used. It should |
be followed by names separated with commas. If the name given as parameter to |
"local" directive begins with a dot or two dots, the unique labels generated |
by each evaluation of macroinstruction will have the same properties. |
This directive is usually needed for the constants or labels that |
macroinstruction defines and uses internally. For example: |
macro movstr |
{ |
local move |
move: |
lodsb |
stosb |
test al,al |
jnz move |
} |
Each time this macroinstruction is used, "move" will become other unique name |
in its instructions, so you won't get an error you normally get when some |
label is defined more than once. |
"forward", "reverse" and "common" directives divide macroinstruction into |
blocks, each one processed after the processing of previous is finished. They |
differ in behavior only if macroinstruction allows multiple groups of |
arguments. Block of instructions that follows "forward" directive is processed |
for each group of arguments, from first to last - exactly like the default |
block (not preceded by any of these directives). Block that follows "reverse" |
directive is processed for each group of argument in reverse order - from last |
to first. Block that follows "common" directive is processed only once, |
commonly for all groups of arguments. Local name defined in one of the blocks |
is available in all the following blocks when processing the same group of |
arguments as when it was defined, and when it is defined in common block it is |
available in all the following blocks not depending on which group of |
arguments is processed. |
Here is an example of macroinstruction that will create the table of |
addresses to strings followed by these strings: |
macro strtbl name,[string] |
{ |
common |
label name dword |
forward |
local label |
dd label |
forward |
label db string,0 |
} |
First argument given to this macroinstruction will become the label for table |
of addresses, next arguments should be the strings. First block is processed |
only once and defines the label, second block for each string declares its |
local name and defines the table entry holding the address to that string. |
Third block defines the data of each string with the corresponding label. |
The directive starting the block in macroinstruction can be followed by the |
first instruction of this block in the same line, like in the following |
example: |
macro stdcall proc,[arg] |
{ |
reverse push arg |
common call proc |
} |
This macroinstruction can be used for calling the procedures using STDCALL |
convention, arguments are pushed on stack in the reverse order. For example |
"stdcall foo,1,2,3" will be assembled as: |
push 3 |
push 2 |
push 1 |
call foo |
If some name inside macroinstruction has multiple values (it is either one |
of the arguments enclosed in square brackets or local name defined in the |
block following "forward" or "reverse" directive) and is used in block |
following the "common" directive, it will be replaced with all of its values, |
separated with commas. For example the following macroinstruction will pass |
all of the additional arguments to the previously defined "stdcall" |
macroinstruction: |
macro invoke proc,[arg] |
{ common stdcall [proc],arg } |
It can be used to call indirectly (by the pointer stored in memory) the |
procedure using STDCALL convention. |
Inside macroinstruction also special operator "#" can be used. This |
operator causes two names to be concatenated into one name. It can be useful, |
because it's done after the arguments and local names are replaced with their |
values. The following macroinstruction will generate the conditional jump |
according to the "cond" argument: |
macro jif op1,cond,op2,label |
{ |
cmp op1,op2 |
j#cond label |
} |
For example "jif ax,ae,10h,exit" will be assembled as "cmp ax,10h" and |
"jae exit" instructions. |
The "#" operator can be also used to concatenate two quoted strings into one. |
Also conversion of name into a quoted string is possible, with the "`" operator, |
which likewise can be used inside the macroinstruction. It convert the name |
that follows it into a quoted string - but note, that when it is followed by |
a macro argument which is being replaced with value containing more than one |
symbol, only the first of them will be converted, as the "`" operator converts |
only one symbol that immediately follows it. Here's an example of utilizing |
those two features: |
macro label name |
{ |
label name |
if ~ used name |
display `name # " is defined but not used.",13,10 |
end if |
} |
When label defined with such macro is not used in the source, macro will warn |
you with the message, informing to which label it applies. |
To make macroinstruction behaving differently when some of the arguments are |
of some special type, for example a quoted strings, you can use "eqtype" |
comparison operator. Here's an example of utilizing it to distinguish a |
quoted string from an other argument: |
macro message arg |
{ |
if arg eqtype "" |
local str |
jmp @f |
str db arg,0Dh,0Ah,24h |
@@: |
mov dx,str |
else |
mov dx,arg |
end if |
mov ah,9 |
int 21h |
} |
The above macro is designed for displaying messages in DOS programs. When the |
argument of this macro is some number, label, or variable, the string from |
that address is displayed, but when the argument is a quoted string, the |
created code will display that string followed by the carriage return and |
line feed. |
It is also possible to put a declaration of macroinstruction inside another |
macroinstruction, so one macro can define another, but there is a problem |
with such definitions caused by the fact, that "}" character cannot occur |
inside the macroinstruction, as it always means the end of definition. To |
overcome this problem, the escaping of symbols inside macroinstruction can be |
used. This is done by placing one or more backslashes in front of any other |
symbol (even the special character). Preprocessor sees such sequence as a |
single symbol, but each time it meets such symbol during the macroinstruction |
processing, it cuts the backslash character from the front of it. For example |
"\{" is treated as single symbol, but during processing of the macroinstruction |
it becomes the "{" symbol. This allows to put one definition of |
macroinstruction inside another: |
macro ext instr |
{ |
macro instr op1,op2,op3 |
\{ |
if op3 eq |
instr op1,op2 |
else |
instr op1,op2 |
instr op2,op3 |
end if |
\} |
} |
ext add |
ext sub |
The macro "ext" is defined correctly, but when it is used, the "\{" and "\}" |
become the "{" and "}" symbols. So when the "ext add" is processed, the |
contents of macro becomes valid definition of a macroinstruction and this way |
the "add" macro becomes defined. In the same way "ext sub" defines the "sub" |
macro. The use of "\{" symbol wasn't really necessary here, but is done this |
way to make the definition more clear. |
If some directives specific to macroinstructions, like "local" or "common" |
are needed inside some macro embedded this way, they can be escaped in the same |
way. Escaping the symbol with more than one backslash is also allowed, which |
allows multiple levels of nesting the macroinstruction definitions. |
The another technique for defining one macroinstruction by another is to |
use the "fix" directive, which becomes useful when some macroinstruction only |
begins the definition of another one, without closing it. For example: |
macro tmacro [params] |
{ |
common macro params { |
} |
MACRO fix tmacro |
ENDM fix } |
defines an alternative syntax for defining macroinstructions, which looks like: |
MACRO stoschar char |
mov al,char |
stosb |
ENDM |
Note that symbol that has such customized definition must be defined with "fix" |
directive, because only the prioritized symbolic constants are processed before |
the preprocessor looks for the "}" character while defining the macro. This |
might be a problem if one needed to perform some additional tasks one the end |
of such definition, but there is one more feature which helps in such cases. |
Namely it is possible to put any directive, instruction or macroinstruction |
just after the "}" character that ends the macroinstruction and it will be |
processed in the same way as if it was put in the next line. |
2.3.4 Structures |
"struc" directive is a special variant of "macro" directive that is used to |
define data structures. Macroinstruction defined using the "struc" directive |
must be preceded by a label (like the data definition directive) when it's |
used. This label will be also attached at the beginning of every name starting |
with dot in the contents of macroinstruction. The macroinstruction defined |
using the "struc" directive can have the same name as some other |
macroinstruction defined using the "macro" directive, structure |
macroinstruction won't prevent the standard macroinstruction being processed |
when there is no label before it and vice versa. All the rules and features |
concerning standard macroinstructions apply to structure macroinstructions. |
Here is the sample of structure macroinstruction: |
struc point x,y |
{ |
.x dw x |
.y dw y |
} |
For example "my point 7,11" will define structure labeled "my", consisting of |
two variables: "my.x" with value 7 and "my.y" with value 11. |
If somewhere inside the definition of structure the name consisting of a |
single dot it found, it is replaced by the name of the label for the given |
instance of structure and this label will not be defined automatically in |
such case, allowing to completely customize the definition. The following |
example utilizes this feature to extend the data definition directive "db" |
with ability to calculate the size of defined data: |
struc db [data] |
{ |
common |
. db data |
.size = $ - . |
} |
With such definition "msg db 'Hello!',13,10" will define also "msg.size" |
constant, equal to the size of defined data in bytes. |
Defining data structures addressed by registers or absolute values should be |
done using the "virtual" directive with structure macroinstruction |
(see 2.2.4). |
"restruc" directive removes the last definition of the structure, just like |
"purge" does with macroinstructions and "restore" with symbolic constants. |
It also has the same syntax - should be followed by one or more names of |
structure macroinstructions, separated with commas. |
2.3.5 Repeating macroinstructions |
The "rept" directive is a special kind of macroinstruction, which makes given |
amount of duplicates of the block enclosed with braces. The basic syntax is |
"rept" directive followed by number (it cannot be an expression, since |
preprocessor doesn't do calculations, if you need repetitions based on values |
calculated by assembler, use one of the code repeating directives that are |
processed by assembler, see 2.2.3), and then block of source enclosed between |
the "{" and "}" characters. The simplest example: |
rept 5 { in al,dx } |
will make five duplicates of the "in al,dx" line. The block of instructions |
is defined in the same way as for the standard macroinstruction and any |
special operators and directives which can be used only inside |
macroinstructions are also allowed here. When the given count is zero, the |
block is simply skipped, as if you defined macroinstruction but never used |
it. The number of repetitions can be followed by the name of counter symbol, |
which will get replaced symbolically with the number of duplicate currently |
generated. So this: |
rept 3 counter |
{ |
byte#counter db counter |
} |
will generate lines: |
byte1 db 1 |
byte2 db 2 |
byte3 db 3 |
The repetition mechanism applied to "rept" blocks is the same as the one used |
to process multiple groups of arguments for macroinstructions, so directives |
like "forward", "common" and "reverse" can be used in their usual meaning. |
Thus such macroinstruction: |
rept 7 num { reverse display `num } |
will display digits from 7 to 1 as text. The "local" directive behaves in the |
same way as inside macroinstruction with multiple groups of arguments, so: |
rept 21 |
{ |
local label |
label: loop label |
} |
will generate unique label for each duplicate. |
The counter symbol by default counts from 1, but you can declare different |
base value by placing the number preceded by colon immediately after the name |
of counter. For example: |
rept 8 n:0 { pxor xmm#n,xmm#n } |
will generate code which will clear the contents of eight SSE registers. |
You can define multiple counters separated with commas, and each one can have |
different base. |
The "irp" directive iterates the single argument through the given list of |
parameters. The syntax is "irp" followed by the argument name, then the comma |
and then the list of parameters. The parameters are specified in the same |
way like in the invocation of standard macroinstruction, so they have to be |
separated with commas and each one can be enclosed with the "<" and ">" |
characters. Also the name of argument may be followed by "*" to mark that it |
cannot get an empty value. Such block: |
irp value, 2,3,5 |
{ db value } |
will generate lines: |
db 2 |
db 3 |
db 5 |
The "irps" directive iterates through the given list of symbols, it should |
be followed by the argument name, then the comma and then the sequence of any |
symbols. Each symbol in this sequence, no matter whether it is the name |
symbol, symbol character or quoted string, becomes an argument value for one |
iteration. If there are no symbols following the comma, no iteration is done |
at all. This example: |
irps reg, al bx ecx |
{ xor reg,reg } |
will generate lines: |
xor al,al |
xor bx,bx |
xor ecx,ecx |
The blocks defined by the "irp" and "irps" directives are also processed in |
the same way as any macroinstructions, so operators and directives specific |
to macroinstructions may be freely used also in this case. |
2.3.6 Conditional preprocessing |
"match" directive causes some block of source to be preprocessed and passed |
to assembler only when the given sequence of symbols matches the specified |
pattern. The pattern comes first, ended with comma, then the symbols that have |
to be matched with the pattern, and finally the block of source, enclosed |
within braces as macroinstruction. |
There are the few rules for building the expression for matching, first is |
that any of symbol characters and any quoted string should be matched exactly |
as is. In this example: |
match +,+ { include 'first.inc' } |
match +,- { include 'second.inc' } |
the first file will get included, since "+" after comma matches the "+" in |
pattern, and the second file won't be included, since there is no match. |
To match any other symbol literally, it has to be preceded by "=" character |
in the pattern. Also to match the "=" character itself, or the comma, the |
"==" and "=," constructions have to be used. For example the "=a==" pattern |
will match the "a=" sequence. |
If some name symbol is placed in the pattern, it matches any sequence |
consisting of at least one symbol and then this name is replaced with the |
matched sequence everywhere inside the following block, analogously to the |
parameters of macroinstruction. For instance: |
match a-b, 0-7 |
{ dw a,b-a } |
will generate the "dw 0,7-0" instruction. Each name is always matched with |
as few symbols as possible, leaving the rest for the following ones, so in |
this case: |
match a b, 1+2+3 { db a } |
the "a" name will match the "1" symbol, leaving the "+2+3" sequence to be |
matched with "b". But in this case: |
match a b, 1 { db a } |
there will be nothing left for "b" to match, so the block won't get processed |
at all. |
The block of source defined by match is processed in the same way as any |
macroinstruction, so any operators specific to macroinstructions can be used |
also in this case. |
What makes "match" directive more useful is the fact, that it replaces the |
symbolic constants with their values in the matched sequence of symbols (that |
is everywhere after comma up to the beginning of the source block) before |
performing the match. Thanks to this it can be used for example to process |
some block of source under the condition that some symbolic constant has the |
given value, like: |
match =TRUE, DEBUG { include 'debug.inc' } |
which will include the file only when the symbolic constant "DEBUG" was |
defined with value "TRUE". |
2.3.7 Order of processing |
When combining various features of the preprocessor, it's important to know |
the order in which they are processed. As it was already noted, the highest |
priority has the "fix" directive and the replacements defined with it. This |
is done completely before doing any other preprocessing, therefore this |
piece of source: |
V fix { |
macro empty |
V |
V fix } |
V |
becomes a valid definition of an empty macroinstruction. It can be interpreted |
that the "fix" directive and prioritized symbolic constants are processed in |
a separate stage, and all other preprocessing is done after on the resulting |
source. |
The standard preprocessing that comes after, on each line begins with |
recognition of the first symbol. It begins with checking for the preprocessor |
directives, and when none of them is detected, preprocessor checks whether the |
first symbol is macroinstruction. If no macroinstruction is found, it moves |
to the second symbol of line, and again begins with checking for directives, |
which in this case is only the "equ" directive, as this is the only one that |
occurs as the second symbol in line. If there's no directive, the second |
symbol is checked for the case of structure macroinstruction and when none |
of those checks gives the positive result, the symbolic constants are replaced |
with their values and such line is passed to the assembler. |
To see it on the example, assume that there is defined the macroinstruction |
called "foo" and the structure macroinstruction called "bar". Those lines: |
foo equ |
foo bar |
would be then both interpreted as invocations of macroinstruction "foo", since |
the meaning of the first symbol overrides the meaning of second one. |
The macroinstructions generate the new lines from their definition blocks, |
replacing the parameters with their values and then processing the "#" and "`" |
operators. The conversion operator has the higher priority than concatenation. |
After this is completed, the newly generated line goes through the standard |
preprocessing, as described above. |
Though the symbolic constants are usually only replaced in the lines, where |
no preprocessor directives nor macroinstructions has been found, there are some |
special cases where those replacements are performed in the parts of lines |
containing directives. First one is the definition of symbolic constant, where |
the replacements are done everywhere after the "equ" keyword and the resulting |
value is then assigned to the new constant (see 2.3.2). The second such case |
is the "match" directive, where the replacements are done in the symbols |
following comma before matching them with pattern. These features can be used |
for example to maintain the lists, like this set of definitions: |
list equ |
macro append item |
{ |
match any, list \{ list equ list,item \} |
match , list \{ list equ item \} |
} |
The "list" constant is here initialized with empty value, and the "append" |
macroinstruction can be used to add the new items into this list, separating |
them with commas. The first match in this macroinstruction occurs only when |
the value of list is not empty (see 2.3.6), in such case the new value for the |
list is the previous one with the comma and the new item appended at the end. |
The second match happens only when the list is still empty, and in such case |
the list is defined to contain just the new item. So starting with the empty |
list, the "append 1" would define "list equ 1" and the "append 2" following it |
would define "list equ 1,2". One might then need to use this list as the |
parameters to some macroinstruction. But it cannot be done directly - if "foo" |
is the macroinstruction, then "foo list" would just pass the "list" symbol |
as a parameter to macro, since symbolic constants are not unrolled at this |
stage. For this purpose again "match" directive comes in handy: |
match params, list { foo params } |
The value of "list", if it's not empty, matches the "params" keyword, which is |
then replaced with matched value when generating the new lines defined by the |
block enclosed with braces. So if the "list" had value "1,2", the above line |
would generate the line containing "foo 1,2", which would then go through the |
standard preprocessing. |
There is one more special case - when preprocessor goes to checking the |
second symbol in the line and it happens to be the colon character (what is |
then interpreted by assembler as definition of a label), it stops in this |
place and finishes the preprocessing of the first symbol (so if it's the |
symbolic constant it gets unrolled) and if it still appears to be the label, |
it performs the standard preprocessing starting from the place after the |
label. This allows to place preprocessor directives and macroinstructions |
after the labels, analogously to the instructions and directives processed |
by assembler, like: |
start: include 'start.inc' |
However if the label becomes broken during preprocessing (for example when |
it is the symbolic constant with empty value), only replacing of the symbolic |
constants is continued for the rest of line. |
It should be remembered, that the jobs performed by preprocessor are the |
preliminary operations on the texts symbols, that are done in a simple |
single pass before the main process of assembly. The text that is the |
result of preprocessing is passed to assembler, and it then does its |
multiple passes on it. Thus the control directives, which are recognized and |
processed only by the assembler - as they are dependent on the numerical |
values that may even vary between passes - are not recognized in any way by |
the preprocessor and have no effect on the preprocessing. Consider this |
example source: |
if 0 |
a = 1 |
b equ 2 |
end if |
dd b |
When it is preprocessed, they only directive that is recognized by the |
preprocessor is the "equ", which defines symbolic constant "b", so later |
in the source the "b" symbol is replaced with the value "2". Except for this |
replacement, the other lines are passes unchanged to the assembler. So |
after preprocessing the above source becomes: |
if 0 |
a = 1 |
end if |
dd 2 |
Now when assembler processes it, the condition for the "if" is false, and |
the "a" constant doesn't get defined. However symbolic constant "b" was |
processed normally, even though its definition was put just next to the one |
of "a". So because of the possible confusion you should be very careful |
every time when mixing the features of preprocessor and assembler - always |
try to imagine what your source will become after the preprocessing, and |
thus what the assembler will see and do its multiple passes on. |
2.4 Formatter directives |
These directives are actually also a kind of control directives, with the |
purpose of controlling the format of generated code. |
"format" directive followed by the format identifier allows to select the |
output format. This directive should be put at the beginning of the source. |
Default output format is a flat binary file, it can also be selected by using |
"format binary" directive. |
"use16" and "use32" directives force the assembler to generate 16-bit or |
32-bit code, omitting the default setting for selected output format. "use64" |
enables generating the code for the long mode of x86-64 processors. |
Below are described different output formats with the directives specific to |
these formats. |
2.4.1 MZ executable |
To select the MZ output format, use "format MZ" directive. The default code |
setting for this format is 16-bit. |
"segment" directive defines a new segment, it should be followed by label, |
which value will be the number of defined segment, optionally "use16" or |
"use32" word can follow to specify whether code in this segment should be |
16-bit or 32-bit. The origin of segment is aligned to paragraph (16 bytes). |
All the labels defined then will have values relative to the beginning of this |
segment. |
"entry" directive sets the entry point for MZ executable, it should be |
followed by the far address (name of segment, colon and the offset inside |
segment) of desired entry point. |
"stack" directive sets up the stack for MZ executable. It can be followed by |
numerical expression specifying the size of stack to be created automatically |
or by the far address of initial stack frame when you want to set up the stack |
manually. When no stack is defined, the stack of default size 4096 bytes will |
be created. |
"heap" directive should be followed by a 16-bit value defining maximum size |
of additional heap in paragraphs (this is heap in addition to stack and |
undefined data). Use "heap 0" to always allocate only memory program really |
needs. Default size of heap is 65535. |
2.4.2 Portable Executable |
To select the Portable Executable output format, use "format PE" directive, it |
can be followed by additional format settings: use "console", "GUI" or |
"native" operator selects the target subsystem (floating point value |
specifying subsystem version can follow), "DLL" marks the output file as a |
dynamic link library. Then can follow the "at" operator and the numerical |
expression specifying the base of PE image and then optionally "on" operator |
followed by the quoted string containing file name selects custom MZ stub for |
PE program (when specified file is not a MZ executable, it is treated as a |
flat binary executable file and converted into MZ format). The default code |
setting for this format is 32-bit. The example of fully featured PE format |
declaration: |
format PE GUI 4.0 DLL at 7000000h on 'stub.exe' |
To create PE file for the x86-64 architecture, use "PE64" keyword instead of |
"PE" in the format declaration, in such case the long mode code is generated |
by default. |
"section" directive defines a new section, it should be followed by quoted |
string defining the name of section, then one or more section flags can |
follow. Available flags are: "code", "data", "readable", "writeable", |
"executable", "shareable", "discardable", "notpageable". The origin of section |
is aligned to page (4096 bytes). Example declaration of PE section: |
section '.text' code readable executable |
Among with flags also one of the special PE data identifiers can be specified |
to mark the whole section as a special data, possible identifiers are |
"export", "import", "resource" and "fixups". If the section is marked to |
contain fixups, they are generated automatically and no more data needs to be |
defined in this section. Also resource data can be generated automatically |
from the resource file, it can be achieved by writing the "from" operator and |
quoted file name after the "resource" identifier. Below are the examples of |
sections containing some special PE data: |
section '.reloc' data discardable fixups |
section '.rsrc' data readable resource from 'my.res' |
"entry" directive sets the entry point for Portable Executable, the value of |
entry point should follow. |
"stack" directive sets up the size of stack for Portable Executable, value |
of stack reserve size should follow, optionally value of stack commit |
separated with comma can follow. When stack is not defined, it's set by |
default to size of 4096 bytes. |
"heap" directive chooses the size of heap for Portable Executable, value of |
heap reserve size should follow, optionally value of heap commit separated |
with comma can follow. When no heap is defined, it is set by default to size |
of 65536 bytes, when size of heap commit is unspecified, it is by default set |
to zero. |
"data" directive begins the definition of special PE data, it should be |
followed by one of the data identifiers ("export", "import", "resource" or |
"fixups") or by the number of data entry in PE header. The data should be |
defined in next lines, ended with "end data" directive. When fixups data |
definition is chosen, they are generated automatically and no more data needs |
to be defined there. The same applies to the resource data when the "resource" |
identifier is followed by "from" operator and quoted file name - in such case |
data is taken from the given resource file. |
The "rva" operator can be used inside the numerical expressions to obtain |
the RVA of the item addressed by the value it is applied to. |
2.4.3 Common Object File Format |
To select Common Object File Format, use "format COFF" or "format MS COFF" |
directive whether you want to create classic or Microsoft's COFF file. The |
default code setting for this format is 32-bit. To create the file in |
Microsoft's COFF format for the x86-64 architecture, use "format MS64 COFF" |
setting, in such case long mode code is generated by default. |
"section" directive defines a new section, it should be followed by quoted |
string defining the name of section, then one or more section flags can |
follow. Section flags available for both COFF variants are "code" and "data", |
while "readable", "writeable", "executable", "shareable", "discardable", |
"notpageable", "linkremove" and "linkinfo" are flags available only with |
Microsoft COFF variant. |
By default section is aligned to double word (four bytes), in case of |
Microsoft COFF variant other alignment can be specified by providing the |
"align" operator followed by alignment value (any power of two up to 8192) |
among the section flags. |
"extrn" directive defines the external symbol, it should be followed by the |
name of symbol and optionally the size operator specifying the size of data |
labeled by this symbol. The name of symbol can be also preceded by quoted |
string containing name of the external symbol and the "as" operator. |
Some example declarations of external symbols: |
extrn exit |
extrn '__imp__MessageBoxA@16' as MessageBox:dword |
"public" directive declares the existing symbol as public, it should be |
followed by the name of symbol, optionally it can be followed by the "as" |
operator and the quoted string containing name under which symbol should be |
available as public. Some examples of public symbols declarations: |
public main |
public start as '_start' |
2.4.4 Executable and Linkable Format |
To select ELF output format, use "format ELF" directive. The default code |
setting for this format is 32-bit. To create ELF file for the x86-64 |
architecture, use "format ELF64" directive, in such case the long mode code is |
generated by default. |
"section" directive defines a new section, it should be followed by quoted |
string defining the name of section, then can follow one or both of the |
"executable" and "writeable" flags, optionally also "align" operator followed |
by the number specifying the alignment of section (it has to be the power of |
two), if no alignment is specified, the default value is used, which is 4 or 8, |
depending on which format variant has been chosen. |
"extrn" and "public" directives have the same meaning and syntax as when the |
COFF output format is selected (described in previous section). |
The "rva" operator can be used also in the case of this format (however not |
when target architecture is x86-64), it converts the address into the offset |
relative to the GOT table, so it may be useful to create position-independent |
code. |
To create executable file, follow the format choice directive with the |
"executable" keyword. It allows to use "entry" directive followed by the value |
to set as entry point of program. On the other hand it makes "extrn" and |
"public" directives unavailable, and instead of "section" there should be the |
"segment" directive used, followed only by one or more segment permission |
flags. The origin of segment is aligned to page (4096 bytes), and available |
flags for are: "readable", "writeable" and "executable". |
EOF |
/data/eng/docs/HOT_KEYS.TXT |
---|
0,0 → 1,10 |
The following "hot" shortcut keys are used in the system: |
(Indexing on time of appearance in the system) |
1) Ctrl + Alt + Del start of the application CPU (the manager of processes), is a sole combination maintained on a level of a kernel, all rest "hot" key is realized at the expense of the application @PANEL. |
2) Ctrl + Shift - switching of keyboard layout. |
3) Win - start of the application MENU. |
4) Alt + Ctrl + F12 - start of the application END. |
5) Alt + F4 - terminate the active application. |
6) Alt + Tab - switch to the next (in the window stack) window |
7) Alt + Shift + Tab - switch to the previous (in the window stack) window |
8) Alt + Shift + NumLock - start of the application MOUSEMUL, which emulates mouse with numpad, when NumLock is on (note: mousEmul does not create window or pictures to indicate its work!) |
/data/eng/docs/INI.TXT |
---|
0,0 → 1,25 |
Ini-files are text files of special contents: |
[name of first section] |
Key1=value1 |
Key2=value2 |
;comment |
[name of second section] |
Key3=value3 |
All lines beginning with ';' are considered as comments and ignored. |
Keyboard shortcuts are described as follows: |
any number of modificators Ctrl/Alt/Shift/LCtrl/LAlt/LShift/RCtrl/RAlt/RShift, |
followed by latin letter, digit or key name. The following keys have a name: |
F1 - F12 |
Home; End; PgUp; PgDn; Ins, equivalently, Insert; Del, equivalently, Delete; |
Tab; Plus; Esc; Enter; Backspace; Space; |
Left (left arrow); Right (right arrow); Up (up arrow); Down (down arrow). |
The string for shortcut is case-insensitive. Parts of the string |
can be written without delimiters or with '+' between parts. Examples: |
Ctrl+Alt+Backspace |
RCtrl+RShift |
ShiftA |
f10 |
shiftalt5 |
/data/eng/docs/KFAR_KEYS.TXT |
---|
0,0 → 1,94 |
Control keys in KFar. |
For panels: |
arrows, Home, End - move cursor on active panel |
Tab - change active panel |
Enter - enter to folder or run program under cursor |
F3 - view file under cursor |
F5 - copy selected items or item under cursor to another panel |
Shift+F5 - copy selected items or item under cursor to the same panel |
(of course, you must specify another file name) |
F7 - create folder |
F8 - delete selected elements or element under cursor |
F10 - exit |
Alt+F1/Alt+F2 - change drive on left/right panel |
Alt+F9 - resize window to maximum possible size and restore initial size |
Ctrl+F3 - sort file/folders on active panel by name |
Ctrl+F4 - sort by extension |
Ctrl+F5 - sort by date/time of last modification |
Ctrl+F6 - sort by size |
Ctrl+F7 - don't sort (display in order as on disk) |
Ctrl+F8 - sort by date/time of creation |
Ctrl+F9 - sort by date/time of last access |
F12 - display screens menu |
Ctrl+R - refresh active panel |
Menu - display context menu for file under cursor |
LeftCtrl+1/2/3/4 - select panel mode (brief/medium/full/wide) |
RightCtrl+0..9 - go to folder specified in the section [FolderShortcuts] |
of ini-file as Shortcut0..9 accordingly |
Insert - select/deselect current element |
Grey[+] - select files and folders with mask |
Grey[-] - deselect files and folders with mask |
The mask is like "*.asm,*.inc|template.asm" (which selects all files with |
extensions ASM and INC except for template.asm): one or more elementary |
including masks with standard mean of '*' and '?', delimited by ',' or ';', |
optionally followed by '|' and one or more elementary excluding masks. |
The mask "*.*" specifies all files having '.' in name (i.e. files with |
any non-empty extension); to specify all files use "*". |
Grey[*] - invert selection |
Alt+<letter or digit> - position cursor on name of file/folder, |
beginning from selected letter or digit; it shows fast find window, |
in which one can enter subsequent symbols of file/folder name to more precise |
selection, and also Ctrl+Enter/Shift+Ctrl+Enter to move to the next/previous |
panel item, whose name starts with specified letters |
For viewer: |
Esc = F3 = F10 = Numpad5 - exit |
Down - line down |
PgDn - page down |
Up - line up |
PgUp - page up |
Home - to begin of file |
End - to end of file |
Left - character left |
Right - character right |
Ctrl+Left - in Text-mode 20 characters left; |
in Hex-mode 1 byte left |
Ctrl+Right - in Text-mode 20 characters right; |
in Hex-mode 1 byte right |
Ctrl+Shift+Left - start of lines on the screen |
Ctrl+Shift+Right - end of lines on the screen |
F2 - toggle line wrap |
F4 - toggle Text <-> Hex mode |
F8 - toggle encoding cp866 (DOS) <-> cp1251 (Win) |
Shift+F8 - encoding tables menu |
F12 - display screens menu |
F7 - search a string from the current position in the file |
(the string and settings are set in the following dialog) |
Shift+F7 - continue to search a string |
(use the string and settings from last search by F7) |
Alt+F9 - resize window to maximum possible size and restore initial size |
For editor: |
Esc = F10 - exit; if the file was modified, the question about save necessity |
will follow |
Shift+F10 - save and exit |
F2 - save the file |
Down - move cursor down to one line |
PgDn - move cursor down to one page |
Up - move cursor up to one line |
PgUp - move cursor up to one page |
Left - move cursor left to one symbol |
Right - move cursor right to one symbol |
Home - move cursor to the beginning of the current line |
End - move cursor to the end of the current line |
Backspace - delete the symbol before the cursor |
Del - delete the symbol under the cursor |
Ins - toggle insert/replace mode when entering symbols |
F12 - display screens menu |
Alt+F9 - resize window to maximum possible size and restore initial size |
F7 - search a string starting from the position next to the cursor |
(the string and search settings are prompted in the following dialog) |
Shift+F7 - continue to search a string (same as F7 without settings dialog) |
diamond |
mailto:diamondz@land.ru |
/data/eng/docs/MTDBG.TXT |
---|
0,0 → 1,214 |
Introduction. |
mtdbg is a debugger for Kolibri operating system. This documentation describes |
debugger features and work with it. If you need some features which are |
not presented yet, either write to the forum meos.sysbin.com (if you can |
read russian texts) or mail me to address given in the end of this file. |
General description. |
In each moment of time mtdbg can debug only one program. I will call it |
loaded program. If no program is loaded, overwhelming majority of debugging |
actions is disabled. |
mtdbg is controlled by command line, entering from keyboard. Command line |
is drawn in the bottom part of debugger window. Debugger handles standard |
input keys Backspace,Delete,Home,End,left/right arrows. |
Commands are case-insensitive. Delimiter is arbitrary nonzero number of spaces. |
At any moment mtdbg can be terminated by command "quit" (without arguments). |
You can also simply press to close button in the right upper corner of window. |
When debugger is started without command string parameters, no program is |
loaded. Also mtdbg can be started with command string, in this case it tries |
to load program with the name pointed to in first parameter in command string |
and parameters pointed to following (if present). |
If no program is loaded, you can load a program with the command |
load <full name of executable file> [<parameters>] |
Examples: |
load /rd/1/example |
LOAD /rd/1/aclock w200 h200 |
LoaD /hd0/1/menuetos/dosbox/dosbox |
All that stays after first space after executable file name, is exactly passed |
to program as command string. |
The command "load" reports result in the messages window (a little higher |
than command line window). If program was loaded successfully, there will |
be the appropriate message; otherwise the message will contain error reason. |
Most probable error is "file not found" if wrong file name is given. |
The debugger can load files with information on symbols in the program |
(labels, global variables) - text files, each line of which has format |
0x<hex_value_of_addr> <name> |
(lines, which do not have such format, are ignored). Such file can be created |
by hand or generated automatically by fasm. Evident load can be done by command |
load-symbols <full name of symbols file> |
Furthermore, when the debugger executes the command "load", it checks for |
presence of file with name as of loading binary and extension '.dbg' |
(/rd/1/example.dbg in the first of examples above), and if such file exists, |
the debugger loads it automatically (with the message "Symbols loaded", if |
all is OK). |
It can happen so that loaded program is packed. General principle of |
program packing is following: at first input file is packed (by some |
pack algorithm), then is appended small code which gets control at program |
start, unpacks input code in the memory and then passes control to it. |
If program is packed, it "real" code is not visible and for debugging it is |
needed previously to pass through unpacker code. |
mtdbg determines most of existing packers (mxp,mxp_lzo,mxp_nrv,mtappack) |
and in this case suggests to automatically go to "real" code. It is recommended |
to accept (press 'y' or <Enter>), but you can refuse too. At refusal and if |
program is packed by something unknown the command "unpack" (without arguments) |
can be used. Call it only in the case when you are sure that program is packed |
and control has not already went to main code! [Starting from Kolibri 0.6.5.0, |
this paragraph is no more actual, because one can pack applications as all |
binary files with kpack and the unpacker code in this case is located in the |
kernel and is transparent for debug.] |
Loaded program can be terminated by the command "terminate" (without |
arguments). The command "detach" (without arguments) detaches from program, |
after that program continues execution normally, as if there was no debugger. |
After both this commands program stops to be debugged. |
It is possible to anew load program for debugging by the command "reload" |
(without arguments). If there is already loaded program, it is terminated |
and new instance is started (from the beginning) (with the same command |
string), in this case the command is similar to the commands |
terminate |
load <last program name> <last program arguments> |
Otherwise is loaded anew latest program, which was debugged (in the current |
seance of work with mtdbg) (with the same command string), i.e. is similar to |
load <last program name> <last program arguments>, |
but the command "reload" in both cases is shorter and more convenient; |
moreover, "load" thinks that new program is loaded and moves data window |
(see below) to zero address, and "reload" keeps current address. |
The command "help", which can be shorten to "h", is always available. |
All commands are divided on groups. |
"help" without arguments displays the list of command groups. |
"help" with group name displays the list of commands in this group with short |
comments. |
"help" with command name displays information about given command. |
Examples: |
help |
help control |
h LoaD |
The debugger window consists from the following items enumerated from up |
to down: |
- status string. If there is loaded program, shows its name and state |
("Running/Paused"), otherwise reports "No program loaded". |
- registers window - shows values of general-purpose registers, register eip |
and states of single flags: CF,PF,AF,ZF,SF,DF,OF: if flag is cleared, then |
is displayed lower-case letter, if flag is set, then upper-case one. |
Registers which are changed from previous moment are highlighted in green. |
- data window (dump window) - shows memory contains of loaded program |
- code window (disassembler window) - shows program code as disassembled |
instructions |
- messages window |
- command line window |
Dump window can display data starting from any address, to this serves |
the command |
d <expression> |
The command "d" without arguments flicks dump window down. |
The same is for code window and the command |
u <expression> |
or simply "u". |
Examples: |
d esi - displays data at address esi (e.g. is useful before execution of |
instruction rep movsb) |
d esp - displays stack |
u eip - disassembles instruction starting from the current |
Expressions in mtdbg can include |
- hexadecimal constants |
- names of all general-purpose registers (8 32-bits, 8 16-bits and |
8 8-bits) and register eip; values of 16- and 8-bits registers are padded |
with zeroes to 32 bits |
- four arithmetic operations +,-,*,/ (with standard priorities) and |
brackets |
- [if symbols information was loaded] names, loaded from dbg-file |
All calculations are realized modulo 2^32. |
Examples of expressions: |
eax |
eip+2 |
ecx-esi-1F |
al+AH*bl |
ax + 2* bH*(eip+a73) |
3*esi*di/EAX |
The command |
? <expression> |
calculates value of specified expression. |
Values of registers in loaded program can be changed by the command "r", which |
has two absolutely equivalent forms: |
r <register> <expression> |
r <register>=<expression> |
(in both cases you can place spaces as you want). Register can be any of |
above-mentioned - 24 general-purpose registers and eip. |
Let us assume that the command "load" was successfully load program for |
debugging. |
Immediately after loading program is suspended and does not execute. |
Press Ctrl+F7 (command-line analog is the command "s") to make one step |
in loaded program, after that control returns to debugger which displays |
new contains of registers and memory. The system call "int 40h" is considered |
as one step. |
Pressing Ctrl+F8 (command-line analog is the command "p") also makes step in |
loaded program, but procedure calls, string operations with prefix |
rep/repz/repnz and 'loop' cycles are executed as one step. |
The one-step commands are used usually on single program sections, |
when it is needed, for example, to regularly trace registers value and/or |
some variables in memory. |
The command |
g <expression> |
resumes program execution and waits until control goes to eip=given address, |
and in this moment suspends program. The command "g" without arguments |
simply resumes execution. |
To suspend program use the command "stop" (without arguments). |
In the typical situation it is required that program is executed normally, |
but when some conditions are satisfied, program suspends and debugger receives |
control. The corresponding conditions are called breakpoints or simply breaks. |
Primary type of breakpoints is to concrete address, i.e. stop execution at |
eip=<given value>. Such breakpoints are set by the command |
bp <expression> |
Note that if there is only one such breakpoint, there is more convenient to use |
the command "g" with argument instead. |
Other type of breakpoints is on access to given memory area. Maximum |
numbers of such breakpoints is 4 (because hardware features of x86 processors |
are used and they allows only 4). |
bpm <expression> - breaks at any access to byte at given address |
bpm w <expression> - breaks at write to byte at given address |
bpmb,bpmw,bpmd <expression> - breaks to access correspondingly to byte, word |
or dword at given address. bpm ¨ bpmb are synonyms. When bpmw,bpmd are used, |
address must be aligned according to correspondingly word bound (i.e. be even) |
or dword bound (i.e. be divisible by 4). |
bpmb,bpmw,bpmd w <expression> - similar to break on write. |
To see the list of set breakpoints use the command "bl", to obtain information |
on concrete breakpoint use "bl <number>". Unnecessary breakpoints can be |
deleted with the command "bc <number>", temporarily unnecessary can be |
disabled by the command "bd <number>", when they will be needed again, |
use the command "be <number>". |
Remarks. |
1. When debugging your own programs you can put in code instructions |
int3 (pay attention to absence of space!). Such instruction causes |
exception at normal run, which leads to process termination, but |
at work under debugger it is simply activated (with the message |
"int3 command at xxx"). This feature allows to not think about addresses |
to use in the commands g and/or bp. |
2. All output and all input is oriented on hexadecimal scale of notation. |
3. When program is executed, registers and data window shows information |
regarding to moment before resume; you can not set registers value in this |
mode. Nevertheless the command "d" in this mode shows information that |
was true in the moment of command delivery. |
diamond |
mailto:diamondz@land.ru |
/data/eng/docs/README.TXT |
---|
0,0 → 1,268 |
************************ |
* Kolibri OS 0.7.7.0+ * |
* February 2010 * |
************************ |
The latest release of the OS is available on the official site: |
http://kolibrios.org |
If you have questions - look for support on our forum: |
http://board.kolibrios.org (rus+eng) |
*********************************** |
* What is new in this release? * |
*********************************** |
The following changes, revisions, fixes in the kernel have been made: |
From Evgeny Grechnikov (Diamond) - Russian Federation |
1) Improvement of drives detection using BIOS service (V86) |
2) Kernel bugfixes. |
From Sergey Semyonov (Serge) - Russian Federation |
1) Driver for ATI videocards updated. |
2) Linux-like kernel mutexes |
From Mihail Semenyako (mike.dld) - Republic of Belarus |
1) Refactoring of window subsystem. |
From <Lrz> |
1) Processing API functions in order to completely remove the shift-register-call |
2) Refactoring, optimization, bugfixes of some places in the kernel. |
From A.Jerdev (art_zh) - United Kingdom |
1) Memory-mapped I/O (MMIO) access from the userworld. |
2) PCIe Extended configuration space access (auto-adjust for AMD-NPT since Athlon64). |
From turbanoff |
1) Read from ext2fs/ext3fs. |
From Marat Zakiyanov (Mario79) - Russian Federation |
1) Improvements in the processing of mouse clicks. |
From hidnplayr |
1) Rewriting of the entire network subsystem. |
From Asper |
1) Drivers for the sound cards VT823(X) and EMU10K1X. |
From tsdima |
1) Driver for the sound card ForteMedia fm801. |
From Maxis |
1) changes in free memory checks. |
The following changes, revisions, fixes in applications have been made: |
* New versions of applications and new applications: |
FTPS - tsdima, some improvements |
VIEW3DS - macgub, version 0.054 |
FASM - Pavel Rymovski (Heavyiron), updated to version 1.69.11 |
IgorA, use the library box_lib, russification, |
Marat Zakiyanov (Mario79) fix bugs encountered |
Evgeny Grechnikov (Diamond), fix of window wrapping |
PCIDEV - art_zh, MMIO sample dumps added; vendors database |
trimmed to reduce the distro size. |
BOARD - Evgeny Grechnikov (Diamond), do not throw out existing |
messages at the program start |
UNVWATER - Asper, demo ported from OctaOS |
(the author is Octavio Vega Fernandez). |
HEED - staper, version 0.14: use the library box_lib; |
Ctrl+C/X/V, Ctrl+B to select a block |
Marat Zakiyanov (Mario79), using of OpenDialog component, |
little optimization of the code |
SHELL - Albom, version 0.4.2 |
CPU - Evgeny Grechnikov (Diamond) at the suggestion of |
Kirill Lipatov (Leency), do not show system processes |
by default |
HTMLV - Kirill Lipatov (Leency), version 0.62a |
EOLITE - Kirill Lipatov (Leency), version 0.98.7a |
RTFREAD - Sorcerer, cosmetic fix |
dunkaist, menu_bar and scroll_bar from box_lib, 'end' hotkey |
E80 - Albom, version 0.5.1 |
KIV - Evgeny Grechnikov (Diamond), file name in the window |
title, configurable keyboard shortcuts for next/prev |
images in the current folder |
SUDOKU - staper, port of Sudoku game - that is a puzzle with digits, where you |
have to fill free cells with digits from 1 to 9 so that every row, |
every column and every small square 3x3 contain each digit just one time. |
There are 9 levels in the game. |
REVERSI - staper, port of strategy game Reversi (Othello) |
MSQUARE - staper, math puzzle "magic square": sum of the numbers in rows, columns |
(less often in diagonals) should be equal |
FINDN-S - Artemonische, a simple game in which you have to collect all the numbers |
in the order of 10 to 90 |
PANEL - Evgeny Grechnikov (Diamond), a little change in the panel clock |
and reanimation of backlight on the Alt+[Shift+]Tab press. |
AC97SND - Asper, support of playlists in m3u format. |
@NOTIFY - SoUrcerer, program for popup text messages |
DOSBOX - Evgeny Grechnikov (Diamond), version 0.74 |
ASCIIVJU - Konstantin Dutkevich (Nazarus), program shows ASCII table |
PIPETKA - Rock_maniak_forever, program to get color of a pixel on the screen |
SNAKE - dunkaist, yet another implementation of classic game |
* New versions of dynamic libraries and new dynamic libraries: |
libini - Evgeny Grechnikov (Diamond), added function to read |
keyboard shortcuts |
box_lib - IgorA, update component tree_list, new component |
text_editor, documentation on the library |
Marat Zakiyanov (Mario79) refinement of penDialog component, rewriting |
of some applications to use it, new component PathShow |
/-----------------------------------------------\ |
* Dates of publication of the distribution kits * |
\-----------------------------------------------/ |
RE N1 30.08.2003 |
RE N2 07.10.2003 |
RE N3 26.11.2003 |
RE N4 23.12.2003 |
RE N5 15.02.2004 |
RE N6 27.03.2004 |
KOLIBRI N1 16.05.2004 |
RE N7 11.06.2004 |
KOLIBRI N2 28.08.2004 |
RE N8 01.12.2004 |
KOLIBRI N3 22.02.2005 |
Beta 2: 20.03.2005 |
KOLIBRI N4 07.06.2005 |
KOLIBRI 0.5.0.0 04.10.2005 |
0.5.1.0 12.10.2005 |
0.5.2.0 02.12.2005 |
0.5.3.0 18.03.2006 |
0.5.8.0 09.07.2006 |
0.5.8.1 25.07.2006 |
0.6.0.0 04.09.2006 |
0.6.3.0 31.10.2006 |
0.6.5.0 14.02.2007 |
0.7.0.0 07.06.2007 |
0.7.1.0 23.09.2007 |
0.7.5.0 31.01.2009 |
0.7.7.0 13.12.2009 |
/----------------\ |
* KolibriOS TEAM * |
\----------------/ |
This list contains all, who has actively helped to creation and development |
of KolibriOS, whoever possible. |
(people are enumerated in the order by time of participation in the project, |
from bottom to top - from past to future, through present) |
* Trans \ |
* VaStaNi | |
* Ivan Poddubny | |
* Marat Zakiyanov (Mario79) | |
* Mihail Semenyako (mike.dld) | system programming |
* Sergey Kuzmin (Wildwest) | |
* Andrey Halyavin (halyavin) | loaders, |
* Mihail Lisovin (Mihasik) | kernel improvements and so on |
* Andrey Ignatiev (andrew_programmer) | |
* NoName | |
* Evgeny Grechnikov (Diamond) | |
* Iliya Mihailov (Ghost) | |
* Sergey Semyonov (Serge) | |
* Johnny_B | |
* kasTIgar | |
* SPraid | |
* Rus | |
* Alver | |
* Maxis | |
* Galkov | |
* CleverMouse | |
* tsdima | |
* turbanoff | |
* Asper | |
* art_zh / |
* Mihail Lisovin (Mihasik) \ |
* Andrey Ivushkin (Willow) | |
* Mihail Semenyako (mike.dld) | |
* Pavlushin Evgeny (Exis) | |
* Ivan Poddubny | application programming |
* Marat Zakiyanov (Mario79) | |
* Sergey Kuzmin (Wildwest) | |
* Andrey Halyavin (halyavin) | creation of new, |
* Hex | port of existing |
* Andrey Ignatiev (andrew_programmer) | or revisions of old |
* ealex | applications for Kolibri |
* Olaf | |
* Evgeny Grechnikov (Diamond) | |
* Navanax | |
* Johnny_B | |
* Pavel Rymovski (Heavyiron) | |
* Vitaly Bendik (mistifi(ator) | |
* Iliya Mihailov (Ghost) | |
* Maxim Evtihov (Maxxxx32) | |
* Vladimir Zaitsev (Rabid Rabbit) | |
* vectoroc | |
* Alexey Teplov (<Lrz>) | |
* Sergey Semyonov (Serge) | |
* YELLOW | |
* iadn | |
* Maciej Guba (macgub) | |
* Mario Birkner (cYfleXX) | |
* hidden player (hidnplayr) | |
* trolly | |
* nilgui | |
* kaitz | |
* DedOk | |
* SPraid | |
* Rus | |
* Alver | |
* Dron2004 | |
* Gluk | |
* Aleksandr Bogomaz (Albom) | |
* Kirill Lipatov (Leency) | |
* Vasiliy Kosenko (vkos) | |
* IgorA | |
* staper | |
* chaykin | |
* Alexander Meshcheryakov | |
(Self-Perfection) | |
* CleverMouse | |
* tsdima | |
* art_zh | |
* Asper | |
* Pterox | |
* Artemonische | |
* dunkaist / |
* Hex \ |
* Diamond / documentation |
* CodeWorld \ forum http://meos.sysbin.com |
* mike.dld / site http://kolibrios.org; svn-server |
* Alexey Teplov (<Lrz>) \ (KolibriOS logo) |
* goglus | design (KolibriOS background) |
* Kirill Lipatov (Leency) / (KolibriOS icons) |
* Pavel Rymovski (Heavyiron) \ |
* Vitaly Bendik (mistifi(ator) | |
* vectoroc | |
* Veliant | testing, |
* AqwAS | countenance |
* Mike | |
* camper | |
* Dmitry the Sorcerer | |
* Ataualpa | |
* Maxis | |
* Galkov | |
* ChE / |
and others... |
KolibriOS team |
/data/eng/docs/STACK.TXT |
---|
0,0 → 1,387 |
What is implemented |
=================== |
The following features are present in the TCP/IP stack code: |
IP layer. |
ICMP. |
TCP layer. |
UDP layer. |
local loopback. |
Realtek 8029 PCI ethernet interface. |
Realtek 8139 PCI ethernet interface. |
Intel i8255x PCI ethernet interface. |
Dynamic ARP table. |
PPP dialer |
And the following internet applcations are implemented |
HTTP Server |
Telnet |
POP Client |
DNS Name resolver |
MP3 Server |
TFTP Client |
IRC Client |
There are also a number of experimental applications for streaming music |
and performing interprocess communication via sockets. A Web broswer is in |
development |
What is not implemented |
======================= |
The IP layer does not process header options. |
The IP layer does not support routing. |
Packet fragmentation is not supported. |
How to configure Kolibri for PPP |
=============================== |
See ppp.txt |
How to configure Kolibri for Ethernet |
==================================== |
First, you need to have a supported ethernet card fitted, or present |
on your motherboard. If you are uncertain what type of hardware you |
have, try to configue the stack. If you have supported hardware it |
will be found, and enabled. |
Setting Up the ARP Table |
------------------------ |
Kolibri's ARP table is dynamically created and maintained; You can see what |
hosts Kolibri has communicated with by running the ARPSTAT application. |
Enabling Ethernet |
----------------- |
Boot Kolibri, then select STACKCFG from the NET menu. |
Press the 'Read' Button, then select 'Packet Driver'. |
Press 'Change' next to the IP address, and enter the IP address you want |
to use. Make sure it is on the same sub-net as the LAN to which you are |
connected. |
Press 'Apply' to action the changes. |
Close the program. |
The stack is now running, which you can test by pinging Kolibri from a |
remote host. |
The simplest way to connect two PC's together is using a 'Null Modem' |
Ethernet cable. These simply cross certain wires over. They can be |
purchased from PC stores, but are simple to make. Details can be found |
on the web. Look on google for 'ethernet cross over cable' or similar. |
How to use TCP/IP locally, with no Network |
========================================== |
Kolibri supports a form of local loopback that means applications on the |
same PC can communicate with each other via sockets as though they |
were on separate hosts. To connect to an application on the same machine, |
specify the local IP address as the destination address. You do not even |
need to configure the stack for ethernet; local loopback will work without |
any network hardware. It's great for development and testing. |
Application Programming Interface |
================================= |
The developer can access the stack through interrupt 0x40, function 53. |
The file TFTPC.ASM gives a good example of how to use the programming |
interface ( at least, for UDP), but as network communication is complex |
I'll give an overview. |
Sockets |
======= |
Applications connect to each other and pass information between themselves |
through a mechanism called a 'socket'. Sockets are end-points for |
communication; You need one at each application to communicate. |
Using sockets is a little like using files on an OS; You open them, read |
and write to them, then close them. The only thing that makes life slightly |
more complicated is that unlike with a file, you have something intelligent |
at the other end ( which for example may not want to close when you do! ) |
Lets deal with the terminology before we go any further. |
socket A unique identifier used by the application for communication. |
local port A number that identifies this application on the local host. |
Ports are a way to allow multiple applications to communicate |
with other hosts without the data becoming mixed up. ( The |
technical term is 'multiplex' ). Port numbers are 16 bit. |
remote port A number that identifies the application on the remote host |
to which we are communicating with. To the remote host, this is |
it's 'local port'. Port numbers are 16 bit. |
IP Address A 32 bit number that identifies the remote host PC that we are |
communicating with. |
Passive Refers to the mode by which a socket is opened; When opening in |
passive mode, the local PC is awaiting an incoming connection. |
Active Refers to the mode by which a socket is opened; When opening in |
active mode, the local PC will attempt to connect to a remote |
PC. |
When you connect to a socket on a remote PC, you need to specify more than |
just the IP address, otherwise the remote stack will not know to which |
application it should send your data. You must fully qualify the address, |
which means you specify the IP address and the port number. This would be |
written like this |
192.168.1.10:80 ; Connect to port 80 on the machine 192.168.1.10 |
Port numbers are important. Some are 'well known' and provide access to |
common applications. For example port 80 is used by HTTP servers; That |
way I can connect to a webserver on a host without having to find out |
what port number the application is listening on. |
This brings me to the way in which you open a socket; As I said earlier, |
there are two modes, Passive and Active. A webserver would open a passive |
socket, as it is waiting for incoming connection requests. A web browser |
would open an active socket because it is attempting to connect to a |
specified remote host. |
Access to programming interface |
=============================== |
The developer accesses the stack functions through interrupt 0x40, |
function 53. Some functions may be accessed through function 52, but these |
are mainly for stack configuration. |
Here is a summary of the functions that you may use and the parameter |
definitions. |
Get Local IP Address |
-------------------- |
eax = 52 |
ebx = 1 |
IP address returned in eax ( in internet byte order ) |
Write to stack input queue |
-------------------------- |
eax = 52 |
ebx = 6 |
edx = number of bytes to write |
esi = pointer to data ( in application space ) |
On return, eax holds 0 for OK, or 0xFFFFFFFF for error. |
This interface is for slow network drivers only ( PPP, SLIP ) |
Read data from network output queue |
----------------------------------- |
eax = 52 |
ebx = 8 |
esi = pointer to data ( in application space ) |
On return, eax holds number of bytes transferred. |
This interface is for slow network drivers only ( PPP, SLIP ) |
Open a UDP socket |
----------------- |
eax = 53 |
ebx = 0 |
ecx = local port |
edx = remote port |
esi = remote ip address ( in internet byte order ) |
The socket number allocated is returned in eax. |
A return value of 0xFFFFFFFF means no socket could be opened. |
Open a TCP socket |
----------------- |
eax = 53 |
ebx = 5 |
ecx = local port |
edx = remote port |
esi = remote ip address ( in internet byte order ) |
edi = mode : SOCKET_PASSIVE or SOCKET_ACTIVE ( defined in stack.inc ) |
The socket number allocated is returned in eax. |
A return value of 0xFFFFFFFF means no socket could be opened. |
Close a socket (UDP Only ) |
-------------------------- |
eax = 53 |
ebx = 1 |
ecx = socket number |
On return, eax holds 0 for OK, or 0xFFFFFFFF for error. |
Close a socket (TCP Only ) |
-------------------------- |
eax = 53 |
ebx = 8 |
ecx = socket number |
On return, eax holds 0 for OK, or 0xFFFFFFFF for error. |
Poll socket |
----------- |
eax = 53 |
ebx = 2 |
ecx = socket number |
On return, eax holds the number of bytes in the receive buffer. |
Read socket data |
---------------- |
eax = 53 |
ebx = 3 |
ecx = socket number |
On return, eax holds the number of bytes remaining, bl holds a data byte. |
Write to socket ( UDP only ) |
---------------------------- |
eax = 53 |
ebx = 4 |
ecx = socket number |
edx = number of bytes to write |
esi = pointer to data ( in application space ) |
On return, eax holds 0 for OK, or 0xFFFFFFFF for error. |
Return socket status ( TCP only ) |
--------------------------------- |
eax = 53 |
ebx = 6 |
ecx = socket number |
On return, eax holds the sockets TCP status. |
This function can be used to determine when a socket has actually connected |
to another socket - data cannot be written to a socket until the connection |
is established (TCB_ESTABLISHED). The states a socket can be in are defined |
in stack.inc as TCB_ |
Write to socket ( TCP only ) |
---------------------------- |
eax = 53 |
ebx = 7 |
ecx = socket number |
edx = number of bytes to write |
esi = pointer to data ( in application space ) |
On return, eax holds 0 for OK, or 0xFFFFFFFF for error. |
Check port number |
----------------- |
eax = 53 |
ebx = 9 |
ecx = port number |
This function is used to determine if a port number |
is in use by any sockets as a local port number. Local |
port numbers are normally unique. |
On return, eax is 1 for port number not in use, 0 otherwise. |
Opening a TCP socket in Kolibri |
=============================== |
There are two ways to open a socket - Passive or Active. |
In a Passive connection your application 'listens' for incoming |
requests from remote applications. Typically this will be done when |
you are implementing a server application that allows any other |
application to connect to it. You would specify a 'known' local |
port number, such as 80 for a web server. You would leave the |
remote IP and remote port number as 0, which indicates any |
remote application may connect. |
Once the socket has been opened you would wait for an incoming |
connection before doing anything. This can be by either checking |
the socket status for TCB_ESTABLISHED, or waiting for data in the |
receive buffer. |
In an Active connection, you are making a connection to a specified |
remote port. The remote IP and remote port parameters must be filled |
in with non-zero values ( otherwise, what are you connecting to? ). |
You also specify a unique local port number so the remote application |
can uniquely identify you - after all, there may be several applications |
on your machine connected to the same remote host. See below for finding |
a unique port number. |
How to find an unused local port number |
======================================= |
Typically when you are creating an active connection to a remote |
socket you will want to choose a unique local port number. Local |
port numbers normally start from 1000; The following code may |
be used to obtain an unused port number prior to making the |
open socket call. |
mov ecx, 1000 ; local port starting at 1000 |
getlp: |
inc ecx |
push ecx |
mov eax, 53 |
mov ebx, 9 |
int 0x40 |
pop ecx |
cmp eax, 0 ; is this local port in use? |
jz getlp ; yes - so try next |
; ecx contains a free local port number |
Writing data to a socket |
======================== |
There are two functions available depending on whether the socket |
was opened for TCP or UDP protocol; The call parameters are the |
same however. When the socket is being opened for TCP, use the |
status function to poll for a connection - data cannot be written |
to a socket until another socket has connected to it, and the |
state of the socket is TCB_ESTABLISHED. |
When you write data, the call results in a single IP packet being |
created and transmitted. Thus the user application is responsible for |
the size of transmitted packets. Keep the packet sizes under 768 bytes. |
If you are writing a terminal program like telnet, you may want to send |
a packet for each keystroke ( inefficient ) or use a timer to send data |
periodically ( say, every second ). |
Reading data from a socket |
========================== |
There is one function to read data from a sockets receive buffer. This |
function retrieves one byte at a time. You can use the poll function to |
test the receive buffer for data. |
Closing a socket |
================ |
Simply call the appropriate function - there is one for TCP, and another |
for UDP. When closing a TCP socket, don't forget that the other end |
may continue to send data, so the socket may remain active for a |
few seconds after your call. |
If you have any questions or have suggestions for improving this |
document please contact me at mikeh@oceanfree.net. |
/data/eng/docs/VRR_ENG.TXT |
---|
0,0 → 1,104 |
Vertical Refresh Rater |
Version 2.0 |
Copyright (C) 2003, Trans |
Text Version 1.1 (02.08.03) |
Win text (cp1251). (DOS codepage text - see down.) |
------------------------------------------------------------------------------- |
Contents: |
1. Why it need? |
2. Installation. |
3. Using. |
4. FAQ. |
5. Support. |
1. Why it need? |
--------------------- |
The problem of "60 Hz" is falling stand before of users of MeOS in modern condisions. |
As a rule, most modern computers consist of 17" monitor (all written later is not actual |
for owners of LCD monitors). If on 14" or 15" monitors the problem of "60 Hz" not a |
main, but with 17" monitor it's a most pantfull. And with more size monitors I have no |
words for discusion: it's a slade-show. Of couse, all of the upper correlated with |
standart interface of VESA. As for VESA 3.0 - yes, interface have more rich features, |
but it have no possiblity of change videomode in protect mode (the Virtual86 not realized |
in MeOS !!!!!). |
The MeOS not known as a detected devices on boot, it setting of standard VESA videomode |
with 60 Hz vertical refrash rate ! |
This programm is a FreeWare. And distribute "AS IS ...". Author not |
carreing responsibility for probable damage :) . |
!!!!!_Warning_!!!!!: |
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
! On this time programm have a EXPERIMENTAL status (!). And this reason you have a ! |
! chance destroy own device (monitor). Espesialy this taking attantionall users with ! |
! monitor without of rate protection. ! |
! If you decide using this util I have a suggestion: fill of information form and ! |
! send me. ! |
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
2. Installation. |
----------------- |
Extract file VRR (it's ordinary executed MeOS file) from archive and situated it on |
C:\ root or MeOS floppy. In main, VRR may situated on any directory (you must have |
possibility run this file under MeOS). |
3. Using. |
---------- |
The VRR is a standard executed file of Menuet Operation System. You may send on |
execute this file by SYSTREE or MASH. |
After redraw of programm window will be present of current vertical refrash rate |
and table with possibiling videoregimes. It's sorrably, table have VERY small |
videomode (the programm is experimental). |
Change of videomode |
~~~~~~~~~~~~~~~~~~~~~ |
You may select interesting videomode using _ONLY_ numerical keys: 1,2,3,4 and 5. |
In a first step you must select resolution of videoregime. In a second step - need |
select of vertical refresh rate. All changes are indicated on screen in a the |
programm window. After select videomode, to set mode you must press "Enter" or |
button "Ok". Notification: in this time all executing MeOS programs will be |
killing. It this needed for minimize artefacts of the screen. After change videomode |
you have a two way. First way: you can not any doing and after 13 seconds waiting |
return last videomode. Second way: press two-three time any key or some time mouse |
click on artefacts of VRR (or this plase) and fixing selected mode. Also you have |
possibility modification of horizontal screen size by button "Left"\"Right" or keys |
"+\-". For correcting your select you may use button "Cancel". |
Also in programm realized return at initial videomode with 60 Hz vertical refresh |
by button "Default". And you may return in last videomode by button "Return" or |
key "r" |
Note: |
~~~~~~ |
In this time programm may change vertical refresh rate _ONLY_ by lowing screen |
resolution, because this method will be using at most part videocard |
(VGA, SVGA or modern) |
Example: |
If you have videomode 1024x768x60Hz and if you want select 800x600x95Hz, you must |
press key "3" and key "1". After that key "Enter" or button "Ok". And after redraw |
screen two time click on last program window position. If need using button |
"Left\Right" for correcting horizontal size. |
4. FAQ. |
---------- |
5. Supports. |
---------------- |
All questions, notes and wishs you may send to author by following e-mail: |
transafe@rambler.ru |
transafe@chat.ru |
trans397@yahoo.com |
Using with enjoy! |
Trans. |
/data/eng/drivers/atikms.dll |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/eng/e80 |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/eng/fonts/bold.chr |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/eng/fonts/char.mt |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/eng/fonts/char2.mt |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/eng/games/FindNumbers |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/eng/games/bnc |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/eng/games/c4 |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/eng/games/checkers |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/eng/games/clicks |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/eng/games/gomoku |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/eng/games/klavisha |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/eng/games/kosilka |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/eng/games/kosskin.gfx |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/eng/games/kox |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/eng/games/lights |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/eng/games/megamaze |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/eng/games/mine |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/eng/games/msquare |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/eng/games/reversi |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/eng/games/rforces |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/eng/games/snake.ini |
---|
0,0 → 1,175 |
;;===Common_preferences================================================= |
[Preferences] |
Speed=80 |
; SLOW == 0 <= Speed <= 100 == FAST |
Theme=Theme_standard |
; Theme name to use |
; See [Theme_*] sections below for available themes |
; Name of any theme must be shorter than 30 chars |
;;---Common_preferences------------------------------------------------- |
;;===Visual_themes====================================================== |
[Theme_standard] |
; all these keys are optional |
Decorations = 2 |
; 0 = nothing |
; 1 = grid_lines |
; 2 = grid_lines_with_ends |
; 3 = grid_lines_with_corners |
; 4 = grid_dots |
; 5 = borders_lines |
; 6 = borders_lines_with_corners |
; 7 = borders_dots |
; 8 = corners_dots |
; 9 = corners_inner |
; 10 = corners_outer |
; 11 = corners_crosses |
Background_color = 0,0,0 |
Decorations_color = 170,170,0 |
Snake_color = 17,17,255 |
Snake_head_color = 107,107,255 |
; by default Snake_head_color is equal to Snake_color, so the snake has no head |
Snake_picture_color = 68,136,255 |
; color of big 'SNAKE' label at start menu |
Version_picture_color = 85,255,85 |
Pause_picture_color = 17,255,17 |
Game_over_picture_color = 255,17,17 |
; ... if you end game without new record |
You_win_picture_color = 255,255,17 |
; ... if you end game with new record |
Navigation_string_color = 255,119,119 |
; color of 'PRESS * to *' and like this strings |
Game_over_string_color = 255,153,0 |
; color of strings on game_over screen |
Game_over_hiscore_color = 255,221,68 |
; color of new hiscore and champion name on game_over screen |
Eat_color = 255,255,17 |
Score_number_color = 255,255,255 |
; color of "SCORE : " string at the left bottom screen part |
Score_string_color = 255,255,255 |
; color of digits after "SCORE : " |
Level_string_color = 255,255,255 |
; color of "LEVEL : " string at the left bottom screen part |
Level_number_color = 255,255,255 |
; color of digits after "LEVEL : " |
Hiscore_number_color = 255,255,255 |
Hiscore_string_color = 255,255,255 |
Champion_string_color = 255,255,255 |
Champion_name_color = 255,255,255 |
Edit_box_selection_color= 0,176,0 |
Button_color = 221,221,221 |
; color of buttons 'play', 'exit' etc at start menu |
Button_text_color = 0,0,0 |
; color of the text on these buttons |
Stone_color = 95,135,0 |
Splash_background_color = 170,170,0 |
; background color for "LEVEL ??" label between levels |
Splash_level_string_color= 0,0,0 |
; color of "LEVEL" label |
Splash_level_number_color= 0,0,0 |
; color of two level number digits on splash between levels |
[Theme_light] |
Decorations = 2 |
Background_color = 245,245,245 |
Decorations_color = 55,55,55 |
Snake_color = 225,125,225 |
Snake_head_color = 255,125,55 |
Snake_picture_color = 105,155,205 |
Version_picture_color = 155,255,0 |
Pause_picture_color = 75,255,75 |
Game_over_picture_color = 225,125,105 |
You_win_picture_color = 55,255,155 |
Navigation_string_color = 205,105,105 |
Game_over_string_color = 205,105,105 |
Game_over_hiscore_color = 205,75,75 |
Eat_color = 225,225,25 |
Score_number_color = 100,100,255 |
Score_string_color = 100,100,255 |
Level_string_color = 100,100,255 |
Level_number_color = 100,100,255 |
Hiscore_number_color = 100,100,255 |
Hiscore_string_color = 100,100,255 |
Champion_string_color = 100,100,255 |
Champion_name_color = 100,100,255 |
Edit_box_selection_color= 0,176,0 |
Button_color = 221,221,221 |
Button_text_color = 0,0,0 |
Stone_color = 105,185,255 |
Splash_background_color = 185,255,185 |
Splash_level_string_color= 165,165,255 |
Splash_level_number_color= 255,165,165 |
[Theme_ultra_white] |
Decorations = 10 |
Background_color = 255,255,255 |
Decorations_color = 0,0,0 |
Snake_color = 30,30,30 |
Snake_head_color = 30,30,30 |
Snake_picture_color = 30,30,30 |
Version_picture_color = 70,70,70 |
Pause_picture_color = 30,30,30 |
Game_over_picture_color = 30,30,30 |
You_win_picture_color = 105,105,105 |
Navigation_string_color = 255,255,255 |
Game_over_string_color = 30,30,30 |
Game_over_hiscore_color = 0,0,0 |
Eat_color = 0,255,0 |
Score_number_color = 0,0,0 |
Score_string_color = 255,255,255 |
Level_string_color = 255,255,255 |
Level_number_color = 255,255,255 |
Hiscore_number_color = 0,0,0 |
Hiscore_string_color = 255,255,255 |
Champion_string_color = 255,255,255 |
Champion_name_color = 255,255,255 |
Edit_box_selection_color= 176,176,176 |
Button_color = 221,221,221 |
Button_text_color = 0,0,0 |
Stone_color = 145,145,145 |
Splash_background_color = 205,205,205 |
Splash_level_string_color= 255,255,255 |
Splash_level_number_color= 255,255,255 |
[Theme_ultra_black] |
Decorations = 6 |
Background_color = 0,0,0 |
Decorations_color = 255,255,255 |
Snake_color = 255,255,255 |
Snake_head_color = 255,255,255 |
Snake_picture_color = 255,255,255 |
Version_picture_color = 225,225,225 |
Pause_picture_color = 225,225,225 |
Game_over_picture_color = 225,225,225 |
You_win_picture_color = 255,255,255 |
Navigation_string_color = 0,0,0 |
Game_over_string_color = 225,225,225 |
Game_over_hiscore_color = 225,225,225 |
Eat_color = 255,0,0 |
Score_number_color = 255,255,255 |
Score_string_color = 255,255,255 |
Level_string_color = 0,0,0 |
Level_number_color = 0,0,0 |
Hiscore_number_color = 255,255,255 |
Hiscore_string_color = 255,255,255 |
Champion_string_color = 0,0,0 |
Champion_name_color = 0,0,0 |
Edit_box_selection_color= 100,100,100 |
Button_color = 221,221,221 |
Button_text_color = 0,0,0 |
Stone_color = 145,145,145 |
Splash_background_color = 30,30,30 |
Splash_level_string_color= 255,255,255 |
Splash_level_number_color= 255,255,255 |
[Theme_your_theme_name] |
;;---Visual_themes------------------------------------------------------ |
;;===Reserved_Section=================================================== |
[Reserved] |
Square_side_length=19 |
Champion_name_classic= |
Hiscore_classic=777 |
Champion_name_levels= |
Hiscore_levels=222 |
/data/eng/games/sq_game |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/eng/games/sudoku |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/eng/games/sw |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/eng/games/xonix |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/eng/graph |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/eng/hdread |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/eng/htmlv |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/eng/icons.dat |
---|
0,0 → 1,27 |
AA-FASM -010-/SYS/DEVELOP/FASM - * |
AB-TINYPAD -009-/SYS/TINYPAD - * |
BA-EOLITE -002-/SYS/File Managers/EOLITE - * |
CA-SHELL -020-/SYS/SHELL - * |
BB-KFAR -024-/SYS/File Managers/KFAR - * |
AC-RDSAVE -017-/SYS/RDSAVE - * |
BC-CALC -004-/SYS/CALC - * |
CB-KFM -005-/SYS/File Managers/KFM - * |
JA-VRR -007-/SYS/VRR - * |
II-C4 -003-/SYS/GAMES/C4 - * |
JI-MINE -014-/SYS/GAMES/MINE - * |
IH-TETRIS -018-/SYS/GAMES/TETRIS - * |
JH-MBLOCKS -011-/SYS/GAMES/MBLOCKS - * |
HI-PONG -012-/SYS/GAMES/PONG3 - * |
GI-15 -000-/SYS/GAMES/15 - * |
HH-LIFE2 -013-/SYS/DEMOS/LIFE2 - * |
JB-ANIMAGE -015-/SYS/MEDIA/ANIMAGE - * |
IA-BOARD -019-/SYS/DEVELOP/BOARD - * |
JC-DOCPACK -008-/SYS/DOCPAK - * |
HA-MTDBG -025-/SYS/DEVELOP/MTDBG - * |
AH-PIPES -026-/SYS/GAMES/PIPES - * |
AI-SUDOKU -030-/SYS/GAMES/SUDOKU - * |
BI-ARC-II -012-/SYS/GAMES/ARCANII - * |
BH-XONIX -021-/SYS/GAMES/XONIX - * |
GH-CHECKERS-001-/SYS/GAMES/CHECKERS - * |
CI-KOSILKA -023-/SYS/GAMES/KOSILKA - * |
CH-GOMOKU -029-/SYS/GAMES/GOMOKU - * |
/data/eng/iconstrp.gif |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/eng/index_htm |
---|
0,0 → 1,30 |
<?xml version="1.0" encoding="utf-8"?> |
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" |
"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd"> |
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" > |
<head> |
<title>KolibriOS web server - default message</title> |
</head> |
<body> |
<h1>Welcome to KolibriOS server</h1> |
<p> |
If you can read this with an external html-browser then Kolibri |
networking is correctly set up. |
<br /><br />This file: /rd/1/index.htm |
</p> |
<ul> |
<li><a href="/TinyStat">TinyStat</a></li> |
<li><a href="/TinyBoard">TinyBoard</a></li> |
</ul> |
</body> |
</html> |
/data/eng/kerpack |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/eng/keymap.key |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/eng/kpack |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/eng/kuzkina.mid |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/eng/lang.inc |
---|
0,0 → 1,0 |
lang fix en |
/data/eng/lang.ini |
---|
0,0 → 1,28 |
[start] |
startlng = 1 |
[comkey] |
ccomkey1 = 1 |
ccomkey2 = 4 |
ccomkey3 = 7 |
[altkey] |
altkey1 = 1 |
altkey2 = 4 |
altkey3 = 7 |
altkey4 = 3 |
altkey5 = 5 |
altkey6 = 6 |
altkey7 = 2 |
altkey8 = 0 |
altkey9 = 0 |
altkey0 = 0 |
[langs] |
1 = En |
2 = Fi |
3 = Ge |
4 = Ru |
5 = Fr |
6 = Et |
7 = Ua |
/data/eng/lib/cnv_png.obj |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/eng/lib/msgbox.obj |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/eng/lib/pixlib.obj |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/eng/lib/sort.obj |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/eng/media/ac97snd |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/eng/media/kiv.ini |
---|
0,0 → 1,3 |
[Shortcuts] |
Next=PgDn |
Prev=PgUp |
/data/eng/media/listplay |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/eng/media/startmus |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/eng/menu.dat |
---|
0,0 → 1,177 |
#0 **** MAIN **** |
Games > /@1 |
Demos > /@4 |
Graphics > /@6 |
Sound and music > /@7 |
Development > /@8 |
System > /@10 |
Data processing > /@14 |
Network > /@15 |
Other > /@18 |
Help /rd/1/docpak |
Run application /rd/1/run |
Shutdown /rd/1/end |
#1 **** GAMES **** |
Logical games > /@2 |
Arcades > /@3 |
Spectrum emulator /rd/1/e80 |
Memory Blocks /rd/1/games/mblocks |
FreeCell /rd/1/games/freecell |
Pipes /rd/1/games/pipes |
Kosilka /rd/1/games/kosilka |
RockeT ForceS /rd/1/games/rforces |
Find Numbers /rd/1/games/FindNumbers |
#2 **** LOGICAL GAMES **** |
C4 /rd/1/games/c4 |
15 /rd/1/games/15 |
Mine /rd/1/games/mine |
Just Clicks /rd/1/games/clicks |
Checkers /rd/1/games/checkers |
SQ_GAME /rd/1/games/sq_game |
Color Lines /rd/1/games/lines |
Lights /rd/1/games/lights |
Criss-Cross /rd/1/games/kox |
Bulls and cows /rd/1/games/bnc |
MegaMaze /rd/1/games/megamaze |
Sea Fight /rd/1/games/sw |
Sudoku /rd/1/games/sudoku |
Go-moku /rd/1/games/gomoku |
Reversi /rd/1/games/reversi |
#3 **** ARCADES **** |
Tetris /rd/1/games/tetris |
Pong /rd/1/games/pong |
New Pong /rd/1/games/pong3 |
Red Square /rd/1/games/rsquare |
XONIX /rd/1/games/xonix |
ArcanII /rd/1/games/arcanii |
Phenix /rd/1/games/phenix |
Snake /rd/1/games/snake |
#4 **** DEMOS **** |
3D > /@5 |
Fire /rd/1/demos/fire |
Circle /rd/1/demos/circle |
Fractal /rd/1/demos/tinyfrac |
Color demo /rd/1/demos/colorref |
Eyes /rd/1/demos/eyes |
Tube /rd/1/demos/tube |
Plasma /rd/1/demos/plasma |
Moveback /rd/1/demos/movback |
Life /rd/1/demos/life2 |
TranTest /rd/1/demos/trantest |
WEB /rd/1/demos/web |
FireWork /rd/1/demos/firework |
UnvWater /rd/1/demos/unvwater |
#5 **** 3D demos **** |
ScreenSaver /rd/1/3d/crownscr |
3D-cube /rd/1/3d/3dcube2 |
3D-labyrinth /rd/1/3d/free3d04 |
3D-textured cube /rd/1/3d/3dtcub10 |
3DSHeart /rd/1/3d/3dsheart |
View3DS /rd/1/3d/view3ds |
CubeLine /rd/1/3d/cubeline |
3D-textured cube 2 /rd/1/3d/cubetext |
Gears /rd/1/3d/gears |
FlatWave /rd/1/3d/flatwav |
3D-spiral /rd/1/3d/3dspiral |
#6 **** GRAPHICS **** |
Image viewer /rd/1/media/kiv |
Animage /rd/1/media/animage |
#7 **** AUDIO **** |
MidAMP /rd/1/media/midamp |
CD player /rd/1/media/cdp |
#8 **** PROGRAMMING **** |
Examples > /@9 |
Tools > /@20 |
#9 **** EXAMPLES **** |
Threads /rd/1/develop/thread |
IPC /rd/1/develop/ipc |
Color slider /rd/1/demos/cslide |
Console example 1 /rd/1/develop/testcon2 |
Console example 2 /rd/1/develop/test_gets |
Message Boxes example /rd/1/demos/use_mb |
#10 **** SYSTEM **** |
Settings > /@11 |
System sensors > /@12 |
Work with files > /@13 |
Testing > /@19 |
Accessibility opt. > /@21 |
Debug board /rd/1/develop/board |
#11 **** SETTINGS **** |
Devices /rd/1/setup |
Background generator /rd/1/pic4 |
Colors & Skin /rd/1/desktop |
Panel /rd/1/spanel |
Icons manager /rd/1/icon |
VRR /rd/1/vrr |
MyKey /rd/1/mykey |
Video mode for ATI /rd/1/vmode |
#12 **** SYSTEM SENSORS **** |
Process manager /rd/1/cpu |
PCI devices /rd/1/pcidev |
Test graphics speed /rd/1/mgb |
CPUID /rd/1/cpuid |
Ghost Monitor /rd/1/gmon |
K. Bus disconnected /rd/1/kbd |
HDD informer /rd/1/hdd_info |
Read HDD /rd/1/hdread |
#13 **** WORK WITH FILES **** |
KFAR /rd/1/File Managers/kfar |
KFM /rd/1/File Managers/kfm |
Eolite /rd/1/File Managers/Eolite |
SHELL console /rd/1/shell |
SysXTree /rd/1/sysxtree |
Save RD image /rd/1/rdsave |
#14 **** DATA PROCESSING **** |
Calculator /rd/1/calc |
TinyPad /rd/1/tinypad |
Table Processor /rd/1/table |
Graph builder /rd/1/graph |
Hex-Editor /rd/1/demos/heed |
#15 **** NET **** |
Servers > /@16 |
Clients > /@17 |
Configuration /rd/1/network/stackcfg |
Zero-Config /rd/1/network/zeroconf |
Network status /rd/1/network/ethstat |
ARP status /rd/1/network/arpstat |
#16 **** SERVERS **** |
SMTPS /rd/1/network/smtps |
HTTPS /rd/1/network/https |
FTPS /rd/1/network/ftps |
#17 **** CLIENTS **** |
TFTP client /rd/1/network/tftpc |
Internet-chess /rd/1/network/chess |
Simple HTTP client /rd/1/network/httpc |
HTML+HTTP viewer /rd/1/htmlv |
NNTP-NewsGroups /rd/1/network/nntpc |
TELNET /rd/1/network/telnet |
POP - MAIL /rd/1/network/popc |
IRC client /rd/1/network/airc |
YAHOO messenger (demo) /rd/1/network/ym |
JMail /rd/1/network/jmail |
VNC client /rd/1/network/vncclient |
DNS resolver /rd/1/network/nslookup |
#18 **** OTHER **** |
Analogue clock /rd/1/demos/aclock |
Binary clock /rd/1/demos/bcdclk |
Timer /rd/1/demos/timer |
ScrShoot /rd/1/scrshoot |
Calendar /rd/1/calendar |
BGI Font demo /rd/1/fonts/bgitest |
RTF reader /rd/1/rtfread |
#19 **** SYSTEM TESTS **** |
Protection test /rd/1/test |
Monitor test /rd/1/disptest |
#20 **** PROGRAMMING TOOLS **** |
Archiver KPack /rd/1/kpack |
Flat Assembler /rd/1/develop/fasm |
ASCII-codes /rd/1/develop/keyascii |
SCAN-codes /rd/1/develop/scancode |
Hex2Dec2Bin /rd/1/develop/h2d2b |
Debug Board /rd/1/develop/board |
Debugger /rd/1/develop/mtdbg |
#21 **** SYSTEM SPECIAL **** |
Screen magnifier /rd/1/magnify |
Screen keyboard /rd/1/zkey |
Character table /rd/1/ASCIIVju |
## |
/data/eng/mykey |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/eng/network/jmail |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/eng/network/zeroconf.ini |
---|
0,0 → 1,19 |
[ipconfig] |
; type should be static or zeroconf |
; zeroconf means the service first tries to contact a DHCP server |
; If dhcp is not available, it switches to link-local |
type = zeroconf |
ip = 10.0.2.15 |
gateway = 10.0.2.2 |
dns = 10.0.2.2 |
subnet = 255.255.255.0 |
[proxy] |
; If Internet connection requires HTTP proxy, set it here |
; and uncomment following lines: |
;proxy = <set your proxy IP-addr or domain name here> |
;port = <set your proxy port here> |
; If proxy requires authentification, uncomment following lines too |
; (otherwise, leave them commented): |
;user = <set username here> |
;password= <set password here> |
/data/eng/panel.dat |
---|
0,0 → 1,0 |
0000;0000;0001;0001;0001;0001;0100;0001;0001;0001;0001;0001;x |
/data/eng/setup.dat |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/eng/shell |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/eng/spanel |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/eng/table |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/eng/test |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/eng/vmode |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/rus/3d/3dsheart |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/rus/3d/3dspiral |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/rus/3d/cubeline |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/rus/3d/cubetext |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/rus/3d/flatwav |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/rus/3d/gears |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/rus/3d/house.3ds |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/rus/3d/logio.bmp |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/rus/@notify |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/rus/File Managers/buttons.bmp |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/rus/File Managers/eolite |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/rus/File Managers/eolite.ini |
---|
0,0 → 1,42 |
[Associations] |
rtf=/sys/htmlv |
asm=TinyPad |
inc=TinyPad |
ini=TinyPad |
txt=TinyPad |
gif=/sys/media/kiv |
bmp=/sys/media/kiv |
png=/sys/media/kiv |
tga=/sys/media/kiv |
jpg=/sys/media/kiv |
jpeg=/sys/media/kiv |
ico=/sys/media/kiv |
cur=/sys/media/kiv |
pcx=/sys/media/kiv |
3ds=/sys/3d/view3ds |
lif=/sys/demos/life2 |
skn=/sys/desktop |
htm=/sys/HTMLv |
html=/sys/HTMLv |
rtf=/sys/RtfRead |
obj=/sys/develop/cObj |
sna=/sys/e80 |
nes=/sys/games/fceu |
xm=/sys/media/AC97SND |
wav=/sys/media/AC97SND |
mp3=/sys/media/AC97SND |
mid=/sys/media/MIDAMP |
m3u=/sys/media/listplay |
lap=/sys/media/listplay |
asf=/sys/media/listplay |
mht=/sys/htmlv |
kla=/sys/games/klavisha |
[Config] |
;åñëè ïîñòàâèòü 1 âìåñòî êíîïîê áóäåò ñòðîêà àäðåñà |
ShowEditBoxPath=0 |
;öâåò âûäåëåíîãî ýëåìåíòà è âûäåëåíèå åäèòáîêñà |
;ïî-óìîë÷àíèþ 94AECE, äëÿ òåñòà FEA4B7,8BCDFF,B8C9B8 |
BorderColor=94AECE |
/data/rus/File Managers/icons.bmp |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/rus/File Managers/icons.ini |
---|
0,0 → 1,141 |
asm=4 |
inc=4 |
txt=3 |
rtf=3 |
ini=3 |
log=3 |
dic=3 |
doc=3 |
exc=3 |
wtx=3 |
inf=3 |
xml=3 |
odt=3 |
jpg=6 |
jpe=6 |
jpeg=6 |
jif=6 |
jfif=6 |
jp2=6 |
jpx=6 |
jpk=6 |
j2k=6 |
jpc=6 |
j2c=6 |
bmp=6 |
dib=6 |
rle=6 |
pbm=6 |
wbm=6 |
wbmp=6 |
xbm=6 |
xpm=6 |
gif=6 |
png=6 |
ico=6 |
cur=6 |
ani=6 |
tif=6 |
tiff=6 |
xif=6 |
tga=6 |
pcx=6 |
dcx=6 |
ppm=6 |
psd=6 |
psp=6 |
raw=6 |
raf=6 |
x3f=6 |
orf=6 |
nef=6 |
mrw=6 |
dcr=6 |
crw=6 |
cr2=6 |
ras=6 |
pix=6 |
pict=6 |
pct=6 |
pic=6 |
pgm=6 |
pef=6 |
pcd=6 |
iff=6 |
lbm=6 |
ilbm=6 |
fpx=6 |
djv=6 |
djvu=6 |
iw4=6 |
wav=7 |
mp3=7 |
xm=7 |
mid=7 |
midi=7 |
aif=7 |
aifc=7 |
aiff=7 |
au=7 |
snd=7 |
wma=7 |
wm=7 |
avi=11 |
mpg=11 |
mpe=11 |
mpeg=11 |
flv=11 |
3gp=11 |
mkv=11 |
wmv=11 |
mov=11 |
mp4=11 |
img=5 |
ima=5 |
imz=5 |
bwz=5 |
dsk=5 |
vfd=5 |
wil=5 |
wlz=5 |
exe=8 |
com=8 |
bat=8 |
7z=9 |
rar=9 |
zip=9 |
cab=9 |
arj=9 |
lha=9 |
lzh=9 |
tar=9 |
taz=9 |
tbz=9 |
tbz2=9 |
bz=9 |
bz2=9 |
ice=9 |
gz=9 |
tgz=9 |
uue=9 |
uu=9 |
xxe=9 |
z=9 |
dat=10 |
ttf=12 |
ttc=12 |
chr=12 |
mt=12 |
htm=13 |
html=13 |
mht=13 |
eml=13 |
lif=14 |
3ds=15 |
kex=16 |
skn=17 |
obj=18 |
dll=18 |
ocx=18 |
so=18 |
drv=18 |
/data/rus/File Managers/kfar.ini |
---|
0,0 → 1,71 |
[Associations] |
asm=/sys/TinyPad; AsmMenu1,AsmMenu2 |
inc=/sys/TinyPad |
ini=/sys/TinyPad |
txt=/sys/TinyPad |
jpg=/sys/media/kiv |
jpeg=/sys/media/kiv |
gif=/sys/media/kiv; ViewGraph,MenuAnimage |
wav=/sys/media/AC97SND |
mp3=/sys/media/AC97SND |
xm=/sys/media/AC97SND |
mid=/sys/media/MIDAMP |
bmp=/sys/media/kiv; ViewGraph,MenuAnimage |
png=/sys/media/kiv |
ico=/sys/media/kiv |
cur=/sys/media/kiv |
pcx=/sys/media/kiv |
rtf=/sys/RtfRead |
3ds=/sys/3d/view3ds |
lif=/sys/demos/life2 |
skn=/sys/desktop |
m3u=/sys/media/listplay |
lap=/sys/media/listplay |
asf=/sys/media/listplay |
cvs=/sys/graph |
obj=/sys/develop/cObj |
nes=/sys/fceu |
sna=/sys/e80 |
htm=/sys/HTMLv |
html=/sys/HTMLv |
kla=/sys/games/klavisha |
[Menu] |
AsmMenu1=&¥è¨© । ªâ®à,/sys/TinyPad |
AsmMenu2=&®¬¯¨«¨à®¢ âì,/sys/develop/fasm |
ViewGraph=&à®á¬®âà,/sys/media/kiv |
MenuAnimage=&¥¤ ªâ®à,/sys/media/animage |
[Panels] |
; ¥¦¨¬ë ®â®¡à ¦¥¨ï ä ©«®¢ ¯ ¥«ïå |
; § 票ï ᮮ⢥âáâ¢ãîâ æ¨äà ¬ ¤«ï LCtrl+<1-4> |
LeftViewMode=2 |
RightViewMode=2 |
; ¥¦¨¬ë á®àâ¨à®¢ª¨ ä ©«®¢ ¯ ¥«ïå |
; § ç¥¨ï ¨¬¥îâ ¢¨¤ 2 * N + M, £¤¥ |
; M = 0 - ¯àï¬ ï á®àâ¨à®¢ª , M = 1 - ®¡à â ï |
; N = 0-6 ᮮ⢥âáâ¢ã¥â ०¨¬ã á®àâ¨à®¢ª¨ ¤«ï Ctrl+F<3-9> |
LeftSortMode=0 |
RightSortMode=0 |
[Editor] |
; ¨¬¢®«ë ª®æ áâப¨, ª®â®àë¥ ¡ã¤¥â ¢áâ ¢«ïâì |
; । ªâ®à kfar ¯à¨ ¤®¡ ¢«¥¨¨ ®¢®© áâப¨: |
; DOS - ¯®¤®¡¨¥ DOS/Win (0D 0A), Unix - ¯®¤®¡¨¥ Unix (0A), |
; Mac - ¯®¤®¡¨¥ Mac (0D) |
EOLStyle=Unix |
[FolderShortcuts] |
; ®¦® ®¯à¥¤¥«¨âì ¤® ¤¥áï⨠ááë«®ª ¯ ¯ª¨ Shortcut0...Shortcut9, |
; â ª¨¥ ¯ ¯ª¨ ¬®¦® ᤥ« âì ¡ëáâàë© ¯¥à¥å®¤ ¯® RCtrl+<æ¨äà > |
Shortcut0=/rd/1 |
[Confirmations] |
Delete=1 |
DeleteIncomplete=0 |
[Plugins] |
; «¥¢ ®â § ª à ¢¥á⢠¬®¦® áâ ¢¨âì «î¡®¥ ®á¬ëá«¥®¥ ¨«¨ ¡¥áá¬ëá«¥®¥ |
; ¨¬ï; á¯à ¢ - ¯ãâì ª ¯« £¨ã. |
; ᫨ ¯ãâì ¥ ¡á®«îâ¥, â® ® ®âáç¨âë¢ ¥âáï ®â ¯ ¯ª¨ á ¡¨ ਪ®¬ kfar. |
ArchiveReader=/sys/lib/archiver.obj |
/data/rus/File Managers/kfm |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/rus/File Managers/kfm.ini |
---|
0,0 → 1,172 |
start |
<>icons_associations |
asm 0004 |
inc 0004 |
txt 0003 |
rtf 0003 |
ini 0003 |
log 0003 |
dic 0003 |
doc 0003 |
exc 0003 |
wtx 0003 |
inf 0003 |
jpg 0006 |
jpe 0006 |
jpeg 0006 |
jif 0006 |
jfif 0006 |
jp2 0006 |
jpx 0006 |
jpk 0006 |
j2k 0006 |
jpc 0006 |
j2c 0006 |
bmp 0006 |
dib 0006 |
rle 0006 |
pbm 0006 |
wbm 0006 |
wbmp 0006 |
xbm 0006 |
xpm 0006 |
gif 0006 |
png 0006 |
ico 0006 |
cur 0006 |
ani 0006 |
tif 0006 |
tiff 0006 |
xif 0006 |
tga 0006 |
pcx 0006 |
dcx 0006 |
ppm 0006 |
psd 0006 |
psp 0006 |
raw 0006 |
raf 0006 |
x3f 0006 |
orf 0006 |
nef 0006 |
mrw 0006 |
dcr 0006 |
crw 0006 |
cr2 0006 |
ras 0006 |
pix 0006 |
pict 0006 |
pct 0006 |
pic 0006 |
pgm 0006 |
pef 0006 |
pcd 0006 |
iff 0006 |
lbm 0006 |
ilbm 0006 |
fpx 0006 |
djv 0006 |
djvu 0006 |
iw4 0006 |
wav 0007 |
mp3 0007 |
xm 0007 |
mid 0007 |
midi 0007 |
aif 0007 |
aifc 0007 |
aiff 0007 |
au 0007 |
snd 0007 |
wma 0007 |
wm 0007 |
avi 0011 |
mpg 0011 |
img 0005 |
ima 0005 |
imz 0005 |
bwz 0005 |
dsk 0005 |
vfd 0005 |
wil 0005 |
wlz 0005 |
exe 0008 |
com 0008 |
bat 0008 |
7z 0009 |
rar 0009 |
zip 0009 |
cab 0009 |
arj 0009 |
lha 0009 |
lzh 0009 |
tar 0009 |
taz 0009 |
tbz 0009 |
tbz2 0009 |
bz 0009 |
bz2 0009 |
ice 0009 |
gz 0009 |
tgz 0009 |
uue 0009 |
uu 0009 |
xxe 0009 |
z 0009 |
dat 0010 |
ttf 0012 |
ttc 0012 |
chr 0012 |
mt 0012 |
htm 0013 |
html 0013 |
lif 0014 |
3ds 0015 |
kex 0016 |
skn 0017 |
<>end |
<>files_associations |
asm /sys/tinypad |
inc /sys/tinypad |
txt /sys/tinypad |
ini /sys/tinypad |
log /sys/tinypad |
dat /sys/tinypad |
inf /sys/tinypad |
bat /sys/tinypad |
jpg /sys/media/kiv |
jpeg /sys/media/kiv |
jpe /sys/media/kiv |
gif /sys/media/kiv |
wav /sys/media/ac97snd |
mp3 /sys/media/ac97snd |
xm /sys/media/ac97snd |
mid /sys/media/midamp |
bmp /sys/media/kiv |
png /sys/media/kiv |
ico /sys/media/kiv |
cur /sys/media/kiv |
pcx /sys/media/kiv |
rtf /sys/rtfread |
3ds /sys/3d/view3ds |
lif /sys/demos/life2 |
skn /sys/desktop |
avi /sys/kvid.kex |
m3u /sys/media/listplay |
lap /sys/media/listplay |
asf /sys/media/listplay |
cvs /sys/graph |
obj /sys/develop/cObj |
nes /sys/fceu |
sna /sys/e80 |
htm /sys/HTMLv |
html /sys/HTMLv |
kla /sys/games/klavisha |
<>end |
<>files_association1 |
bmp /sys/media/animage |
<>end |
end |
/data/rus/File Managers/kfm_keys.txt |
---|
0,0 → 1,46 |
¯à ¢«ïî騥 á®ç¥â ¨ï ª« ¢¨è ¢ KFM - Kolibri File Manager v0.47. |
¯ ¥«ïå: |
1) ¥à¥¬¥é¥¨¥ ªãàá®à ¯® ªâ¨¢®© ¯ ¥«¨: |
) áâ५ª¨ ¢¢¥àå ¨ ¢¨§ (¢ ⮬ ç¨á«¥ à ᯮ«®¦¥ë¥ ¢ ¤®¯®«¨â¥«ì®© ç á⨠ª« ¢¨ âãàë) - ¯¥à¥¬¥é¥¨¥ ªãàá®à ®¤ã ¯®§¨æ¨î ¢¢¥àå ¨«¨ ¢¨§. |
¡) PageUp - ¯®áâà ¨ç®¥ «¨áâ ¨¥ ¢¢¥àå. |
¢) PageDown - ¯®áâà ¨ç®¥ «¨áâ ¨¥ ¢¨§. |
£) Home - ¢ ç «® ª â «®£ á ä ©« ¬¨. |
¤) End - ¢ ª®¥æ ª â «®£ á ä ©« ¬¨. |
2) Tab - ¨§¬¥¥¨¥ ªâ¨¢®© ¯ ¥«¨. |
3) Enter - ¤¥©á⢨ï á ä ©«®¬ ¯®§¨æ¨¨ ª®â®à®£® 室¨âáï ªãàá®à ¢ë¤¥«¥¨ï: |
) ¢å®¤ ¢ ¯ ¯ªã. |
¡) § ¯ã᪠¯à®£à ¬¬ë. |
¢) ®âªàëâì ä ©« ¢ ¯à®¯¨á ®¬ ¯à¨«®¦¥¨¨, ᮣ« ᮠᮤ¥à¦ ¨î ä ©« kfm.ini, à §¤¥« "<>files associations". |
4) Alt+F1 - ¢ë§®¢ ¬¥î ¢ë¡®à ¤¨áª , ®â®¡à ¦ ¥¬®£® «¥¢®© ¯ ¥«¨. |
5) Alt+F2 - ¢ë§®¢ ¬¥î ¢ë¡®à ¤¨áª , ®â®¡à ¦ ¥¬®£® ¯à ¢®© ¯ ¥«¨. |
6) á®àâ¨à®¢ª ä ©«®¢ ¢ ªâ¨¢®© ¯ ¥«¨: |
) Ctrl+F3 - á®àâ¨à®¢ª ¯® ¨¬¥ ¬. |
¡) Ctrl+F4 - á®àâ¨à®¢ª ¯® à áè¨à¥¨ï¬. |
¢) Ctrl+F5 - á®àâ¨à®¢ª ¯® à §¬¥àã. |
£) Ctrl+F6 - á®àâ¨à®¢ª ¯® ¤ ⥠¬®¤¨ä¨ª 樨. |
7) Ctrl+R - ¯®¢â®à ï § £à㧪 ᮤ¥à¦¨¬®£® ¤¨à¥ªâ®à¨¨ ¢ ªâ¨¢®© ¯ ¥«¨. |
8) Delete ¨ F8 - 㤠«¥¨¥ ä ©« ª®â®à®¬ 室¨âáï ªãàá®à. |
9) Insert - ¢ë¤¥«¥¨¥ ªà áë¬ æ¢¥â®¬ ä ©« ª®â®à®¬ 室¨âáï ªãàá®à ¨ ¯¥à¥¬¥é¥¨¥ ªãàá®à 1 ¯®§¨æ¨î ¢¨§. |
10) F4 - ®âªàëâì ä ©« ¤«ï । ªâ¨à®¢ ¨ï ¢ ¯à®¯¨á ®¬ ¯à¨«®¦¥¨¨, ᮣ« ᮠᮤ¥à¦ ¨î ä ©« kfm.ini, à §¤¥« "<>files association1". |
11) F7 - ᮧ¤ ¨¥ ¤¨à¥ªâ®à¨¨ ¢ ªâ¨¢®© ¯ ¥«¨. |
12) F5 - ª®¯¨à®¢ ¨¥ ä ©« ¨§ ªâ¨¢®© ¯ ¥«¨ ¢ ¯à®â¨¢®¯®«®¦ãî. |
13) F6 - ¯¥à¥¬¥é¥¨¥ ä ©« ¨§ ªâ¨¢®© ¯ ¥«¨ ¢ ¯à®â¨¢®¯®«®¦ãî. |
14) Ctrl+A ¨ Ctrl+(NumPad(+) Up) - ¢ë¤¥«¥¨¥ ¢á¥å ä ©«®¢ ¨ ¤¨à¥ªâ®à¨© ¢ ªâ¨¢®© ¯ ¥«¨, § ¨áª«î票¥¬ ¤¨à¥ªâ®à¨¨ '..' |
15) Ctrl+(NumPad(-) Up) - áïâì ¢ë¤¥«¥¨¥ ¢á¥å ä ©«®¢ ¨ ¤¨à¥ªâ®à¨© ¢ ªâ¨¢®© ¯ ¥«¨, § ¨áª«î票¥¬ ¤¨à¥ªâ®à¨¨ '..' |
16) Ctrl+(NumPad(*) Up) - ¨¢¥àâ¨à®¢ âì ¢ë¤¥«¥¨¥ ¢á¥å ä ©«®¢ ¨ ¤¨à¥ªâ®à¨© ¢ ªâ¨¢®© ¯ ¥«¨, § ¨áª«î票¥¬ ¤¨à¥ªâ®à¨¨ '..' |
17) F12 - § ¢¥à襨¥ à ¡®âë ¯à®£à ¬¬ë. |
18) F1 - á¯à ¢ª , £®àï稥 ª®¬¡¨ 樨 ª« ¢¨è. ॡã¥âáï «¨ç¨¥ ä ©« kfm_keys.txt ¢ ¤¨à¥ªâ®à¨¨ £¤¥ à ᯮ«®¦¥® ¯à¨«®¦¥¨¥. |
19) âªàëâì ä ©« ¢ áâ®à®¥¬ ¯à¨«®¦¥¨¨ á ¯ à ¬¥â஬: |
) Shift + W - ãáâ ®¢¨âì ä®®¢ë© à¨á㮪 à ¡®ç¥£® á⮫ , ०¨¬ ®âà¨á®¢ª¨ § ¬®áâ¨âì. |
¡) Ctrl + W - ãáâ ®¢¨âì ä®®¢ë© à¨á㮪 à ¡®ç¥£® á⮫ , ०¨¬ ®âà¨á®¢ª¨ à áâïãâì. |
20) Alt+Enter - ¯®«ã票¥ ¤«ï ä ©«®¢ ¨ ¤¨à¥ªâ®à¨©: à ᯮ«®¦¥¨ï, §¢ ¨ï, à §¬¥à , ª®«¨ç¥áâ¢ ä ©«®¢ ¨ ¤¨à¥ªâ®à¨© |
(¢ ⮬ ç¨á«¥ ¨ ¤«ï á«ãç ï ¢ë¤¥«¥¨ï ®â¤¥«ìëå ä ©«®¢ ¨ ¤¨à¥ªâ®à¨©). |
¬¥î ¢ë¡®à ¤¨áª : |
1) áâ५ª¨ ¢¢¥àå ¨ ¢¨§ (¢ ⮬ ç¨á«¥ à ᯮ«®¦¥ë¥ ¢ ¤®¯®«¨â¥«ì®© ç á⨠ª« ¢¨ âãàë) - ¯¥à¥¬¥é¥¨¥ ªãàá®à ®¤ã ¯®§¨æ¨î ¢¢¥àå ¨«¨ ¢¨§. |
2) Enter - ¢ë¡®à ¤¨áª ¯®§¨æ¨¨ ª®â®à®£® 室¨âáï ªãàá®à ¢ë¤¥«¥¨ï. |
3) Home ¨ PageUp - ªãàá®à ¢ ç «® ᯨ᪠|
4) End ¨ PageDown - ªãàá®à ¢ ª®¥æ ᯨ᪠. |
5) Insert - § £à㧨âì «®â®ª ¢ë¡à ®£® ATAPI ¯à¨¢®¤ . |
6) Delete - ¢ë£à㧨âì «®â®ª ¢ë¡à ®£® ATAPI ¯à¨¢®¤ . |
/data/rus/Makefile |
---|
0,0 → 1,368 |
# General rule for naming: variables with CAPITALIZED names hold settings, |
# you can - and are expected - to modify it; variables with lowercase names |
# are intermediate variables and macroses not to be modified unless you |
# know what you're doing. |
# Define directories for destination, source repository, sources of kernel, sources of programs. |
BUILD_DIR:=build |
REPOSITORY:=../localcopy |
KERNEL:=$(REPOSITORY)/kernel/trunk |
PROGS:=$(REPOSITORY)/programs |
# Docpak requires some documents; we place them |
# into 'docs' subdir and communicate with FASM |
# through environment var DOCDIR. |
DOCDIR:=docs/ |
export DOCDIR |
# Because most programs are written in FASM and have |
# the common structure of one main .asm file possibly including |
# several .inc files, we handle this case separately. |
# Namely, we organize one big list of such programs |
# (FASM_PROGRAMS, see below) containing name of local binary file, |
# name of file inside kolibri.img and name of the source file. |
# This list is maintained by hand, and the rest is done with some macroses... |
# well, slightly complicated macroses - however, you do not need to |
# understand them in order to maintain the list. |
# To add a FASM program with one .asm file, just |
# add the corresponding item to the list and enjoy |
# the power of GNU make. |
# The list of all FASM programs with one main FASM file. |
# Every item consists of three parts, separated by ':'. |
# First part is the real name of binary file in $(BUILD_DIR) |
# as it should be produced by make. |
# Second part is the name of a file inside kolibri.img, |
# usually uppercased version of first part - to save space |
# for FAT filesystem. |
# Third part is the name of the source file. |
# Spaces separate items, so spaces in names should be |
# represented as '|'. |
FASM_PROGRAMS:=\ |
@clip:@CLIP:$(PROGS)/system/clip/trunk/@clip.ASM \ |
@menu:@MENU:$(PROGS)/system/menu/trunk/menu.asm \ |
@panel:@PANEL:$(PROGS)/system/panel/trunk/@PANEL.ASM \ |
@rb:@RB:$(PROGS)/system/rb/trunk/@RB.ASM \ |
@ss:@SS:$(PROGS)/system/ss/trunk/@SS.ASM \ |
calc:CALC:$(PROGS)/other/calc/trunk/calc.asm \ |
calendar:CALENDAR:$(PROGS)/system/calendar/trunk/calendar.asm \ |
commouse:COMMOUSE:$(PROGS)/system/commouse/trunk/commouse.asm \ |
copyr:COPYR:$(PROGS)/fs/copyr/trunk/copyr.asm \ |
cpu:CPU:$(PROGS)/system/cpu/trunk/cpu.asm \ |
cpuid:CPUID:$(PROGS)/system/cpuid/trunk/CPUID.ASM \ |
desktop:DESKTOP:$(PROGS)/system/desktop/trunk/desktop.asm \ |
disptest:DISPTEST:$(PROGS)/system/disptest/trunk/disptest.ASM \ |
docpak:DOCPAK:$(PROGS)/system/docpack/trunk/docpack.asm \ |
downloader:downloader:$(PROGS)/network/downloader/trunk/downloader.asm \ |
end:END:$(PROGS)/system/end/trunk/end.asm \ |
gmon:GMON:$(PROGS)/system/gmon/gmon.asm \ |
hdd_info:HDD_INFO:$(PROGS)/system/hdd_info/trunk/hdd_info.asm \ |
icon:ICON:$(PROGS)/system/icon/trunk/icon.asm \ |
kbd:KBD:$(PROGS)/system/kbd/trunk/kbd.ASM \ |
launcher:LAUNCHER:$(PROGS)/system/launcher/trunk/launcher.asm \ |
magnify:MAGNIFY:$(PROGS)/demos/magnify/trunk/magnify.asm \ |
mgb:MGB:$(PROGS)/system/mgb/trunk/mgb.asm \ |
mousemul:MOUSEMUL:$(PROGS)/system/mousemul/trunk/mousemul.asm \ |
pcidev:PCIDEV:$(PROGS)/system/pcidev/trunk/PCIDEV.ASM \ |
period:PERIOD:$(PROGS)/other/period/trunk/period.asm \ |
pic4:PIC4:$(PROGS)/media/pic4/trunk/pic4.asm \ |
rdsave:RDSAVE:$(PROGS)/system/rdsave/trunk/rdsave.asm \ |
rtfread:RTFREAD:$(PROGS)/other/rtfread/trunk/rtfread.asm \ |
run:RUN:$(PROGS)/system/run/trunk/run.asm \ |
scrshoot:SCRSHOOT:$(PROGS)/media/scrshoot/scrshoot.asm \ |
setup:SETUP:$(PROGS)/system/setup/trunk/setup.asm \ |
tinypad:TINYPAD:$(PROGS)/develop/tinypad/trunk/tinypad.asm \ |
vrr:VRR:$(PROGS)/system/vrr/trunk/vrr.asm \ |
vrr_m:VRR_M:$(PROGS)/system/vrr_m/trunk/vrr_m.asm \ |
zkey:ZKEY:$(PROGS)/system/zkey/trunk/ZKEY.ASM \ |
3d/3dcube2:3D/3DCUBE2:$(PROGS)/demos/3dcube2/trunk/3DCUBE2.ASM \ |
3d/3dtcub10:3D/3DTCUB10:$(PROGS)/demos/3dtcub10/trunk/3DTCUB10.ASM \ |
3d/crownscr:3D/CROWNSCR:$(PROGS)/demos/crownscr/trunk/crownscr.asm \ |
3d/free3d04:3D/FREE3D04:$(PROGS)/demos/free3d04/trunk/free3d04.asm \ |
3d/view3ds:3D/VIEW3DS:$(PROGS)/demos/3DS/VIEW3DS.ASM \ |
demos/bcdclk:DEMOS/BCDCLK:$(PROGS)/demos/bcdclk/bcdclk/bcdclk.asm \ |
demos/circle:DEMOS/CIRCLE:$(PROGS)/develop/examples/circle/trunk/circle.asm \ |
demos/colorref:DEMOS/COLORREF:$(PROGS)/demos/colorref/trunk/colorref.asm \ |
demos/cslide:DEMOS/CSLIDE:$(PROGS)/demos/cslide/trunk/cslide.asm \ |
demos/eyes:DEMOS/EYES:$(PROGS)/demos/eyes/trunk/eyes.asm \ |
demos/fire:DEMOS/FIRE:$(PROGS)/demos/fire/trunk/fire.asm \ |
demos/firework:DEMOS/FIREWORK:$(PROGS)/demos/firework/trunk/firework.asm \ |
demos/movback:DEMOS/MOVBACK:$(PROGS)/demos/movback/trunk/movback.asm \ |
demos/plasma:DEMOS/PLASMA:$(PROGS)/demos/plasma/trunk/plasma.asm \ |
demos/timer:DEMOS/TIMER:$(PROGS)/demos/timer/trunk/timer.asm \ |
demos/tinyfrac:DEMOS/TINYFRAC:$(PROGS)/demos/tinyfrac/trunk/tinyfrac.asm \ |
demos/trantest:DEMOS/TRANTEST:$(PROGS)/demos/trantest/trunk/trantest.asm \ |
demos/tube:DEMOS/TUBE:$(PROGS)/demos/tube/trunk/tube.asm \ |
demos/unvwater:DEMOS/UNVWATER:$(PROGS)/demos/unvwater/trunk/unvwater.asm \ |
develop/board:DEVELOP/BOARD:$(PROGS)/system/board/trunk/board.asm \ |
develop/cObj:DEVELOP/cObj:$(PROGS)/develop/cObj/trunk/cObj.asm \ |
develop/fasm:DEVELOP/FASM:$(PROGS)/develop/fasm/trunk/fasm.asm \ |
develop/h2d2b:DEVELOP/H2D2B:$(PROGS)/develop/h2d2b/trunk/h2d2b.asm \ |
develop/heed:DEVELOP/HEED:$(PROGS)/develop/heed/trunk/heed.asm \ |
develop/ipc:DEVELOP/IPC:$(PROGS)/network/ipc/trunk/ipc.asm \ |
develop/keyascii:DEVELOP/KEYASCII:$(PROGS)/develop/keyascii/trunk/keyascii.asm \ |
develop/mtdbg:DEVELOP/MTDBG:$(PROGS)/develop/mtdbg/mtdbg.asm \ |
develop/scancode:DEVELOP/SCANCODE:$(PROGS)/develop/scancode/trunk/scancode.asm \ |
develop/test_gets:DEVELOP/test_gets:$(PROGS)/develop/libraries/console/examples/test_gets.asm \ |
develop/testcon2:DEVELOP/TESTCON2:$(PROGS)/develop/libraries/console/examples/testcon2.asm \ |
develop/thread:DEVELOP/THREAD:$(PROGS)/develop/examples/thread/trunk/thread.asm \ |
drivers/atikms:DRIVERS/ATIKMS:$(REPOSITORY)/drivers/video/drm/radeon/atikms.asm \ |
drivers/com_mouse.obj:DRIVERS/COM_MOUSE.OBJ:$(KERNEL)/drivers/com_mouse.asm \ |
drivers/emu10k1x.obj:DRIVERS/EMU10K1X.OBJ:$(KERNEL)/drivers/emu10k1x.asm \ |
drivers/fm801.obj:DRIVERS/FM801.OBJ:$(KERNEL)/drivers/fm801.asm \ |
drivers/infinity.obj:DRIVERS/INFINITY.OBJ:$(KERNEL)/drivers/infinity.asm \ |
drivers/ps2mouse.obj:DRIVERS/PS2MOUSE.OBJ:$(REPOSITORY)/drivers/mouse/ps2mouse4d/trunk/ps2mouse.asm \ |
drivers/sb16.obj:DRIVERS/SB16.OBJ:$(KERNEL)/drivers/sb16/sb16.asm \ |
drivers/sound.obj:DRIVERS/SOUND.OBJ:$(KERNEL)/drivers/sound.asm \ |
drivers/vmode.mdr:DRIVERS/VMODE.MDR:$(KERNEL)/drivers/vmode.asm \ |
drivers/vt8235.obj:DRIVERS/VT8235.OBJ:$(KERNEL)/drivers/vt823x.asm \ |
File|Managers/kfar:File|Managers/KFAR:$(PROGS)/fs/kfar/trunk/kfar.asm \ |
File|Managers/OpenDial:File|Managers/OPENDIAL:$(PROGS)/develop/libraries/box_lib/asm/trunk/OpenDial.asm \ |
fonts/bgitest:FONTS/BGITEST:$(PROGS)/demos/bgitest/trunk/bgitest.asm \ |
games/15:GAMES/15:$(PROGS)/games/15/trunk/15.ASM \ |
games/arcanii:GAMES/ARCANII:$(PROGS)/games/arcanii/trunk/arcanii.asm \ |
games/freecell:GAMES/FREECELL:$(PROGS)/games/freecell/freecell.ASM \ |
games/invaders:GAMES/INVADERS:$(PROGS)/games/invaders/invaders.asm \ |
games/lines:GAMES/LINES:$(PROGS)/games/lines/lines.asm \ |
games/mblocks:GAMES/MBLOCKS:$(PROGS)/games/mblocks/trunk/mblocks.asm \ |
games/phenix:GAMES/PHENIX:$(PROGS)/games/phenix/trunk/phenix.asm \ |
games/pipes:GAMES/PIPES:$(PROGS)/games/pipes/pipes.asm \ |
games/pong:GAMES/PONG:$(PROGS)/games/pong/trunk/pong.asm \ |
games/pong3:GAMES/PONG3:$(PROGS)/games/pong3/trunk/pong3.asm \ |
games/rsquare:GAMES/RSQUARE:$(PROGS)/games/rsquare/trunk/rsquare.asm \ |
games/snake:GAMES/SNAKE:$(PROGS)/games/snake/trunk/snake.asm \ |
games/tetris:GAMES/TETRIS:$(PROGS)/games/tetris/trunk/tetris.asm \ |
lib/archiver.obj:LIB/ARCHIVER.OBJ:$(PROGS)/fs/kfar/trunk/kfar_arc/kfar_arc.asm \ |
lib/box_lib.obj:LIB/BOX_LIB.OBJ:$(PROGS)/develop/libraries/box_lib/trunk/box_lib.asm \ |
lib/console.obj:LIB/CONSOLE.OBJ:$(PROGS)/develop/libraries/console/console.asm \ |
lib/libgfx.obj:LIB/LIBGFX.OBJ:$(PROGS)/develop/libraries/libs-dev/libgfx/libgfx.asm \ |
lib/libimg.obj:LIB/LIBIMG.OBJ:$(PROGS)/develop/libraries/libs-dev/libimg/libimg.asm \ |
lib/libini.obj:LIB/LIBINI.OBJ:$(PROGS)/develop/libraries/libs-dev/libini/libini.asm \ |
lib/libio.obj:LIB/LIBIO.OBJ:$(PROGS)/develop/libraries/libs-dev/libio/libio.asm \ |
lib/network.obj:LIB/NETWORK.OBJ:$(PROGS)/develop/libraries/network/network.asm \ |
lib/proc_lib.obj:LIB/PROC_LIB.OBJ:$(PROGS)/develop/libraries/proc_lib/trunk/proc_lib.asm \ |
media/animage:MEDIA/ANIMAGE:$(PROGS)/media/animage/trunk/animage.asm \ |
media/cdp:MEDIA/CDP:$(PROGS)/media/cdp/trunk/cdp.asm \ |
media/kiv:MEDIA/KIV:$(PROGS)/media/kiv/trunk/kiv.asm \ |
media/midamp:MEDIA/MIDAMP:$(PROGS)/media/midamp/trunk/midamp.asm \ |
network/airc:NETWORK/AIRC:$(PROGS)/network/airc/trunk/airc.asm \ |
network/arpstat:NETWORK/ARPSTAT:$(PROGS)/network/arpstat/trunk/arpstat.asm \ |
network/chess:NETWORK/CHESS:$(PROGS)/network/chess/trunk/chess.asm \ |
network/ethstat:NETWORK/ETHSTAT:$(PROGS)/network/ethstat/trunk/ethstat.asm \ |
network/ftps:NETWORK/FTPS:$(PROGS)/network/ftps/trunk/FTPS.ASM \ |
network/httpc:NETWORK/HTTPC:$(PROGS)/network/httpc/trunk/httpc.asm \ |
network/https:NETWORK/HTTPS:$(PROGS)/network/https/trunk/https.asm \ |
network/nntpc:NETWORK/NNTPC:$(PROGS)/network/nntpc/trunk/nntpc.asm \ |
network/nslookup:NETWORK/NSLOOKUP:$(PROGS)/develop/libraries/network/examples/nslookup.asm \ |
network/popc:NETWORK/POPC:$(PROGS)/network/popc/trunk/popc.asm \ |
network/smtps:NETWORK/SMTPS:$(PROGS)/network/smtps/trunk/smtps.asm \ |
network/stackcfg:NETWORK/STACKCFG:$(PROGS)/network/stackcfg/trunk/stackcfg.asm \ |
network/telnet:NETWORK/TELNET:$(PROGS)/network/telnet/trunk/telnet.asm \ |
network/tftpc:NETWORK/TFTPC:$(PROGS)/network/tftpc/trunk/tftpc.asm \ |
network/VNCclient:NETWORK/VNCclient:$(PROGS)/network/VNCclient/VNCclient.asm \ |
network/ym:NETWORK/YM:$(PROGS)/network/ym/trunk/ym.asm \ |
network/zeroconf:NETWORK/ZEROCONF:$(PROGS)/network/zeroconf/trunk/zeroconf.asm \ |
# end of list |
# The list of files which should be copied from somewhere. |
# Format of an item is exactly the same as in the previous list. |
COPY_FILES:=\ |
macros.inc:MACROS.INC:$(PROGS)/macros.inc \ |
config.inc:CONFIG.INC:$(PROGS)/config.inc \ |
struct.inc:STRUCT.INC:$(PROGS)/struct.inc \ |
File|Managers/z_icons.png:File|Managers/Z_ICONS.PNG:$(PROGS)/develop/libraries/box_lib/asm/trunk/z_icons.png \ |
fonts/euro.chr:FONTS/EURO.CHR:$(PROGS)/demos/bgitest/trunk/FONTS/EURO.CHR \ |
fonts/goth.chr:FONTS/GOTH.CHR:$(PROGS)/demos/bgitest/trunk/FONTS/GOTH.CHR \ |
fonts/lcom.chr:FONTS/LCOM.CHR:$(PROGS)/demos/bgitest/trunk/FONTS/LCOM.CHR \ |
fonts/litt.chr:FONTS/LITT.CHR:$(PROGS)/demos/bgitest/trunk/FONTS/LITT.CHR \ |
fonts/sans.chr:FONTS/SANS.CHR:$(PROGS)/demos/bgitest/trunk/FONTS/SANS.CHR \ |
fonts/scri.chr:FONTS/SCRI.CHR:$(PROGS)/demos/bgitest/trunk/FONTS/SCRI.CHR \ |
fonts/simp.chr:FONTS/SIMP.CHR:$(PROGS)/demos/bgitest/trunk/FONTS/SIMP.CHR \ |
fonts/smal.chr:FONTS/SMAL.CHR:$(PROGS)/demos/bgitest/trunk/FONTS/SMAL.CHR \ |
fonts/trip.chr:FONTS/TRIP.CHR:$(PROGS)/demos/bgitest/trunk/FONTS/TRIP.CHR \ |
fonts/tscr.chr:FONTS/TSCR.CHR:$(PROGS)/demos/bgitest/trunk/FONTS/TSCR.CHR |
# List of other files to be included in the image file. |
# Some of them are auto-built with special rules, some just exist before build. |
# Each item is of the form <local name>:<name inside image>. |
# Spaces should be represented as |. |
OTHER_FILES:=asciivju:ASCIIVJU autorun.dat:AUTORUN.DAT \ |
background.gif:background.gif default.skn:DEFAULT.SKN \ |
e80:E80 graph:GRAPH hdread:HDREAD htmlv:HTMLV \ |
icons.dat:ICONS.DAT iconstrp.gif:ICONSTRP.GIF index_htm:INDEX.HTM \ |
kernel.mnt:KERNEL.MNT kerpack:KERPACK keymap.key:KEYMAP.KEY kpack:KPACK \ |
kuzkina.mid:KUZKINA.MID lang.inc:LANG.INC lang.ini:LANG.INI \ |
menu.dat:MENU.DAT mykey:MYKEY @notify:@NOTIFY \ |
panel.dat:PANEL.DAT pipetka:PIPETKA setup.dat:SETUP.DAT \ |
shell:SHELL spanel:SPANEL table:TABLE test:TEST \ |
vmode:VMODE \ |
3d/3dsheart:3D/3DSHEART 3d/3dspiral:3D/3DSPIRAL 3d/cubeline:3D/CUBELINE \ |
3d/flatwav:3D/FLATWAV 3d/gears:3D/GEARS 3d/house.3ds:3D/HOUSE.3DS \ |
demos/aclock:DEMOS/ACLOCK demos/ak47.lif:DEMOS/AK47.LIF \ |
demos/barge.lif:DEMOS/BARGE.LIF demos/life2:DEMOS/LIFE2 \ |
demos/relay.lif:DEMOS/RELAY.LIF demos/rpento.lif:DEMOS/RPENTO.LIF \ |
demos/use_mb:DEMOS/USE_MB demos/web:DEMOS/WEB \ |
drivers/atikms.dll:DRIVERS/ATIKMS.DLL \ |
File|Managers/buttons.bmp:File|Managers/BUTTONS.BMP \ |
File|Managers/eolite:File|Managers/EOLITE \ |
File|Managers/eolite.ini:File|Managers/EOLITE.INI \ |
File|Managers/icons.bmp:File|Managers/ICONS.BMP \ |
File|Managers/icons.ini:File|Managers/ICONS.INI \ |
File|Managers/kfar.ini:File|Managers/KFAR.INI \ |
File|Managers/kfm:File|Managers/KFM \ |
File|Managers/kfm.ini:File|Managers/KFM.INI \ |
File|Managers/kfm_keys.txt:File|Managers/KFM_KEYS.TXT \ |
fonts/bold.chr:FONTS/BOLD.CHR fonts/char2.mt:FONTS/CHAR2.MT \ |
fonts/char.mt:FONTS/CHAR.MT \ |
games/appdata.dat:GAMES/APPDATA.DAT games/ataka:GAMES/ATAKA \ |
games/basekurs.kla:GAMES/BASEKURS.KLA games/bnc:GAMES/BNC games/c4:GAMES/C4 \ |
games/checkers:GAMES/CHECKERS games/clicks:GAMES/CLICKS \ |
games/FindNumbers:GAMES/FindNumbers games/gomoku:GAMES/GOMOKU \ |
games/klavisha:GAMES/KLAVISHA games/kosilka:GAMES/KOSILKA \ |
games/kosskin.gfx:GAMES/KOSSKIN.GFX games/kox:GAMES/KOX \ |
games/lights:GAMES/LIGHTS games/megamaze:GAMES/MEGAMAZE games/mine:GAMES/MINE \ |
games/msquare:GAMES/MSQUARE games/padenie:GAMES/PADENIE \ |
games/reversi:GAMES/REVERSI games/rforces:GAMES/RFORCES \ |
games/snake.ini:GAMES/SNAKE.INI games/sq_game:GAMES/SQ_GAME \ |
games/sudoku:GAMES/SUDOKU games/sw:GAMES/SW games/whowtbam:GAMES/WHOWTBAM \ |
games/xonix:GAMES/XONIX \ |
lib/cnv_png.obj:LIB/CNV_PNG.OBJ lib/msgbox.obj:LIB/MSGBOX.OBJ \ |
lib/pixlib.obj:LIB/PIXLIB.OBJ lib/sort.obj:LIB/SORT.OBJ \ |
media/ac97snd:MEDIA/AC97SND media/kiv.ini:MEDIA/KIV.INI \ |
media/listplay:MEDIA/LISTPLAY media/startmus:MEDIA/STARTMUS \ |
network/jmail:NETWORK/JMAIL network/zeroconf.ini:NETWORK/ZEROCONF.INI \ |
#end of list |
#3d/logio.bmp:3D/LOGIO.BMP 3d/cubetext:3D/CUBETEXT |
# Some macro for convenient work. |
# Macros for replacing '|' to escaped space '\ '. |
space:=\ #plus space |
respace=$(subst |,$(space),$(1)) |
# Macro for selecting different parts of ':'-separated items. |
binarypart=$(word 1,$(subst :, ,$(1))) |
imagepart=$(word 2,$(subst :, ,$(1))) |
sourcepart=$(word 3,$(subst :, ,$(1))) |
# Get file names, possibly with spaces inside, from an item. |
# Here $(f) is an item - in fact, macro argument. |
fbinary=$(call respace,$(call binarypart,$(f))) |
fimage=$(call respace,$(call imagepart,$(f))) |
fsource=$(call respace,$(call sourcepart,$(f))) |
# Define targets for image file. |
# Join lists $(FASM_PROGRAMS), $(COPY_FILES) and $(OTHER_FILES); |
# for each item in the united list call fbinary. |
targets:=$(foreach f,$(COPY_FILES) $(FASM_PROGRAMS) $(OTHER_FILES),$(fbinary)) |
# Define a command for copying a file inside the image. |
# mcopy_command is a macro with two parameters, |
# local file name $(1) and image file name $(2). |
# Note that spaces in these have to be escaped with backslashes. |
mcopy_command=mcopy -mi $(BUILD_DIR)/kolibri.img $(1) ::$(2) |
# Specialize a previous command for an item $(f) in one of lists. |
mcopy_item_command=$(call mcopy_command,$(fbinary),$(fimage)) |
# Join all $(mcopy_item_command) for all items, |
# append newline after each item. |
# The first newline character after "define" line and |
# the last newline character before "endef" line get away |
# with define/endef, so we make three newline characters, |
# that is two empty lines, in order to get one in $(newline). |
define newline |
endef |
mcopy_all_items:=$(foreach f,$(FASM_PROGRAMS) $(COPY_FILES) $(OTHER_FILES),$(mcopy_item_command)$(newline)) |
# The main goal: image. |
$(BUILD_DIR)/kolibri.img: $(BUILD_DIR)/.dir \ |
Makefile \ |
$(BUILD_DIR)/boot_fat12.bin \ |
$(targets) |
# SYSXTREE |
# 3d/CUBETEXT |
# 3d/LOGIO.BMP |
dd if=/dev/zero of=$(BUILD_DIR)/kolibri.img count=2880 bs=512 |
mformat -f 1440 -i $(BUILD_DIR)/kolibri.img :: |
dd if=$(BUILD_DIR)/boot_fat12.bin of=$(BUILD_DIR)/kolibri.img count=1 bs=512 conv=notrunc |
mmd -i $(BUILD_DIR)/kolibri.img ::3D |
mmd -i $(BUILD_DIR)/kolibri.img ::DEMOS |
mmd -i $(BUILD_DIR)/kolibri.img ::DEVELOP |
mmd -i $(BUILD_DIR)/kolibri.img ::DRIVERS |
mmd -i $(BUILD_DIR)/kolibri.img ::File\ Managers |
mmd -i $(BUILD_DIR)/kolibri.img ::FONTS |
mmd -i $(BUILD_DIR)/kolibri.img ::GAMES |
mmd -i $(BUILD_DIR)/kolibri.img ::LIB |
mmd -i $(BUILD_DIR)/kolibri.img ::MEDIA |
mmd -i $(BUILD_DIR)/kolibri.img ::NETWORK |
$(mcopy_all_items) |
# Special target to modify behaviour of make. |
.DELETE_ON_ERROR: |
# The floppy bootsector. |
$(BUILD_DIR)/boot_fat12.bin: $(KERNEL)/bootloader/boot_fat12.asm $(KERNEL)/bootloader/floppy1440.inc |
fasm $(KERNEL)/bootloader/boot_fat12.asm $(BUILD_DIR)/boot_fat12.bin |
$(BUILD_DIR)/.dir 3d/.dir demos/.dir develop/.dir drivers/.dir fonts/.dir \ |
games/.dir lib/.dir media/.dir network/.dir .deps/.dir: |
mkdir -p $(dir $@) |
touch $@ |
File\ Managers/.dir: |
mkdir -p "File Managers" |
touch "File Managers/.dir" |
# Define the rule for all FASM programs. |
# Yes, this looks like a black magic. |
# But it is not so scary as it seems. |
# First, we define "meta-rule" as a rule which is |
# macro depending on $(fasmprog). |
# Second, the construction foreach+eval creates |
# usual rules, one for each $(fasmprog) in $(FASM_PROGRAMS). |
# Note that meta-rule is double-expanded, first |
# time as the arg of eval - it is the place where $(fasmprog) |
# gets expanded - and second time as the rule; |
# so all $ which are expected to expand at the second time should be escaped. |
# And all $ which are expected to be expanded by the shell should be escaped |
# twice, so they become $$$$. |
# The arguments of macro fasm_meta_rule: |
# $(1) = name of binary file, |
# $(2) = name of main source file. |
# $(3) = folder of binary file - without spaces. |
# $(4) = name of program - without path and extension, |
define fasm_meta_rule |
$(1): $(2) Makefile .deps/.dir $$(call respace,$$(addsuffix .dir,$(3))) |
fasm -m 65536 $$< "$$@" -s .deps/$(4).fas |
prepsrc .deps/$(4).fas /dev/null |
prepsrc .deps/$(4).fas /dev/stdout | (echo -n '$(1):' && \ |
perl -ne 's|\\|/|g;print " \\\n $$$$1" if /^;include \x27(.*?)\x27/' \ |
&& echo) > .deps/$(4).Po |
kpack --nologo "$$@" |
-include .deps/$(4).Po |
endef |
progname=$(call respace,$(basename $(notdir $(call binarypart,$(f))))) |
binarydir=$(subst ./,,$(dir $(call binarypart,$(f)))) |
$(foreach f,$(FASM_PROGRAMS),$(eval $(call fasm_meta_rule,$(fbinary),$(fsource),$(binarydir),$(progname)))) |
# Rule for the kernel differs: it uses kerpack instead of kpack. |
kernel.mnt: $(KERNEL)/kernel.asm Makefile .deps/.dir |
fasm -m 65536 $< "$@" -s .deps/kernel.fas |
prepsrc .deps/kernel.fas /dev/null |
prepsrc .deps/kernel.fas /dev/stdout | (echo -n 'kernel.mnt:' && \ |
perl -ne 's|\\|/|g;print " \\\n $$1" if /^;include \x27(.*?)\x27/' \ |
&& echo) > .deps/kernel.Po |
kerpack $@ |
-include .deps/kernel.Po |
# Rule for copying files is simpler, but similar to previous. |
define copy_meta_rule |
$(1): $(2) Makefile $$(call respace,$$(addsuffix .dir,$(3))) |
cp $$< "$$@" |
endef |
$(foreach f,$(COPY_FILES),$(eval $(call copy_meta_rule,$(fbinary),$(fsource),$(binarydir)))) |
# Special rules for copying sysfuncr.txt. |
docpak: $(DOCDIR)SYSFUNCR.TXT $(wildcard $(DOCDIR)*) |
$(DOCDIR)SYSFUNCR.TXT: $(KERNEL)/docs/sysfuncr.txt |
cp $(KERNEL)/docs/sysfuncr.txt $(DOCDIR)SYSFUNCR.TXT |
/data/rus/asciivju |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/rus/autorun.dat |
---|
0,0 → 1,12 |
# Program Parameters Delay |
/RD/1/COMMOUSE <NO> 1 # COM mice detector |
/RD/1/DRIVERS/ATIKMS -l/rd/1/drivers/ati.log -1 #ATI videodriver loader |
/RD/1/MEDIA/KIV \T__background.gif -1 # Desktop background image |
/RD/1/@CLIP <NO> 1 # Clipboard |
/RD/1/@RB <NO> 1 # Desktop right-click menu |
/RD/1/@SS <NO> 1 # Screensaver |
/RD/1/@PANEL <NO> 1 # Start panel |
/RD/1/SETUP BOOT 1 # Load device settings |
/RD/1/ICON BOOT 1 # Multithread icon |
/RD/1/NETWORK/ZEROCONF <NO> 1 # Network configuration |
### Hello, ASM World! ### |
/data/rus/background.gif |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/rus/default.skn |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/rus/demos/aclock |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/rus/demos/ak47.lif |
---|
0,0 → 1,71 |
#Life 1.05 |
#D AK47, a gun at 47 gens/shot. |
#D The AK47 reaction (middle) |
#D by Richard Schroeppel was |
#D known for years before |
#D stabilizers were found by |
#D Paul Callahan in July 1994. |
#D See also P94S. |
#N |
#P -23 -11 |
...** |
..*..* |
.*.*..* |
.*.*...* |
**.*.****** |
...*..*.* |
...***.*..* |
.**...*.*.* |
*..*.**.* |
.**...*.** |
...**....* |
...*.*...* |
**.*.....** |
.*.*.** |
.*.*..* |
..*..* |
...** |
#P -6 -12 |
**.......* |
**.....*** |
......* |
......** |
. |
...*** |
..*...* |
.*.....* |
.*.....* |
.*.....* |
..*...* |
...*** |
. |
. |
. |
. |
. |
. |
. |
. |
. |
....** |
.....* |
..***.....** |
..*.......** |
#P 12 -5 |
......** |
.....*..* |
....*.**.* |
.*...*.*.* |
.*...*.*.** |
*......* |
..*..*** |
..*.....** |
..*.**.*..* |
.**.*...** |
**...*** |
.**....* |
**..**.*.** |
....**.*.* |
....*..*.* |
.....*..* |
......** |
/data/rus/demos/barge.lif |
---|
0,0 → 1,406 |
#Life 1.05 |
#D c/3 spaceship extensible in 2 dimensions |
#D Hartmut Holzwart, David Bell |
#N |
#P -32 -50 |
...* |
..*.* |
.** |
..* |
.*.* |
.* |
* |
*.* |
*.* |
.**** |
...*.* |
...*.* |
..* |
..*** |
* |
*** |
.***.* |
...* |
...* |
...** |
#P -29 -29 |
** |
*..* |
*.** |
.*** |
.** |
...* |
.** |
..*.* |
...* |
. |
...* |
..*.* |
.** |
...* |
.** |
.*** |
*.** |
*..* |
** |
. |
** |
*..* |
*.** |
.*** |
.** |
...* |
.** |
..*.* |
...* |
. |
...* |
..*.* |
.** |
...* |
.** |
.*** |
*.** |
*..* |
** |
. |
** |
*..* |
*.** |
.*** |
.** |
...* |
.** |
..*.* |
...* |
. |
...* |
..*.* |
.** |
...* |
.** |
.*** |
*.** |
*..* |
** |
#P -32 31 |
...** |
...* |
...* |
.***.* |
*** |
* |
..*** |
..* |
...*.* |
...*.* |
.**** |
*.* |
*.* |
* |
.* |
.*.* |
..* |
.** |
..*.* |
...* |
#P -24 -29 |
..**.*.*.* |
.*...*..** |
*.....* |
.*......*.* |
...**..**.* |
..*...* |
..*.***...* |
..* |
...******** |
. |
...******** |
..* |
..*.***...* |
..*...* |
...**..**.* |
.*......*.* |
*.....* |
.*...*..** |
..**.*.*.* |
. |
..**.*.*.* |
.*...*..** |
*.....* |
.*......*.* |
...**..**.* |
..*...* |
..*.***...* |
..* |
...******** |
. |
...******** |
..* |
..*.***...* |
..*...* |
...**..**.* |
.*......*.* |
*.....* |
.*...*..** |
..**.*.*.* |
. |
..**.*.*.* |
.*...*..** |
*.....* |
.*......*.* |
...**..**.* |
..*...* |
..*.***...* |
..* |
...******** |
. |
...******** |
..* |
..*.***...* |
..*...* |
...**..**.* |
.*......*.* |
*.....* |
.*...*..** |
..**.*.*.* |
#P -12 -29 |
..**.*.*.* |
.*...*..** |
*.....* |
.*......*.* |
...**..**.* |
..*...* |
..*.***...* |
..* |
...******** |
. |
...******** |
..* |
..*.***...* |
..*...* |
...**..**.* |
.*......*.* |
*.....* |
.*...*..** |
..**.*.*.* |
. |
..**.*.*.* |
.*...*..** |
*.....* |
.*......*.* |
...**..**.* |
..*...* |
..*.***...* |
..* |
...******** |
. |
...******** |
..* |
..*.***...* |
..*...* |
...**..**.* |
.*......*.* |
*.....* |
.*...*..** |
..**.*.*.* |
. |
..**.*.*.* |
.*...*..** |
*.....* |
.*......*.* |
...**..**.* |
..*...* |
..*.***...* |
..* |
...******** |
. |
...******** |
..* |
..*.***...* |
..*...* |
...**..**.* |
.*......*.* |
*.....* |
.*...*..** |
..**.*.*.* |
#P 0 -29 |
..**.*.*.* |
.*...*..** |
*.....* |
.*......*.* |
...**..**.* |
..*...* |
..*.***...* |
..* |
...******** |
. |
...******** |
..* |
..*.***...* |
..*...* |
...**..**.* |
.*......*.* |
*.....* |
.*...*..** |
..**.*.*.* |
. |
..**.*.*.* |
.*...*..** |
*.....* |
.*......*.* |
...**..**.* |
..*...* |
..*.***...* |
..* |
...******** |
. |
...******** |
..* |
..*.***...* |
..*...* |
...**..**.* |
.*......*.* |
*.....* |
.*...*..** |
..**.*.*.* |
. |
..**.*.*.* |
.*...*..** |
*.....* |
.*......*.* |
...**..**.* |
..*...* |
..*.***...* |
..* |
...******** |
. |
...******** |
..* |
..*.***...* |
..*...* |
...**..**.* |
.*......*.* |
*.....* |
.*...*..** |
..**.*.*.* |
#P 12 -29 |
..**.*.*.* |
.*...*..** |
*.....* |
.*......*.* |
...**..**.* |
..*...* |
..*.***...* |
..* |
...******** |
. |
...******** |
..* |
..*.***...* |
..*...* |
...**..**.* |
.*......*.* |
*.....* |
.*...*..** |
..**.*.*.* |
. |
..**.*.*.* |
.*...*..** |
*.....* |
.*......*.* |
...**..**.* |
..*...* |
..*.***...* |
..* |
...******** |
. |
...******** |
..* |
..*.***...* |
..*...* |
...**..**.* |
.*......*.* |
*.....* |
.*...*..** |
..**.*.*.* |
. |
..**.*.*.* |
.*...*..** |
*.....* |
.*......*.* |
...**..**.* |
..*...* |
..*.***...* |
..* |
...******** |
. |
...******** |
..* |
..*.***...* |
..*...* |
...**..**.* |
.*......*.* |
*.....* |
.*...*..** |
..**.*.*.* |
#P 24 -29 |
..**.*.*.* |
.*...*..** |
*.....* |
.*......*.* |
...**..**.* |
..*...* |
..*.***...* |
..* |
...******** |
. |
...******** |
..* |
..*.***...* |
..*...* |
...**..**.* |
.*......*.* |
*.....* |
.*...*..** |
..**.*.*.* |
. |
..**.*.*.* |
.*...*..** |
*.....* |
.*......*.* |
...**..**.* |
..*...* |
..*.***...* |
..* |
...******** |
. |
...******** |
..* |
..*.***...* |
..*...* |
...**..**.* |
.*......*.* |
*.....* |
.*...*..** |
..**.*.*.* |
. |
..**.*.*.* |
.*...*..** |
*.....* |
.*......*.* |
...**..**.* |
..*...* |
..*.***...* |
..* |
...******** |
. |
...******** |
..* |
..*.***...* |
..*...* |
...**..**.* |
.*......*.* |
*.....* |
.*...*..** |
..**.*.*.* |
/data/rus/demos/life2 |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/rus/demos/relay.lif |
---|
0,0 → 1,12 |
#Life 1.05 |
#D Relay between two pentadecathlons |
#D Well known. |
#N |
#P -17 -2 |
********** |
#P -1 0 |
* |
.** |
** |
#P 8 2 |
********** |
/data/rus/demos/rpento.lif |
---|
0,0 → 1,13 |
#Life 1.05 |
#D r-pentomino |
#D A small, vigorous, common pattern. |
#D |
#D When the Game of Life was first |
#D introduced around 1970, this was |
#D proposed as the smallest pattern |
#D for which the outcome was unknown. |
#N |
#P 3 3 |
.** |
** |
.* |
/data/rus/demos/use_mb |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/rus/demos/web |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/rus/docs/FASM.TXT |
---|
0,0 → 1,3591 |
Üßßß |
ÜÜÛÜÜ ÜÜÜÜ ÜÜÜÜÜ ÜÜÜ ÜÜ |
Û Û Û Û Û Û |
Û ÜßßßßÛ ßßßßÜ Û Û Û |
Û ßÜÜÜÜÛÜ ÜÜÜÜÜß Û Û Û |
flat assembler 1.66 |
Programmer's Manual |
Table of contents |
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ |
Chapter 1 Introduction |
1.1 Compiler overview |
1.1.1 System requirements |
1.1.2 Executing compiler from command line |
1.1.3 Compiler messages |
1.1.4 Output formats |
1.2 Assembly syntax |
1.2.1 Instruction syntax |
1.2.2 Data definitions |
1.2.3 Constants and labels |
1.2.4 Numerical expressions |
1.2.5 Jumps and calls |
1.2.6 Size settings |
Chapter 2 Instruction set |
2.1 The x86 architecture instructions |
2.1.1 Data movement instructions |
2.1.2 Type conversion instructions |
2.1.3 Binary arithmetic instructions |
2.1.4 Decimal arithmetic instructions |
2.1.5 Logical instructions |
2.1.6 Control transfer instructions |
2.1.7 I/O instructions |
2.1.8 Strings operations |
2.1.9 Flag control instructions |
2.1.10 Conditional operations |
2.1.11 Miscellaneous instructions |
2.1.12 System instructions |
2.1.13 FPU instructions |
2.1.14 MMX instructions |
2.1.15 SSE instructions |
2.1.16 SSE2 instructions |
2.1.17 SSE3 instructions |
2.1.18 AMD 3DNow! instructions |
2.1.19 The x86-64 long mode instructions |
2.2 Control directives |
2.2.1 Numerical constants |
2.2.2 Conditional assembly |
2.2.3 Repeating blocks of instructions |
2.2.4 Addressing spaces |
2.2.5 Other directives |
2.2.6 Multiple passes |
2.3 Preprocessor directives |
2.3.1 Including source files |
2.3.2 Symbolic constants |
2.3.3 Macroinstructions |
2.3.4 Structures |
2.3.5 Repeating macroinstructions |
2.3.6 Conditional preprocessing |
2.3.7 Order of processing |
2.4 Formatter directives |
2.4.1 MZ executable |
2.4.2 Portable Executable |
2.4.3 Common Object File Format |
2.4.4 Executable and Linkable Format |
Chapter 1 Introduction |
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ |
This chapter contains all the most important information you need to begin |
using the flat assembler. If you are experienced assembly language programmer, |
you should read at least this chapter before using this compiler. |
1.1 Compiler overview |
Flat assembler is a fast assembly language compiler for the x86 architecture |
processors, which does multiple passes to optimize the size of generated |
machine code. It is self-compilable and versions for different operating |
systems are provided. All the versions are designed to be used from the system |
command line and they should not differ in behavior. |
1.1.1 System requirements |
All versions require the x86 architecture 32-bit processor (at least 80386), |
although they can produce programs for the x86 architecture 16-bit processors, |
too. DOS version requires an OS compatible with MS DOS 2.0 and either true |
real mode environment or DPMI. Windows version requires a Win32 console |
compatible with 3.1 version. |
1.1.2 Executing compiler from command line |
To execute flat assembler from the command line you need to provide two |
parameters - first should be name of source file, second should be name of |
destination file. If no second parameter is given, the name for output |
file will be guessed automatically. After displaying short information about |
the program name and version, compiler will read the data from source file and |
compile it. When the compilation is successful, compiler will write the |
generated code to the destination file and display the summary of compilation |
process; otherwise it will display the information about error that occurred. |
The source file should be a text file, and can be created in any text |
editor. Line breaks are accepted in both DOS and Unix standards, tabulators |
are treated as spaces. |
In the command line you can also include "-m" option followed by a number, |
which specifies how many kilobytes of memory flat assembler should maximally |
use. In case of DOS version this options limits only the usage of extended |
memory. The "-p" option followed by a number can be used to specify the limit |
for number of passes the assembler performs. If code cannot be generated |
within specified amount of passes, the assembly will be terminated with an |
error message. The maximum value of this setting is 65536, while the default |
limit, used when no such option is included in command line, is 100. |
It is also possible to limit the number of passes the assembler |
performs, with the "-p" option followed by a number specifying the maximum |
number of passes. |
There are no command line options that would affect the output of compiler, |
flat assembler requires only the source code to include the information it |
really needs. For example, to specify output format you specify it by using |
the "format" directive at the beginning of source. |
1.1.3 Compiler messages |
As it is stated above, after the successful compilation, the compiler displays |
the compilation summary. It includes the information of how many passes was |
done, how much time it took, and how many bytes were written into the |
destination file. |
The following is an example of the compilation summary: |
flat assembler version 1.66 |
38 passes, 5.3 seconds, 77824 bytes. |
In case of error during the compilation process, the program will display an |
error message. For example, when compiler can't find the input file, it will |
display the following message: |
flat assembler version 1.66 |
error: source file not found. |
If the error is connected with a specific part of source code, the source line |
that caused the error will be also displayed. Also placement of this line in |
the source is given to help you finding this error, for example: |
flat assembler version 1.66 |
example.asm [3]: |
mob ax,1 |
error: illegal instruction. |
It means that in the third line of the "example.asm" file compiler has |
encountered an unrecognized instruction. When the line that caused error |
contains a macroinstruction, also the line in macroinstruction definition |
that generated the erroneous instruction is displayed: |
flat assembler version 1.66 |
example.asm [6]: |
stoschar 7 |
example.asm [3] stoschar [1]: |
mob al,char |
error: illegal instruction. |
It means that the macroinstruction in the sixth line of the "example.asm" file |
generated an unrecognized instruction with the first line of its definition. |
1.1.4 Output formats |
By default, when there is no "format" directive in source file, flat |
assembler simply puts generated instruction codes into output, creating this |
way flat binary file. By default it generates 16-bit code, but you can always |
turn it into the 16-bit or 32-bit mode by using "use16" or "use32" directive. |
Some of the output formats switch into 32-bit mode, when selected - more |
information about formats which you can choose can be found in 2.4. |
All output code is always in the order in which it was entered into the |
source file. |
1.2 Assembly syntax |
The information provided below is intended mainly for the assembler |
programmers that have been using some other assembly compilers before. |
If you are beginner, you should look for the assembly programming tutorials. |
Flat assembler by default uses the Intel syntax for the assembly |
instructions, although you can customize it using the preprocessor |
capabilities (macroinstructions and symbolic constants). It also has its own |
set of the directives - the instructions for compiler. |
All symbols defined inside the sources are case-sensitive. |
1.2.1 Instruction syntax |
Instructions in assembly language are separated by line breaks, and one |
instruction is expected to fill the one line of text. If a line contains |
a semicolon, except for the semicolons inside the quoted strings, the rest of |
this line is the comment and compiler ignores it. If a line ends with "\" |
character (eventually the semicolon and comment may follow it), the next line |
is attached at this point. |
Each line in source is the sequence of items, which may be one of the three |
types. One type are the symbol characters, which are the special characters |
that are individual items even when are not spaced from the other ones. |
Any of the "+-*/=<>()[]{}:,|&~#`" is the symbol character. The sequence of |
other characters, separated from other items with either blank spaces or |
symbol characters, is a symbol. If the first character of symbol is either a |
single or double quote, it integrates the any sequence of characters following |
it, even the special ones, into a quoted string, which should end with the same |
character, with which it began (the single or double quote) - however if there |
are two such characters in a row (without any other character between them), |
they are integrated into quoted string as just one of them and the quoted |
string continues then. The symbols other than symbol characters and quoted |
strings can be used as names, so are also called the name symbols. |
Every instruction consists of the mnemonic and the various number of |
operands, separated with commas. The operand can be register, immediate value |
or a data addressed in memory, it can also be preceded by size operator to |
define or override its size (table 1.1). Names of available registers you can |
find in table 1.2, their sizes cannot be overridden. Immediate value can be |
specified by any numerical expression. |
When operand is a data in memory, the address of that data (also any |
numerical expression, but it may contain registers) should be enclosed in |
square brackets or preceded by "ptr" operator. For example instruction |
"mov eax,3" will put the immediate value 3 into the EAX register, instruction |
"mov eax,[7]" will put the 32-bit value from the address 7 into EAX and the |
instruction "mov byte [7],3" will put the immediate value 3 into the byte at |
address 7, it can also be written as "mov byte ptr 7,3". To specify which |
segment register should be used for addressing, segment register name followed |
by a colon should be put just before the address value (inside the square |
brackets or after the "ptr" operator). |
Table 1.1 Size operators |
ÚÄÄÄÄÄÄÄÄÄÄÂÄÄÄÄÄÄÂÄÄÄÄÄÄÄ¿ |
³ Operator ³ Bits ³ Bytes ³ |
ÆÍÍÍÍÍÍÍÍÍÍØÍÍÍÍÍÍØÍÍÍÍÍÍ͵ |
³ byte ³ 8 ³ 1 ³ |
³ word ³ 16 ³ 2 ³ |
³ dword ³ 32 ³ 4 ³ |
³ fword ³ 48 ³ 6 ³ |
³ pword ³ 48 ³ 6 ³ |
³ qword ³ 64 ³ 8 ³ |
³ tbyte ³ 80 ³ 10 ³ |
³ tword ³ 80 ³ 10 ³ |
³ dqword ³ 128 ³ 16 ³ |
ÀÄÄÄÄÄÄÄÄÄÄÁÄÄÄÄÄÄÁÄÄÄÄÄÄÄÙ |
Table 1.2 Registers |
ÚÄÄÄÄÄÄÄÄÄÂÄÄÄÄÄÄÂÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿ |
³ Type ³ Bits ³ ³ |
ÆÍÍÍÍÍÍÍÍÍØÍÍÍÍÍÍØÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ͵ |
³ ³ 8 ³ al cl dl bl ah ch dh bh ³ |
³ General ³ 16 ³ ax cx dx bx sp bp si di ³ |
³ ³ 32 ³ eax ecx edx ebx esp ebp esi edi ³ |
ÃÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´ |
³ Segment ³ 16 ³ es cs ss ds fs gs ³ |
ÃÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´ |
³ Control ³ 32 ³ cr0 cr2 cr3 cr4 ³ |
ÃÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´ |
³ Debug ³ 32 ³ dr0 dr1 dr2 dr3 dr6 dr7 ³ |
ÃÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´ |
³ FPU ³ 80 ³ st0 st1 st2 st3 st4 st5 st6 st7 ³ |
ÃÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´ |
³ MMX ³ 64 ³ mm0 mm1 mm2 mm3 mm4 mm5 mm6 mm7 ³ |
ÃÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´ |
³ SSE ³ 128 ³ xmm0 xmm1 xmm2 xmm3 xmm4 xmm5 xmm6 xmm7 ³ |
ÀÄÄÄÄÄÄÄÄÄÁÄÄÄÄÄÄÁÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ |
1.2.2 Data definitions |
To define data or reserve a space for it, use one of the directives listed in |
table 1.3. The data definition directive should be followed by one or more of |
numerical expressions, separated with commas. These expressions define the |
values for data cells of size depending on which directive is used. For |
example "db 1,2,3" will define the three bytes of values 1, 2 and 3 |
respectively. |
The "db" and "du" directives also accept the quoted string values of any |
length, which will be converted into chain of bytes when "db" is used and into |
chain of words with zeroed high byte when "du" is used. For example "db 'abc'" |
will define the three bytes of values 61, 62 and 63. |
The "dp" directive and its synonym "df" accept the values consisting of two |
numerical expressions separated with colon, the first value will become the |
high word and the second value will become the low double word of the far |
pointer value. Also "dd" accepts such pointers consisting of two word values |
separated with colon, and "dt" accepts the word and quad word value separated |
with colon, the quad word is stored first. The "dt" directive with single |
expression as parameter accepts only floating point values and creates data in |
FPU double extended precision format. |
Any of the above directive allows the usage of special "dup" operator to |
make multiple copies of given values. The count of duplicates should precede |
this operator and the value to duplicate should follow - it can even be the |
chain of values separated with commas, but such set of values needs to be |
enclosed with parenthesis, like "db 5 dup (1,2)", which defines five copies |
of the given two byte sequence. |
The "file" is a special directive and its syntax is different. This |
directive includes a chain of bytes from file and it should be followed by the |
quoted file name, then optionally numerical expression specifying offset in |
file preceded by the colon, and - also optionally - comma and numerical |
expression specifying count of bytes to include (if no count is specified, all |
data up to the end of file is included). For example "file 'data.bin'" will |
include the whole file as binary data and "file 'data.bin':10h,4" will include |
only four bytes starting at offset 10h. |
The data reservation directive should be followed by only one numerical |
expression, and this value defines how many cells of the specified size should |
be reserved. All data definition directives also accept the "?" value, which |
means that this cell should not be initialized to any value and the effect is |
the same as by using the data reservation directive. The uninitialized data |
may not be included in the output file, so its values should be always |
considered unknown. |
Table 1.3 Data directives |
ÚÄÄÄÄÄÄÄÄÄÂÄÄÄÄÄÄÄÄÂÄÄÄÄÄÄÄÄÄ¿ |
³ Size ³ Define ³ Reserve ³ |
³ (bytes) ³ data ³ data ³ |
ÆÍÍÍÍÍÍÍÍÍØÍÍÍÍÍÍÍÍØÍÍÍÍÍÍÍÍ͵ |
³ 1 ³ db ³ rb ³ |
³ ³ file ³ ³ |
ÃÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄ´ |
³ 2 ³ dw ³ rw ³ |
³ ³ du ³ ³ |
ÃÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄ´ |
³ 4 ³ dd ³ rd ³ |
ÃÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄ´ |
³ 6 ³ dp ³ rp ³ |
³ ³ df ³ rf ³ |
ÃÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄ´ |
³ 8 ³ dq ³ rq ³ |
ÃÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄ´ |
³ 10 ³ dt ³ rt ³ |
ÀÄÄÄÄÄÄÄÄÄÁÄÄÄÄÄÄÄÄÁÄÄÄÄÄÄÄÄÄÙ |
1.2.3 Constants and labels |
In the numerical expressions you can also use constants or labels instead of |
numbers. To define the constant or label you should use the specific |
directives. Each label can be defined only once and it is accessible from the |
any place of source (even before it was defined). Constant can be redefined |
many times, but in this case it is accessible only after it was defined, and |
is always equal to the value from last definition before the place where it's |
used. When a constant is defined only once in source, it is - like the label - |
accessible from anywhere. |
The definition of constant consists of name of the constant followed by the |
"=" character and numerical expression, which after calculation will become |
the value of constant. This value is always calculated at the time the |
constant is defined. For example you can define "count" constant by using the |
directive "count = 17", and then use it in the assembly instructions, like |
"mov cx,count" - which will become "mov cx,17" during the compilation process. |
There are different ways to define labels. The simplest is to follow the |
name of label by the colon, this directive can even be followed by the other |
instruction in the same line. It defines the label whose value is equal to |
offset of the point where it's defined. This method is usually used to label |
the places in code. The other way is to follow the name of label (without a |
colon) by some data directive. It defines the label with value equal to |
offset of the beginning of defined data, and remembered as a label for data |
with cell size as specified for that data directive in table 1.3. |
The label can be treated as constant of value equal to offset of labeled |
code or data. For example when you define data using the labeled directive |
"char db 224", to put the offset of this data into BX register you should use |
"mov bx,char" instruction, and to put the value of byte addressed by "char" |
label to DL register, you should use "mov dl,[char]" (or "mov dl,ptr char"). |
But when you try to assemble "mov ax,[char]", it will cause an error, because |
fasm compares the sizes of operands, which should be equal. You can force |
assembling that instruction by using size override: "mov ax,word [char]", but |
remember that this instruction will read the two bytes beginning at "char" |
address, while it was defined as a one byte. |
The last and the most flexible way to define labels is to use "label" |
directive. This directive should be followed by the name of label, then |
optionally size operator (it can be preceded by a colon) and then - also |
optionally "at" operator and the numerical expression defining the address at |
which this label should be defined. For example "label wchar word at char" |
will define a new label for the 16-bit data at the address of "char". Now the |
instruction "mov ax,[wchar]" will be after compilation the same as |
"mov ax,word [char]". If no address is specified, "label" directive defines |
the label at current offset. Thus "mov [wchar],57568" will copy two bytes |
while "mov [char],224" will copy one byte to the same address. |
The label whose name begins with dot is treated as local label, and its name |
is attached to the name of last global label (with name beginning with |
anything but dot) to make the full name of this label. So you can use the |
short name (beginning with dot) of this label anywhere before the next global |
label is defined, and in the other places you have to use the full name. Label |
beginning with two dots are the exception - they are like global, but they |
don't become the new prefix for local labels. |
The "@@" name means anonymous label, you can have defined many of them in |
the source. Symbol "@b" (or equivalent "@r") references the nearest preceding |
anonymous label, symbol "@f" references the nearest following anonymous label. |
These special symbol are case-insensitive. |
1.2.4 Numerical expressions |
In the above examples all the numerical expressions were the simple numbers, |
constants or labels. But they can be more complex, by using the arithmetical |
or logical operators for calculations at compile time. All these operators |
with their priority values are listed in table 1.4. |
The operations with higher priority value will be calculated first, you can |
of course change this behavior by putting some parts of expression into |
parenthesis. The "+", "-", "*" and "/" are standard arithmetical operations, |
"mod" calculates the remainder from division. The "and", "or", "xor", "shl", |
"shr" and "not" perform the same logical operations as assembly instructions |
of those names. The "rva" performs the conversion of an address into the |
relocatable offset and is specific to some of the output formats (see 2.4). |
The numbers in the expression are by default treated as a decimal, binary |
numbers should have the "b" letter attached at the end, octal number should |
end with "o" letter, hexadecimal numbers should begin with "0x" characters |
(like in C language) or with the "$" character (like in Pascal language) or |
they should end with "h" letter. Also quoted string, when encountered in |
expression, will be converted into number - the first character will become |
the least significant byte of number. |
The numerical expression used as an address value can also contain any of |
general registers used for addressing, they can be added and multiplied by |
appropriate values, as it is allowed for the x86 architecture instructions. |
There are also some special symbols that can be used inside the numerical |
expression. First is "$", which is always equal to the value of current |
offset, while "$$" is equal to base address of current addressing space. The |
other one is "%", which is the number of current repeat in parts of code that |
are repeated using some special directives (see 2.2). There's also "%t" |
symbol, which is always equal to the current time stamp. |
Any numerical expression can also consist of single floating point value |
(flat assembler does not allow any floating point operations at compilation |
time) in the scientific notation, they can end with the "f" letter to be |
recognized, otherwise they should contain at least one of the "." or "E" |
characters. So "1.0", "1E0" and "1f" define the same floating point value, |
while simple "1" defines an integer value. |
Table 1.4 Arithmetical and logical operators by priority |
ÚÄÄÄÄÄÄÄÄÄÄÂÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿ |
³ Priority ³ Operators ³ |
ÆÍÍÍÍÍÍÍÍÍÍØÍÍÍÍÍÍÍÍÍÍÍÍÍ͵ |
³ 0 ³ + - ³ |
ÃÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´ |
³ 1 ³ * / ³ |
ÃÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´ |
³ 2 ³ mod ³ |
ÃÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´ |
³ 3 ³ and or xor ³ |
ÃÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´ |
³ 4 ³ shl shr ³ |
ÃÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´ |
³ 5 ³ not ³ |
ÃÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´ |
³ 6 ³ rva ³ |
ÀÄÄÄÄÄÄÄÄÄÄÁÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ |
1.2.5 Jumps and calls |
The operand of any jump or call instruction can be preceded not only by the |
size operator, but also by one of the operators specifying type of the jump: |
"short", "near" of "far". For example, when assembler is in 16-bit mode, |
instruction "jmp dword [0]" will become the far jump and when assembler is |
in 32-bit mode, it will become the near jump. To force this instruction to be |
treated differently, use the "jmp near dword [0]" or "jmp far dword [0]" form. |
When operand of near jump is the immediate value, assembler will generate |
the shortest variant of this jump instruction if possible (but won't create |
32-bit instruction in 16-bit mode nor 16-bit instruction in 32-bit mode, |
unless there is a size operator stating it). By specifying the jump type |
you can force it to always generate long variant (for example "jmp near 0") |
or to always generate short variant and terminate with an error when it's |
impossible (for example "jmp short 0"). |
1.2.6 Size settings |
When instruction uses some memory addressing, by default the smallest form of |
instruction is generated by using the short displacement if only address |
value fits in the range. This can be overridden using the "word" or "dword" |
operator before the address inside the square brackets (or after the "ptr" |
operator), which forces the long displacement of appropriate size to be made. |
In case when address is not relative to any registers, those operators allow |
also to choose the appropriate mode of absolute addressing. |
Instructions "adc", "add", "and", "cmp", "or", "sbb", "sub" and "xor" with |
first operand being 16-bit or 32-bit are by default generated in shortened |
8-bit form when the second operand is immediate value fitting in the range |
for signed 8-bit values. It also can be overridden by putting the "word" or |
"dword" operator before the immediate value. The similar rules applies to the |
"imul" instruction with the last operand being immediate value. |
Immediate value as an operand for "push" instruction without a size operator |
is by default treated as a word value if assembler is in 16-bit mode and as a |
double word value if assembler is in 32-bit mode, shorter 8-bit form of this |
instruction is used if possible, "word" or "dword" size operator forces the |
"push" instruction to be generated in longer form for specified size. "pushw" |
and "pushd" mnemonics force assembler to generate 16-bit or 32-bit code |
without forcing it to use the longer form of instruction. |
Chapter 2 Instruction set |
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ |
This chapter provides the detailed information about the instructions and |
directives supported by flat assembler. Directives for defining labels were |
already discussed in 1.2.3, all other directives will be described later in |
this chapter. |
2.1 The x86 architecture instructions |
In this section you can find both the information about the syntax and |
purpose the assembly language instructions. If you need more technical |
information, look for the Intel Architecture Software Developer's Manual. |
Assembly instructions consist of the mnemonic (instruction's name) and from |
zero to three operands. If there are two or more operands, usually first is |
the destination operand and second is the source operand. Each operand can be |
register, memory or immediate value (see 1.2 for details about syntax of |
operands). After the description of each instruction there are examples |
of different combinations of operands, if the instruction has any. |
Some instructions act as prefixes and can be followed by other instruction |
in the same line, and there can be more than one prefix in a line. Each name |
of the segment register is also a mnemonic of instruction prefix, altough it |
is recommended to use segment overrides inside the square brackets instead of |
these prefixes. |
2.1.1 Data movement instructions |
"mov" transfers a byte, word or double word from the source operand to the |
destination operand. It can transfer data between general registers, from |
the general register to memory, or from memory to general register, but it |
cannot move from memory to memory. It can also transfer an immediate value to |
general register or memory, segment register to general register or memory, |
general register or memory to segment register, control or debug register to |
general register and general register to control or debug register. The "mov" |
can be assembled only if the size of source operand and size of destination |
operand are the same. Below are the examples for each of the allowed |
combinations: |
mov bx,ax ; general register to general register |
mov [char],al ; general register to memory |
mov bl,[char] ; memory to general register |
mov dl,32 ; immediate value to general register |
mov [char],32 ; immediate value to memory |
mov ax,ds ; segment register to general register |
mov [bx],ds ; segment register to memory |
mov ds,ax ; general register to segment register |
mov ds,[bx] ; memory to segment register |
mov eax,cr0 ; control register to general register |
mov cr3,ebx ; general register to control register |
"xchg" swaps the contents of two operands. It can swap two byte operands, |
two word operands or two double word operands. Order of operands is not |
important. The operands may be two general registers, or general register |
with memory. For example: |
xchg ax,bx ; swap two general registers |
xchg al,[char] ; swap register with memory |
"push" decrements the stack frame pointer (ESP register), then transfers |
the operand to the top of stack indicated by ESP. The operand can be memory, |
general register, segment register or immediate value of word or double word |
size. If operand is an immediate value and no size is specified, it is by |
default treated as a word value if assembler is in 16-bit mode and as a double |
word value if assembler is in 32-bit mode. "pushw" and "pushd" mnemonics are |
variants of this instruction that store the values of word or double word size |
respectively. If more operands follow in the same line (separated only with |
spaces, not commas), compiler will assemble chain of the "push" instructions |
with these operands. The examples are with single operands: |
push ax ; store general register |
push es ; store segment register |
pushw [bx] ; store memory |
push 1000h ; store immediate value |
"pusha" saves the contents of the eight general register on the stack. |
This instruction has no operands. There are two version of this instruction, |
one 16-bit and one 32-bit, assembler automatically generates the appropriate |
version for current mode, but it can be overridden by using "pushaw" or |
"pushad" mnemonic to always get the 16-bit or 32-bit version. The 16-bit |
version of this instruction pushes general registers on the stack in the |
following order: AX, CX, DX, BX, the initial value of SP before AX was pushed, |
BP, SI and DI. The 32-bit version pushes equivalent 32-bit general registers |
in the same order. |
"pop" transfers the word or double word at the current top of stack to the |
destination operand, and then increments ESP to point to the new top of stack. |
The operand can be memory, general register or segment register. "popw" and |
"popd" mnemonics are variants of this instruction for restoring the values of |
word or double word size respectively. If more operands separated with spaces |
follow in the same line, compiler will assemble chain of the "pop" |
instructions with these operands. |
pop bx ; restore general register |
pop ds ; restore segment register |
popw [si] ; restore memory |
"popa" restores the registers saved on the stack by "pusha" instruction, |
except for the saved value of SP (or ESP), which is ignored. This instruction |
has no operands. To force assembling 16-bit or 32-bit version of this |
instruction use "popaw" or "popad" mnemonic. |
2.1.2 Type conversion instructions |
The type conversion instructions convert bytes into words, words into double |
words, and double words into quad words. These conversions can be done using |
the sign extension or zero extension. The sign extension fills the extra bits |
of the larger item with the value of the sign bit of the smaller item, the |
zero extension simply fills them with zeros. |
"cwd" and "cdq" double the size of value AX or EAX register respectively |
and store the extra bits into the DX or EDX register. The conversion is done |
using the sign extension. These instructions have no operands. |
"cbw" extends the sign of the byte in AL throughout AX, and "cwde" extends |
the sign of the word in AX throughout EAX. These instructions also have no |
operands. |
"movsx" converts a byte to word or double word and a word to double word |
using the sign extension. "movzx" does the same, but it uses the zero |
extension. The source operand can be general register or memory, while the |
destination operand must be a general register. For example: |
movsx ax,al ; byte register to word register |
movsx edx,dl ; byte register to double word register |
movsx eax,ax ; word register to double word register |
movsx ax,byte [bx] ; byte memory to word register |
movsx edx,byte [bx] ; byte memory to double word register |
movsx eax,word [bx] ; word memory to double word register |
2.1.3 Binary arithmetic instructions |
"add" replaces the destination operand with the sum of the source and |
destination operands and sets CF if overflow has occurred. The operands may |
be bytes, words or double words. The destination operand can be general |
register or memory, the source operand can be general register or immediate |
value, it can also be memory if the destination operand is register. |
add ax,bx ; add register to register |
add ax,[si] ; add memory to register |
add [di],al ; add register to memory |
add al,48 ; add immediate value to register |
add [char],48 ; add immediate value to memory |
"adc" sums the operands, adds one if CF is set, and replaces the destination |
operand with the result. Rules for the operands are the same as for the "add" |
instruction. An "add" followed by multiple "adc" instructions can be used to |
add numbers longer than 32 bits. |
"inc" adds one to the operand, it does not affect CF. The operand can be a |
general register or memory, and the size of the operand can be byte, word or |
double word. |
inc ax ; increment register by one |
inc byte [bx] ; increment memory by one |
"sub" subtracts the source operand from the destination operand and replaces |
the destination operand with the result. If a borrow is required, the CF is |
set. Rules for the operands are the same as for the "add" instruction. |
"sbb" subtracts the source operand from the destination operand, subtracts |
one if CF is set, and stores the result to the destination operand. Rules for |
the operands are the same as for the "add" instruction. A "sub" followed by |
multiple "sbb" instructions may be used to subtract numbers longer than 32 |
bits. |
"dec" subtracts one from the operand, it does not affect CF. Rules for the |
operand are the same as for the "inc" instruction. |
"cmp" subtracts the source operand from the destination operand. It updates |
the flags as the "sub" instruction, but does not alter the source and |
destination operands. Rules for the operands are the same as for the "sub" |
instruction. |
"neg" subtracts a signed integer operand from zero. The effect of this |
instructon is to reverse the sign of the operand from positive to negative or |
from negative to positive. Rules for the operand are the same as for the "inc" |
instruction. |
"xadd" exchanges the destination operand with the source operand, then loads |
the sum of the two values into the destination operand. Rules for the operands |
are the same as for the "add" instruction. |
All the above binary arithmetic instructions update SF, ZF, PF and OF flags. |
SF is always set to the same value as the result's sign bit, ZF is set when |
all the bits of result are zero, PF is set when low order eight bits of result |
contain an even number of set bits, OF is set if result is too large for a |
positive number or too small for a negative number (excluding sign bit) to fit |
in destination operand. |
"mul" performs an unsigned multiplication of the operand and the |
accumulator. If the operand is a byte, the processor multiplies it by the |
contents of AL and returns the 16-bit result to AH and AL. If the operand is a |
word, the processor multiplies it by the contents of AX and returns the 32-bit |
result to DX and AX. If the operand is a double word, the processor multiplies |
it by the contents of EAX and returns the 64-bit result in EDX and EAX. "mul" |
sets CF and OF when the upper half of the result is nonzero, otherwise they |
are cleared. Rules for the operand are the same as for the "inc" instruction. |
"imul" performs a signed multiplication operation. This instruction has |
three variations. First has one operand and behaves in the same way as the |
"mul" instruction. Second has two operands, in this case destination operand |
is multiplied by the source operand and the result replaces the destination |
operand. Destination operand must be a general register, it can be word or |
double word, source operand can be general register, memory or immediate |
value. Third form has three operands, the destination operand must be a |
general register, word or double word in size, source operand can be general |
register or memory, and third operand must be an immediate value. The source |
operand is multiplied by the immediate value and the result is stored in the |
destination register. All the three forms calculate the product to twice the |
size of operands and set CF and OF when the upper half of the result is |
nonzero, but second and third form truncate the product to the size of |
operands. So second and third forms can be also used for unsigned operands |
because, whether the operands are signed or unsigned, the lower half of the |
product is the same. Below are the examples for all three forms: |
imul bl ; accumulator by register |
imul word [si] ; accumulator by memory |
imul bx,cx ; register by register |
imul bx,[si] ; register by memory |
imul bx,10 ; register by immediate value |
imul ax,bx,10 ; register by immediate value to register |
imul ax,[si],10 ; memory by immediate value to register |
"div" performs an unsigned division of the accumulator by the operand. |
The dividend (the accumulator) is twice the size of the divisor (the operand), |
the quotient and remainder have the same size as the divisor. If divisor is |
byte, the dividend is taken from AX register, the quotient is stored in AL and |
the remainder is stored in AH. If divisor is word, the upper half of dividend |
is taken from DX, the lower half of dividend is taken from AX, the quotient is |
stored in AX and the remainder is stored in DX. If divisor is double word, |
the upper half of dividend is taken from EDX, the lower half of dividend is |
taken from EAX, the quotient is stored in EAX and the remainder is stored in |
EDX. Rules for the operand are the same as for the "mul" instruction. |
"idiv" performs a signed division of the accumulator by the operand. |
It uses the same registers as the "div" instruction, and the rules for |
the operand are the same. |
2.1.4 Decimal arithmetic instructions |
Decimal arithmetic is performed by combining the binary arithmetic |
instructions (already described in the prior section) with the decimal |
arithmetic instructions. The decimal arithmetic instructions are used to |
adjust the results of a previous binary arithmetic operation to produce a |
valid packed or unpacked decimal result, or to adjust the inputs to a |
subsequent binary arithmetic operation so the operation will produce a valid |
packed or unpacked decimal result. |
"daa" adjusts the result of adding two valid packed decimal operands in |
AL. "daa" must always follow the addition of two pairs of packed decimal |
numbers (one digit in each half-byte) to obtain a pair of valid packed |
decimal digits as results. The carry flag is set if carry was needed. |
This instruction has no operands. |
"das" adjusts the result of subtracting two valid packed decimal operands |
in AL. "das" must always follow the subtraction of one pair of packed decimal |
numbers (one digit in each half-byte) from another to obtain a pair of valid |
packed decimal digits as results. The carry flag is set if a borrow was |
needed. This instruction has no operands. |
"aaa" changes the contents of register AL to a valid unpacked decimal |
number, and zeroes the top four bits. "aaa" must always follow the addition |
of two unpacked decimal operands in AL. The carry flag is set and AH is |
incremented if a carry is necessary. This instruction has no operands. |
"aas" changes the contents of register AL to a valid unpacked decimal |
number, and zeroes the top four bits. "aas" must always follow the |
subtraction of one unpacked decimal operand from another in AL. The carry flag |
is set and AH decremented if a borrow is necessary. This instruction has no |
operands. |
"aam" corrects the result of a multiplication of two valid unpacked decimal |
numbers. "aam" must always follow the multiplication of two decimal numbers |
to produce a valid decimal result. The high order digit is left in AH, the |
low order digit in AL. The generalized version of this instruction allows |
adjustment of the contents of the AX to create two unpacked digits of any |
number base. The standard version of this instruction has no operands, the |
generalized version has one operand - an immediate value specifying the |
number base for the created digits. |
"aad" modifies the numerator in AH and AL to prepare for the division of two |
valid unpacked decimal operands so that the quotient produced by the division |
will be a valid unpacked decimal number. AH should contain the high order |
digit and AL the low order digit. This instruction adjusts the value and |
places the result in AL, while AH will contain zero. The generalized version |
of this instruction allows adjustment of two unpacked digits of any number |
base. Rules for the operand are the same as for the "aam" instruction. |
2.1.5 Logical instructions |
"not" inverts the bits in the specified operand to form a one's |
complement of the operand. It has no effect on the flags. Rules for the |
operand are the same as for the "inc" instruction. |
"and", "or" and "xor" instructions perform the standard |
logical operations. They update the SF, ZF and PF flags. Rules for the |
operands are the same as for the "add" instruction. |
"bt", "bts", "btr" and "btc" instructions operate on a single bit which can |
be in memory or in a general register. The location of the bit is specified |
as an offset from the low order end of the operand. The value of the offset |
is the taken from the second operand, it either may be an immediate byte or |
a general register. These instructions first assign the value of the selected |
bit to CF. "bt" instruction does nothing more, "bts" sets the selected bit to |
1, "btr" resets the selected bit to 0, "btc" changes the bit to its |
complement. The first operand can be word or double word. |
bt ax,15 ; test bit in register |
bts word [bx],15 ; test and set bit in memory |
btr ax,cx ; test and reset bit in register |
btc word [bx],cx ; test and complement bit in memory |
"bsf" and "bsr" instructions scan a word or double word for first set bit |
and store the index of this bit into destination operand, which must be |
general register. The bit string being scanned is specified by source operand, |
it may be either general register or memory. The ZF flag is set if the entire |
string is zero (no set bits are found); otherwise it is cleared. If no set bit |
is found, the value of the destination register is undefined. "bsf" scans from |
low order to high order (starting from bit index zero). "bsr" scans from high |
order to low order (starting from bit index 15 of a word or index 31 of a |
double word). |
bsf ax,bx ; scan register forward |
bsr ax,[si] ; scan memory reverse |
"shl" shifts the destination operand left by the number of bits specified |
in the second operand. The destination operand can be byte, word, or double |
word general register or memory. The second operand can be an immediate value |
or the CL register. The processor shifts zeros in from the right (low order) |
side of the operand as bits exit from the left side. The last bit that exited |
is stored in CF. "sal" is a synonym for "shl". |
shl al,1 ; shift register left by one bit |
shl byte [bx],1 ; shift memory left by one bit |
shl ax,cl ; shift register left by count from cl |
shl word [bx],cl ; shift memory left by count from cl |
"shr" and "sar" shift the destination operand right by the number of bits |
specified in the second operand. Rules for operands are the same as for the |
"shl" instruction. "shr" shifts zeros in from the left side of the operand as |
bits exit from the right side. The last bit that exited is stored in CF. |
"sar" preserves the sign of the operand by shifting in zeros on the left side |
if the value is positive or by shifting in ones if the value is negative. |
"shld" shifts bits of the destination operand to the left by the number |
of bits specified in third operand, while shifting high order bits from the |
source operand into the destination operand on the right. The source operand |
remains unmodified. The destination operand can be a word or double word |
general register or memory, the source operand must be a general register, |
third operand can be an immediate value or the CL register. |
shld ax,bx,1 ; shift register left by one bit |
shld [di],bx,1 ; shift memory left by one bit |
shld ax,bx,cl ; shift register left by count from cl |
shld [di],bx,cl ; shift memory left by count from cl |
"shrd" shifts bits of the destination operand to the right, while shifting |
low order bits from the source operand into the destination operand on the |
left. The source operand remains unmodified. Rules for operands are the same |
as for the "shld" instruction. |
"rol" and "rcl" rotate the byte, word or double word destination operand |
left by the number of bits specified in the second operand. For each rotation |
specified, the high order bit that exits from the left of the operand returns |
at the right to become the new low order bit. "rcl" additionally puts in CF |
each high order bit that exits from the left side of the operand before it |
returns to the operand as the low order bit on the next rotation cycle. Rules |
for operands are the same as for the "shl" instruction. |
"ror" and "rcr" rotate the byte, word or double word destination operand |
right by the number of bits specified in the second operand. For each rotation |
specified, the low order bit that exits from the right of the operand returns |
at the left to become the new high order bit. "rcr" additionally puts in CF |
each low order bit that exits from the right side of the operand before it |
returns to the operand as the high order bit on the next rotation cycle. |
Rules for operands are the same as for the "shl" instruction. |
"test" performs the same action as the "and" instruction, but it does not |
alter the destination operand, only updates flags. Rules for the operands are |
the same as for the "and" instruction. |
"bswap" reverses the byte order of a 32-bit general register: bits 0 through |
7 are swapped with bits 24 through 31, and bits 8 through 15 are swapped with |
bits 16 through 23. This instruction is provided for converting little-endian |
values to big-endian format and vice versa. |
bswap edx ; swap bytes in register |
2.1.6 Control transfer instructions |
"jmp" unconditionally transfers control to the target location. The |
destination address can be specified directly within the instruction or |
indirectly through a register or memory, the acceptable size of this address |
depends on whether the jump is near or far (it can be specified by preceding |
the operand with "near" or "far" operator) and whether the instruction is |
16-bit or 32-bit. Operand for near jump should be "word" size for 16-bit |
instruction or the "dword" size for 32-bit instruction. Operand for far jump |
should be "dword" size for 16-bit instruction or "pword" size for 32-bit |
instruction. A direct "jmp" instruction includes the destination address as |
part of the instruction (and can be preceded by "short", "near" or "far" |
operator), the operand specifying address should be the numerical expression |
for near or short jump, or two numerical expressions separated with colon for |
far jump, the first specifies selector of segment, the second is the offset |
within segment. The "pword" operator can be used to force the 32-bit far call, |
and "dword" to force the 16-bit far call. An indirect "jmp" instruction |
obtains the destination address indirectly through a register or a pointer |
variable, the operand should be general register or memory. See also 1.2.5 for |
some more details. |
jmp 100h ; direct near jump |
jmp 0FFFFh:0 ; direct far jump |
jmp ax ; indirect near jump |
jmp pword [ebx] ; indirect far jump |
"call" transfers control to the procedure, saving on the stack the address |
of the instruction following the "call" for later use by a "ret" (return) |
instruction. Rules for the operands are the same as for the "jmp" instruction, |
but the "call" has no short variant of direct instruction and thus it not |
optimized. |
"ret", "retn" and "retf" instructions terminate the execution of a procedure |
and transfers control back to the program that originally invoked the |
procedure using the address that was stored on the stack by the "call" |
instruction. "ret" is the equivalent for "retn", which returns from the |
procedure that was executed using the near call, while "retf" returns from |
the procedure that was executed using the far call. These instructions default |
to the size of address appropriate for the current code setting, but the size |
of address can be forced to 16-bit by using the "retw", "retnw" and "retfw" |
mnemonics, and to 32-bit by using the "retd", "retnd" and "retfd" mnemonics. |
All these instructions may optionally specify an immediate operand, by adding |
this constant to the stack pointer, they effectively remove any arguments that |
the calling program pushed on the stack before the execution of the "call" |
instruction. |
"iret" returns control to an interrupted procedure. It differs from "ret" in |
that it also pops the flags from the stack into the flags register. The flags |
are stored on the stack by the interrupt mechanism. It defaults to the size of |
return address appropriate for the current code setting, but it can be forced |
to use 16-bit or 32-bit address by using the "iretw" or "iretd" mnemonic. |
The conditional transfer instructions are jumps that may or may not transfer |
control, depending on the state of the CPU flags when the instruction |
executes. The mnemonics for conditional jumps may be obtained by attaching |
the condition mnemonic (see table 2.1) to the "j" mnemonic, |
for example "jc" instruction will transfer the control when the CF flag is |
set. The conditional jumps can be short or near, and direct only, and can be |
optimized (see 1.2.5), the operand should be an immediate value specifying |
target address. |
Table 2.1 Conditions |
ÚÄÄÄÄÄÄÄÄÄÄÂÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÂÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿ |
³ Mnemonic ³ Condition tested ³ Description ³ |
ÆÍÍÍÍÍÍÍÍÍÍØÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍØÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ͵ |
³ o ³ OF = 1 ³ overflow ³ |
ÃÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´ |
³ no ³ OF = 0 ³ not overflow ³ |
ÃÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´ |
³ c ³ ³ carry ³ |
³ b ³ CF = 1 ³ below ³ |
³ nae ³ ³ not above nor equal ³ |
ÃÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´ |
³ nc ³ ³ not carry ³ |
³ ae ³ CF = 0 ³ above or equal ³ |
³ nb ³ ³ not below ³ |
ÃÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´ |
³ e ³ ZF = 1 ³ equal ³ |
³ z ³ ³ zero ³ |
ÃÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´ |
³ ne ³ ZF = 0 ³ not equal ³ |
³ nz ³ ³ not zero ³ |
ÃÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´ |
³ be ³ CF or ZF = 1 ³ below or equal ³ |
³ na ³ ³ not above ³ |
ÃÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´ |
³ a ³ CF or ZF = 0 ³ above ³ |
³ nbe ³ ³ not below nor equal ³ |
ÃÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´ |
³ s ³ SF = 1 ³ sign ³ |
ÃÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´ |
³ ns ³ SF = 0 ³ not sign ³ |
ÃÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´ |
³ p ³ PF = 1 ³ parity ³ |
³ pe ³ ³ parity even ³ |
ÃÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´ |
³ np ³ PF = 0 ³ not parity ³ |
³ po ³ ³ parity odd ³ |
ÃÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´ |
³ l ³ SF xor OF = 1 ³ less ³ |
³ nge ³ ³ not greater nor equal ³ |
ÃÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´ |
³ ge ³ SF xor OF = 0 ³ greater or equal ³ |
³ nl ³ ³ not less ³ |
ÃÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´ |
³ le ³ (SF xor OF) or ZF = 1 ³ less or equal ³ |
³ ng ³ ³ not greater ³ |
ÃÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ´ |
³ g ³ (SF xor OF) or ZF = 0 ³ greater ³ |
³ nle ³ ³ not less nor equal ³ |
ÀÄÄÄÄÄÄÄÄÄÄÁÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÁÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ |
The "loop" instructions are conditional jumps that use a value placed in |
CX (or ECX) to specify the number of repetitions of a software loop. All |
"loop" instructions automatically decrement CX (or ECX) and terminate the |
loop (don't transfer the control) when CX (or ECX) is zero. It uses CX or ECX |
whether the current code setting is 16-bit or 32-bit, but it can be forced to |
us CX with the "loopw" mnemonic or to use ECX with the "loopd" mnemonic. |
"loope" and "loopz" are the synonyms for the same instruction, which acts as |
the standard "loop", but also terminates the loop when ZF flag is set. |
"loopew" and "loopzw" mnemonics force them to use CX register while "looped" |
and "loopzd" force them to use ECX register. "loopne" and "loopnz" are the |
synonyms for the same instructions, which acts as the standard "loop", but |
also terminate the loop when ZF flag is not set. "loopnew" and "loopnzw" |
mnemonics force them to use CX register while "loopned" and "loopnzd" force |
them to use ECX register. Every "loop" instruction needs an operand being an |
immediate value specifying target address, it can be only short jump (in the |
range of 128 bytes back and 127 bytes forward from the address of instruction |
following the "loop" instruction). |
"jcxz" branches to the label specified in the instruction if it finds a |
value of zero in CX, "jecxz" does the same, but checks the value of ECX |
instead of CX. Rules for the operands are the same as for the "loop" |
instruction. |
"int" activates the interrupt service routine that corresponds to the |
number specified as an operand to the instruction, the number should be in |
range from 0 to 255. The interrupt service routine terminates with an "iret" |
instruction that returns control to the instruction that follows "int". |
"int3" mnemonic codes the short (one byte) trap that invokes the interrupt 3. |
"into" instruction invokes the interrupt 4 if the OF flag is set. |
"bound" verifies that the signed value contained in the specified register |
lies within specified limits. An interrupt 5 occurs if the value contained in |
the register is less than the lower bound or greater than the upper bound. It |
needs two operands, the first operand specifies the register being tested, |
the second operand should be memory address for the two signed limit values. |
The operands can be "word" or "dword" in size. |
bound ax,[bx] ; check word for bounds |
bound eax,[esi] ; check double word for bounds |
2.1.7 I/O instructions |
"in" transfers a byte, word, or double word from an input port to AL, AX, |
or EAX. I/O ports can be addressed either directly, with the immediate byte |
value coded in instruction, or indirectly via the DX register. The destination |
operand should be AL, AX, or EAX register. The source operand should be an |
immediate value in range from 0 to 255, or DX register. |
in al,20h ; input byte from port 20h |
in ax,dx ; input word from port addressed by dx |
"out" transfers a byte, word, or double word to an output port from AL, AX, |
or EAX. The program can specify the number of the port using the same methods |
as the "in" instruction. The destination operand should be an immediate value |
in range from 0 to 255, or DX register. The source operand should be AL, AX, |
or EAX register. |
out 20h,ax ; output word to port 20h |
out dx,al ; output byte to port addressed by dx |
2.1.8 Strings operations |
The string operations operate on one element of a string. A string element |
may be a byte, a word, or a double word. The string elements are addressed by |
SI and DI (or ESI and EDI) registers. After every string operation SI and/or |
DI (or ESI and/or EDI) are automatically updated to point to the next element |
of the string. If DF (direction flag) is zero, the index registers are |
incremented, if DF is one, they are decremented. The amount of the increment |
or decrement is 1, 2, or 4 depending on the size of the string element. Every |
string operation instruction has short forms which have no operands and use |
SI and/or DI when the code type is 16-bit, and ESI and/or EDI when the code |
type is 32-bit. SI and ESI by default address data in the segment selected |
by DS, DI and EDI always address data in the segment selected by ES. Short |
form is obtained by attaching to the mnemonic of string operation letter |
specifying the size of string element, it should be "b" for byte element, |
"w" for word element, and "d" for double word element. Full form of string |
operation needs operands providing the size operator and the memory addresses, |
which can be SI or ESI with any segment prefix, DI or EDI always with ES |
segment prefix. |
"movs" transfers the string element pointed to by SI (or ESI) to the |
location pointed to by DI (or EDI). Size of operands can be byte, word, or |
double word. The destination operand should be memory addressed by DI or EDI, |
the source operand should be memory addressed by SI or ESI with any segment |
prefix. |
movs byte [di],[si] ; transfer byte |
movs word [es:di],[ss:si] ; transfer word |
movsd ; transfer double word |
"cmps" subtracts the destination string element from the source string |
element and updates the flags AF, SF, PF, CF and OF, but it does not change |
any of the compared elements. If the string elements are equal, ZF is set, |
otherwise it is cleared. The first operand for this instruction should be the |
source string element addressed by SI or ESI with any segment prefix, the |
second operand should be the destination string element addressed by DI or |
EDI. |
cmpsb ; compare bytes |
cmps word [ds:si],[es:di] ; compare words |
cmps dword [fs:esi],[edi] ; compare double words |
"scas" subtracts the destination string element from AL, AX, or EAX |
(depending on the size of string element) and updates the flags AF, SF, ZF, |
PF, CF and OF. If the values are equal, ZF is set, otherwise it is cleared. |
The operand should be the destination string element addressed by DI or EDI. |
scas byte [es:di] ; scan byte |
scasw ; scan word |
scas dword [es:edi] ; scan double word |
"stos" places the value of AL, AX, or EAX into the destination string |
element. Rules for the operand are the same as for the "scas" instruction. |
"lods" places the source string element into AL, AX, or EAX. The operand |
should be the source string element addressed by SI or ESI with any segment |
prefix. |
lods byte [ds:si] ; load byte |
lods word [cs:si] ; load word |
lodsd ; load double word |
"ins" transfers a byte, word, or double word from an input port addressed |
by DX register to the destination string element. The destination operand |
should be memory addressed by DI or EDI, the source operand should be the DX |
register. |
insb ; input byte |
ins word [es:di],dx ; input word |
ins dword [edi],dx ; input double word |
"outs" transfers the source string element to an output port addressed by |
DX register. The destination operand should be the DX register and the source |
operand should be memory addressed by SI or ESI with any segment prefix. |
outs dx,byte [si] ; output byte |
outsw ; output word |
outs dx,dword [gs:esi] ; output double word |
The repeat prefixes "rep", "repe"/"repz", and "repne"/"repnz" specify |
repeated string operation. When a string operation instruction has a repeat |
prefix, the operation is executed repeatedly, each time using a different |
element of the string. The repetition terminates when one of the conditions |
specified by the prefix is satisfied. All three prefixes automatically |
decrease CX or ECX register (depending whether string operation instruction |
uses the 16-bit or 32-bit addressing) after each operation and repeat the |
associated operation until CX or ECX is zero. "repe"/"repz" and |
"repne"/"repnz" are used exclusively with the "scas" and "cmps" instructions |
(described below). When these prefixes are used, repetition of the next |
instruction depends on the zero flag (ZF) also, "repe" and "repz" terminate |
the execution when the ZF is zero, "repne" and "repnz" terminate the execution |
when the ZF is set. |
rep movsd ; transfer multiple double words |
repe cmpsb ; compare bytes until not equal |
2.1.9 Flag control instructions |
The flag control instructions provide a method for directly changing the |
state of bits in the flag register. All instructions described in this |
section have no operands. |
"stc" sets the CF (carry flag) to 1, "clc" zeroes the CF, "cmc" changes the |
CF to its complement. "std" sets the DF (direction flag) to 1, "cld" zeroes |
the DF, "sti" sets the IF (interrupt flag) to 1 and therefore enables the |
interrupts, "cli" zeroes the IF and therefore disables the interrupts. |
"lahf" copies SF, ZF, AF, PF, and CF to bits 7, 6, 4, 2, and 0 of the |
AH register. The contents of the remaining bits are undefined. The flags |
remain unaffected. |
"sahf" transfers bits 7, 6, 4, 2, and 0 from the AH register into SF, ZF, |
AF, PF, and CF. |
"pushf" decrements "esp" by two or four and stores the low word or |
double word of flags register at the top of stack, size of stored data |
depends on the current code setting. "pushfw" variant forces storing the |
word and "pushfd" forces storing the double word. |
"popf" transfers specific bits from the word or double word at the top |
of stack, then increments "esp" by two or four, this value depends on |
the current code setting. "popfw" variant forces restoring from the word |
and "popfd" forces restoring from the double word. |
2.1.10 Conditional operations |
The instructions obtained by attaching the condition mnemonic (see table |
2.1) to the "set" mnemonic set a byte to one if the condition is true and set |
the byte to zero otherwise. The operand should be an 8-bit be general register |
or the byte in memory. |
setne al ; set al if zero flag cleared |
seto byte [bx] ; set byte if overflow |
"salc" instruction sets the all bits of AL register when the carry flag is |
set and zeroes the AL register otherwise. This instruction has no arguments. |
The instructions obtained by attaching the condition mnemonic to the "cmov" |
mnemonic transfer the word or double word from the general register or memory |
to the general register only when the condition is true. The destination |
operand should be general register, the source operand can be general register |
or memory. |
cmove ax,bx ; move when zero flag set |
cmovnc eax,[ebx] ; move when carry flag cleared |
"cmpxchg" compares the value in the AL, AX, or EAX register with the |
destination operand. If the two values are equal, the source operand is |
loaded into the destination operand. Otherwise, the destination operand is |
loaded into the AL, AX, or EAX register. The destination operand may be a |
general register or memory, the source operand must be a general register. |
cmpxchg dl,bl ; compare and exchange with register |
cmpxchg [bx],dx ; compare and exchange with memory |
"cmpxchg8b" compares the 64-bit value in EDX and EAX registers with the |
destination operand. If the values are equal, the 64-bit value in ECX and EBX |
registers is stored in the destination operand. Otherwise, the value in the |
destination operand is loaded into EDX and EAX registers. The destination |
operand should be a quad word in memory. |
cmpxchg8b [bx] ; compare and exchange 8 bytes |
2.1.11 Miscellaneous instructions |
"nop" instruction occupies one byte but affects nothing but the instruction |
pointer. This instruction has no operands and doesn't perform any operation. |
"ud2" instruction generates an invalid opcode exception. This instruction |
is provided for software testing to explicitly generate an invalid opcode. |
This is instruction has no operands. |
"xlat" replaces a byte in the AL register with a byte indexed by its value |
in a translation table addressed by BX or EBX. The operand should be a byte |
memory addressed by BX or EBX with any segment prefix. This instruction has |
also a short form "xlatb" which has no operands and uses the BX or EBX address |
in the segment selected by DS depending on the current code setting. |
"lds" transfers a pointer variable from the source operand to DS and the |
destination register. The source operand must be a memory operand, and the |
destination operand must be a general register. The DS register receives the |
segment selector of the pointer while the destination register receives the |
offset part of the pointer. "les", "lfs", "lgs" and "lss" operate identically |
to "lds" except that rather than DS register the ES, FS, GS and SS is used |
respectively. |
lds bx,[si] ; load pointer to ds:bx |
"lea" transfers the offset of the source operand (rather than its value) |
to the destination operand. The source operand must be a memory operand, and |
the destination operand must be a general register. |
lea dx,[bx+si+1] ; load effective address to dx |
"cpuid" returns processor identification and feature information in the |
EAX, EBX, ECX, and EDX registers. The information returned is selected by |
entering a value in the EAX register before the instruction is executed. |
This instruction has no operands. |
"pause" instruction delays the execution of the next instruction an |
implementation specific amount of time. It can be used to improve the |
performance of spin wait loops. This instruction has no operands. |
"enter" creates a stack frame that may be used to implement the scope rules |
of block-structured high-level languages. A "leave" instruction at the end of |
a procedure complements an "enter" at the beginning of the procedure to |
simplify stack management and to control access to variables for nested |
procedures. The "enter" instruction includes two parameters. The first |
parameter specifies the number of bytes of dynamic storage to be allocated on |
the stack for the routine being entered. The second parameter corresponds to |
the lexical nesting level of the routine, it can be in range from 0 to 31. |
The specified lexical level determines how many sets of stack frame pointers |
the CPU copies into the new stack frame from the preceding frame. This list |
of stack frame pointers is sometimes called the display. The first word (or |
double word when code is 32-bit) of the display is a pointer to the last stack |
frame. This pointer enables a "leave" instruction to reverse the action of the |
previous "enter" instruction by effectively discarding the last stack frame. |
After "enter" creates the new display for a procedure, it allocates the |
dynamic storage space for that procedure by decrementing ESP by the number of |
bytes specified in the first parameter. To enable a procedure to address its |
display, "enter" leaves BP (or EBP) pointing to the beginning of the new stack |
frame. If the lexical level is zero, "enter" pushes BP (or EBP), copies SP to |
BP (or ESP to EBP) and then subtracts the first operand from ESP. For nesting |
levels greater than zero, the processor pushes additional frame pointers on |
the stack before adjusting the stack pointer. |
enter 2048,0 ; enter and allocate 2048 bytes on stack |
2.1.12 System instructions |
"lmsw" loads the operand into the machine status word (bits 0 through 15 of |
CR0 register), while "smsw" stores the machine status word into the |
destination operand. The operand for both those instructions can be 16-bit |
general register or memory, for "smsw" it can also be 32-bit general |
register. |
lmsw ax ; load machine status from register |
smsw [bx] ; store machine status to memory |
"lgdt" and "lidt" instructions load the values in operand into the global |
descriptor table register or the interrupt descriptor table register |
respectively. "sgdt" and "sidt" store the contents of the global descriptor |
table register or the interrupt descriptor table register in the destination |
operand. The operand should be a 6 bytes in memory. |
lgdt [ebx] ; load global descriptor table |
"lldt" loads the operand into the segment selector field of the local |
descriptor table register and "sldt" stores the segment selector from the |
local descriptor table register in the operand. "ltr" loads the operand into |
the segment selector field of the task register and "str" stores the segment |
selector from the task register in the operand. Rules for operand are the same |
as for the "lmsw" and "smsw" instructions. |
"lar" loads the access rights from the segment descriptor specified by |
the selector in source operand into the destination operand and sets the ZF |
flag. The destination operand can be a 16-bit or 32-bit general register. |
The source operand should be a 16-bit general register or memory. |
lar ax,[bx] ; load access rights into word |
lar eax,dx ; load access rights into double word |
"lsl" loads the segment limit from the segment descriptor specified by the |
selector in source operand into the destination operand and sets the ZF flag. |
Rules for operand are the same as for the "lar" instruction. |
"verr" and "verw" verify whether the code or data segment specified with |
the operand is readable or writable from the current privilege level. The |
operand should be a word, it can be general register or memory. If the segment |
is accessible and readable (for "verr") or writable (for "verw") the ZF flag |
is set, otherwise it's cleared. Rules for operand are the same as for the |
"lldt" instruction. |
"arpl" compares the RPL (requestor's privilege level) fields of two segment |
selectors. The first operand contains one segment selector and the second |
operand contains the other. If the RPL field of the destination operand is |
less than the RPL field of the source operand, the ZF flag is set and the RPL |
field of the destination operand is increased to match that of the source |
operand. Otherwise, the ZF flag is cleared and no change is made to the |
destination operand. The destination operand can be a word general register |
or memory, the source operand must be a general register. |
arpl bx,ax ; adjust RPL of selector in register |
arpl [bx],ax ; adjust RPL of selector in memory |
"clts" clears the TS (task switched) flag in the CR0 register. This |
instruction has no operands. |
"lock" prefix causes the processor's bus-lock signal to be asserted during |
execution of the accompanying instruction. In a multiprocessor environment, |
the bus-lock signal insures that the processor has exclusive use of any shared |
memory while the signal is asserted. The "lock" prefix can be prepended only |
to the following instructions and only to those forms of the instructions |
where the destination operand is a memory operand: "add", "adc", "and", "btc", |
"btr", "bts", "cmpxchg", "cmpxchg8b", "dec", "inc", "neg", "not", "or", "sbb", |
"sub", "xor", "xadd" and "xchg". If the "lock" prefix is used with one of |
these instructions and the source operand is a memory operand, an undefined |
opcode exception may be generated. An undefined opcode exception will also be |
generated if the "lock" prefix is used with any instruction not in the above |
list. The "xchg" instruction always asserts the bus-lock signal regardless of |
the presence or absence of the "lock" prefix. |
"hlt" stops instruction execution and places the processor in a halted |
state. An enabled interrupt, a debug exception, the BINIT, INIT or the RESET |
signal will resume execution. This instruction has no operands. |
"invlpg" invalidates (flushes) the TLB (translation lookaside buffer) entry |
specified with the operand, which should be a memory. The processor determines |
the page that contains that address and flushes the TLB entry for that page. |
"rdmsr" loads the contents of a 64-bit MSR (model specific register) of the |
address specified in the ECX register into registers EDX and EAX. "wrmsr" |
writes the contents of registers EDX and EAX into the 64-bit MSR of the |
address specified in the ECX register. "rdtsc" loads the current value of the |
processor's time stamp counter from the 64-bit MSR into the EDX and EAX |
registers. The processor increments the time stamp counter MSR every clock |
cycle and resets it to 0 whenever the processor is reset. "rdpmc" loads the |
contents of the 40-bit performance monitoring counter specified in the ECX |
register into registers EDX and EAX. These instructions have no operands. |
"wbinvd" writes back all modified cache lines in the processor's internal |
cache to main memory and invalidates (flushes) the internal caches. The |
instruction then issues a special function bus cycle that directs external |
caches to also write back modified data and another bus cycle to indicate that |
the external caches should be invalidated. This instruction has no operands. |
"rsm" return program control from the system management mode to the program |
that was interrupted when the processor received an SMM interrupt. This |
instruction has no operands. |
"sysenter" executes a fast call to a level 0 system procedure, "sysexit" |
executes a fast return to level 3 user code. The addresses used by these |
instructions are stored in MSRs. These instructions have no operands. |
2.1.13 FPU instructions |
The FPU (Floating-Point Unit) instructions operate on the floating-point |
values in three formats: single precision (32-bit), double precision (64-bit) |
and double extended precision (80-bit). The FPU registers form the stack and |
each of them holds the double extended precision floating-point value. When |
some values are pushed onto the stack or are removed from the top, the FPU |
registers are shifted, so ST0 is always the value on the top of FPU stack, ST1 |
is the first value below the top, etc. The ST0 name has also the synonym ST. |
"fld" pushes the floating-point value onto the FPU register stack. The |
operand can be 32-bit, 64-bit or 80-bit memory location or the FPU register, |
its value is then loaded onto the top of FPU register stack (the ST0 |
register) and is automatically converted into the double extended precision |
format. |
fld dword [bx] ; load single prevision value from memory |
fld st2 ; push value of st2 onto register stack |
"fld1", "fldz", "fldl2t", "fldl2e", "fldpi", "fldlg2" and "fldln2" load the |
commonly used contants onto the FPU register stack. The loaded constants are |
+1.0, +0.0, lb 10, lb e, pi, lg 2 and ln 2 respectively. These instructions |
have no operands. |
"fild" convert the singed integer source operand into double extended |
precision floating-point format and pushes the result onto the FPU register |
stack. The source operand can be a 16-bit, 32-bit or 64-bit memory location. |
fild qword [bx] ; load 64-bit integer from memory |
"fst" copies the value of ST0 register to the destination operand, which |
can be 32-bit or 64-bit memory location or another FPU register. "fstp" |
performs the same operation as "fst" and then pops the register stack, |
getting rid of ST0. "fstp" accepts the same operands as the "fst" instruction |
and can also store value in the 80-bit memory. |
fst st3 ; copy value of st0 into st3 register |
fstp tword [bx] ; store value in memory and pop stack |
"fist" converts the value in ST0 to a signed integer and stores the result |
in the destination operand. The operand can be 16-bit or 32-bit memory |
location. "fistp" performs the same operation and then pops the register |
stack, it accepts the same operands as the "fist" instruction and can also |
store integer value in the 64-bit memory, so it has the same rules for |
operands as "fild" instruction. |
"fbld" converts the packed BCD integer into double extended precision |
floating-point format and pushes this value onto the FPU stack. "fbstp" |
converts the value in ST0 to an 18-digit packed BCD integer, stores the result |
in the destination operand, and pops the register stack. The operand should be |
an 80-bit memory location. |
"fadd" adds the destination and source operand and stores the sum in the |
destination location. The destination operand is always an FPU register, if |
the source is a memory location, the destination is ST0 register and only |
source operand should be specified. If both operands are FPU registers, at |
least one of them should be ST0 register. An operand in memory can be a |
32-bit or 64-bit value. |
fadd qword [bx] ; add double precision value to st0 |
fadd st2,st0 ; add st0 to st2 |
"faddp" adds the destination and source operand, stores the sum in the |
destination location and then pops the register stack. The destination operand |
must be an FPU register and the source operand must be the ST0. When no |
operands are specified, ST1 is used as a destination operand. |
faddp ; add st0 to st1 and pop the stack |
faddp st2,st0 ; add st0 to st2 and pop the stack |
"fiadd" instruction converts an integer source operand into double extended |
precision floating-point value and adds it to the destination operand. The |
operand should be a 16-bit or 32-bit memory location. |
fiadd word [bx] ; add word integer to st0 |
"fsub", "fsubr", "fmul", "fdiv", "fdivr" instruction are similar to "fadd", |
have the same rules for operands and differ only in the perfomed computation. |
"fsub" substracts the source operand from the destination operand, "fsubr" |
substract the destination operand from the source operand, "fmul" multiplies |
the destination and source operands, "fdiv" divides the destination operand by |
the source operand and "fdivr" divides the source operand by the destination |
operand. "fsubp", "fsubrp", "fmulp", "fdivp", "fdivrp" perform the same |
operations and pop the register stack, the rules for operand are the same as |
for the "faddp" instruction. "fisub", "fisubr", "fimul", "fidiv", "fidivr" |
perform these operations after converting the integer source operand into |
floating-point value, they have the same rules for operands as "fiadd" |
instruction. |
"fsqrt" computes the square root of the value in ST0 register, "fsin" |
computes the sine of that value, "fcos" computes the cosine of that value, |
"fchs" complements its sign bit, "fabs" clears its sign to create the absolute |
value, "frndint" rounds it to the nearest integral value, depending on the |
current rounding mode. "f2xm1" computes the exponential value of 2 to the |
power of ST0 and substracts the 1.0 from it, the value of ST0 must lie in the |
range -1.0 to +1.0. All these instruction store the result in ST0 and have no |
operands. |
"fsincos" computes both the sine and the cosine of the value in ST0 |
register, stores the sine in ST0 and pushes the cosine on the top of FPU |
register stack. "fptan" computes the tangent of the value in ST0, stores the |
result in ST0 and pushes a 1.0 onto the FPU register stack. "fpatan" computes |
the arctangent of the value in ST1 divided by the value in ST0, stores the |
result in ST1 and pops the FPU register stack. "fyl2x" computes the binary |
logarithm of ST0, multiplies it by ST1, stores the result in ST1 and pops the |
FPU register stack; "fyl2xp1" performs the same operation but it adds 1.0 to |
ST0 before computing the logarithm. "fprem" computes the remainder obtained |
from dividing the value in ST0 by the value in ST1, and stores the result |
in ST0. "fprem1" performs the same operation as "fprem", but it computes the |
remainder in the way specified by IEEE Standard 754. "fscale" truncates the |
value in ST1 and increases the exponent of ST0 by this value. "fxtract" |
separates the value in ST0 into its exponent and significand, stores the |
exponent in ST0 and pushes the significand onto the register stack. "fnop" |
performs no operation. These instruction have no operands. |
"fxch" exchanges the contents of ST0 an another FPU register. The operand |
should be an FPU register, if no operand is specified, the contents of ST0 and |
ST1 are exchanged. |
"fcom" and "fcomp" compare the contents of ST0 and the source operand and |
set flags in the FPU status word according to the results. "fcomp" |
additionally pops the register stack after performing the comparison. The |
operand can be a single or double precision value in memory or the FPU |
register. When no operand is specified, ST1 is used as a source operand. |
fcom ; compare st0 with st1 |
fcomp st2 ; compare st0 with st2 and pop stack |
"fcompp" compares the contents of ST0 and ST1, sets flags in the FPU status |
word according to the results and pops the register stack twice. This |
instruction has no operands. |
"fucom", "fucomp" and "fucompp" performs an unordered comparison of two FPU |
registers. Rules for operands are the same as for the "fcom", "fcomp" and |
"fcompp", but the source operand must be an FPU register. |
"ficom" and "ficomp" compare the value in ST0 with an integer source operand |
and set the flags in the FPU status word according to the results. "ficomp" |
additionally pops the register stack after performing the comparison. The |
integer value is converted to double extended precision floating-point format |
before the comparison is made. The operand should be a 16-bit or 32-bit |
memory location. |
ficom word [bx] ; compare st0 with 16-bit integer |
"fcomi", "fcomip", "fucomi", "fucomip" perform the comparison of ST0 with |
another FPU register and set the ZF, PF and CF flags according to the results. |
"fcomip" and "fucomip" additionaly pop the register stack after performing the |
comparison. The instructions obtained by attaching the FPU condition mnemonic |
(see table 2.2) to the "fcmov" mnemonic transfer the specified FPU register |
into ST0 register if the fiven test condition is true. These instruction |
allow two different syntaxes, one with single operand specifying the source |
FPU register, and one with two operands, in that case destination operand |
should be ST0 register and the second operand specifies the source FPU |
register. |
fcomi st2 ; compare st0 with st2 and set flags |
fcmovb st0,st2 ; transfer st2 to st0 if below |
Table 2.2 FPU conditions |
ÚÄÄÄÄÄÄÄÄÄÄÂÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÂÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿ |
³ Mnemonic ³ Condition tested ³ Description ³ |
ÆÍÍÍÍÍÍÍÍÍÍØÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍØÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ͵ |
³ b ³ CF = 1 ³ below ³ |
³ e ³ ZF = 1 ³ equal ³ |
³ be ³ CF or ZF = 1 ³ below or equal ³ |
³ u ³ PF = 1 ³ unordered ³ |
³ nb ³ CF = 0 ³ not below ³ |
³ ne ³ ZF = 0 ³ not equal ³ |
³ nbe ³ CF and ZF = 0 ³ not below nor equal ³ |
³ nu ³ PF = 0 ³ not unordered ³ |
ÀÄÄÄÄÄÄÄÄÄÄÁÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÁÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ |
"ftst" compares the value in ST0 with 0.0 and sets the flags in the FPU |
status word according to the results. "fxam" examines the contents of the ST0 |
and sets the flags in FPU status word to indicate the class of value in the |
register. These instructions have no operands. |
"fstsw" and "fnstsw" store the current value of the FPU status word in the |
destination location. The destination operand can be either a 16-bit memory or |
the AX register. "fstsw" checks for pending umasked FPU exceptions before |
storing the status word, "fnstsw" does not. |
"fstcw" and "fnstcw" store the current value of the FPU control word at the |
specified destination in memory. "fstcw" checks for pending umasked FPU |
exceptions before storing the control word, "fnstcw" does not. "fldcw" loads |
the operand into the FPU control word. The operand should be a 16-bit memory |
location. |
"fstenv" and "fnstenv" store the current FPU operating environment at the |
memory location specified with the destination operand, and then mask all FPU |
exceptions. "fstenv" checks for pending umasked FPU exceptions before |
proceeding, "fnstenv" does not. "fldenv" loads the complete operating |
environment from memory into the FPU. "fsave" and "fnsave" store the current |
FPU state (operating environment and register stack) at the specified |
destination in memory and reinitializes the FPU. "fsave" check for pending |
unmasked FPU exceptions before proceeding, "fnsave" does not. "frstor" |
loads the FPU state from the specified memory location. All these instructions |
need an operand being a memory location. |
"finit" and "fninit" set the FPU operating environment into its default |
state. "finit" checks for pending unmasked FPU exception before proceeding, |
"fninit" does not. "fclex" and "fnclex" clear the FPU exception flags in the |
FPU status word. "fclex" checks for pending unmasked FPU exception before |
proceeding, "fnclex" does not. "wait" and "fwait" are synonyms for the same |
instruction, which causes the processor to check for pending unmasked FPU |
exceptions and handle them before proceeding. These instruction have no |
operands. |
"ffree" sets the tag associated with specified FPU register to empty. The |
operand should be an FPU register. |
"fincstp" and "fdecstp" rotate the FPU stack by one by adding or |
substracting one to the pointer of the top of stack. These instruction have no |
operands. |
2.1.14 MMX instructions |
The MMX instructions operate on the packed integer types and use the MMX |
registers, which are the low 64-bit parts of the 80-bit FPU registers. Because |
of this MMX instructions cannot be used at the same time as FPU instructions. |
They can operate on packed bytes (eight 8-bit integers), packed words (four |
16-bit integers) or packed double words (two 32-bit integers), use of packed |
formats allows to perform operations on multiple data at one time. |
"movq" copies a quad word from the source operand to the destination |
operand. At least one of the operands must be a MMX register, the second one |
can be also a MMX register or 64-bit memory location. |
movq mm0,mm1 ; move quad word from register to register |
movq mm2,[ebx] ; move quad word from memory to register |
"movd" copies a double word from the source operand to the destination |
operand. One of the operands must be a MMX register, the second one can be a |
general register or 32-bit memory location. Only low double word of MMX |
register is used. |
All general MMX operations have two operands, the destination operand should |
be a MMX register, the source operand can be a MMX register or 64-bit memory |
location. Operation is performed on the corresponding data elements of the |
source and destination operand and stored in the data elements of the |
destination operand. "paddb", "paddw" and "paddd" perform the addition of |
packed bytes, packed words, or packed double words. "psubb", "psubw" and |
"psubd" perform the substraction of appropriate types. "paddsb", "paddsw", |
"psubsb" and "psubsw" perform the addition or substraction of packed bytes |
or packed words with the signed saturation. "paddusb", "paddusw", "psubusb", |
"psubusw" are analoguous, but with unsigned saturation. "pmulhw" and "pmullw" |
performs a signed multiply of the packed words and store the high or low words |
of the results in the destination operand. "pmaddwd" performs a multiply of |
the packed words and adds the four intermediate double word products in pairs |
to produce result as a packed double words. "pand", "por" and "pxor" perform |
the logical operations on the quad words, "pandn" peforms also a logical |
negation of the destination operand before performing the "and" operation. |
"pcmpeqb", "pcmpeqw" and "pcmpeqd" compare for equality of packed bytes, |
packed words or packed double words. If a pair of data elements is equal, the |
corresponding data element in the destination operand is filled with bits of |
value 1, otherwise it's set to 0. "pcmpgtb", "pcmpgtw" and "pcmpgtd" perform |
the similar operation, but they check whether the data elements in the |
destination operand are greater than the correspoding data elements in the |
source operand. "packsswb" converts packed signed words into packed signed |
bytes, "packssdw" converts packed signed double words into packed signed |
words, using saturation to handle overflow conditions. "packuswb" converts |
packed signed words into packed unsigned bytes. Converted data elements from |
the source operand are stored in the low part of the destination operand, |
while converted data elements from the destination operand are stored in the |
high part. "punpckhbw", "punpckhwd" and "punpckhdq" interleaves the data |
elements from the high parts of the source and destination operands and |
stores the result into the destination operand. "punpcklbw", "punpcklwd" and |
"punpckldq" perform the same operation, but the low parts of the source and |
destination operand are used. |
paddsb mm0,[esi] ; add packed bytes with signed saturation |
pcmpeqw mm3,mm7 ; compare packed words for equality |
"psllw", "pslld" and "psllq" perform logical shift left of the packed words, |
packed double words or a single quad word in the destination operand by the |
amount specified in the source operand. "psrlw", "psrld" and "psrlq" perform |
logical shift right of the packed words, packed double words or a single quad |
word. "psraw" and "psrad" perform arithmetic shift of the packed words or |
double words. The destination operand should be a MMX register, while source |
operand can be a MMX register, 64-bit memory location, or 8-bit immediate |
value. |
psllw mm2,mm4 ; shift words left logically |
psrad mm4,[ebx] ; shift double words right arithmetically |
"emms" makes the FPU registers usable for the FPU instructions, it must be |
used before using the FPU instructions if any MMX instructions were used. |
2.1.15 SSE instructions |
The SSE extension adds more MMX instructions and also introduces the |
operations on packed single precision floating point values. The 128-bit |
packed single precision format consists of four single precision floating |
point values. The 128-bit SSE registers are designed for the purpose of |
operations on this data type. |
"movaps" and "movups" transfer a double quad word operand containing packed |
single precision values from source operand to destination operand. At least |
one of the operands have to be a SSE register, the second one can be also a |
SSE register or 128-bit memory location. Memory operands for "movaps" |
instruction must be aligned on boundary of 16 bytes, operands for "movups" |
instruction don't have to be aligned. |
movups xmm0,[ebx] ; move unaligned double quad word |
"movlps" moves packed two single precision values between the memory and the |
low quad word of SSE register. "movhps" moved packed two single precision |
values between the memory and the high quad word of SSE register. One of the |
operands must be a SSE register, and the other operand must be a 64-bit memory |
location. |
movlps xmm0,[ebx] ; move memory to low quad word of xmm0 |
movhps [esi],xmm7 ; move high quad word of xmm7 to memory |
"movlhps" moves packed two single precision values from the low quad word |
of source register to the high quad word of destination register. "movhlps" |
moves two packed single precision values from the high quad word of source |
register to the low quad word of destination register. Both operands have to |
be a SSE registers. |
"movmskps" transfers the most significant bit of each of the four single |
precision values in the SSE register into low four bits of a general register. |
The source operand must be a SSE register, the destination operand must be a |
general register. |
"movss" transfers a single precision value between source and destination |
operand (only the low double word is trasferred). At least one of the operands |
have to be a SSE register, the second one can be also a SSE register or 32-bit |
memory location. |
movss [edi],xmm3 ; move low double word of xmm3 to memory |
Each of the SSE arithmetic operations has two variants. When the mnemonic |
ends with "ps", the source operand can be a 128-bit memory location or a SSE |
register, the destination operand must be a SSE register and the operation is |
performed on packed four single precision values, for each pair of the |
corresponding data elements separately, the result is stored in the |
destination register. When the mnemonic ends with "ss", the source operand |
can be a 32-bit memory location or a SSE register, the destination operand |
must be a SSE register and the operation is performed on single precision |
values, only low double words of SSE registers are used in this case, the |
result is stored in the low double word of destination register. "addps" and |
"addss" add the values, "subps" and "subss" substract the source value from |
destination value, "mulps" and "mulss" multiply the values, "divps" and |
"divss" divide the destination value by the source value, "rcpps" and "rcpss" |
compute the approximate reciprocal of the source value, "sqrtps" and "sqrtss" |
compute the square root of the source value, "rsqrtps" and "rsqrtss" compute |
the approximate reciprocal of square root of the source value, "maxps" and |
"maxss" compare the source and destination values and return the greater one, |
"minps" and "minss" compare the source and destination values and return the |
lesser one. |
mulss xmm0,[ebx] ; multiply single precision values |
addps xmm3,xmm7 ; add packed single precision values |
"andps", "andnps", "orps" and "xorps" perform the logical operations on |
packed single precision values. The source operand can be a 128-bit memory |
location or a SSE register, the destination operand must be a SSE register. |
"cmpps" compares packed single precision values and returns a mask result |
into the destination operand, which must be a SSE register. The source operand |
can be a 128-bit memory location or SSE register, the third operand must be an |
immediate operand selecting code of one of the eight compare conditions |
(table 2.3). "cmpss" performs the same operation on single precision values, |
only low double word of destination register is affected, in this case source |
operand can be a 32-bit memory location or SSE register. These two |
instructions have also variants with only two operands and the condition |
encoded within mnemonic. Their mnemonics are obtained by attaching the |
mnemonic from table 2.3 to the "cmp" mnemonic and then attaching the "ps" or |
"ss" at the end. |
cmpps xmm2,xmm4,0 ; compare packed single precision values |
cmpltss xmm0,[ebx] ; compare single precision values |
Table 2.3 SSE conditions |
ÚÄÄÄÄÄÄÂÄÄÄÄÄÄÄÄÄÄÂÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿ |
³ Code ³ Mnemonic ³ Description ³ |
ÆÍÍÍÍÍÍØÍÍÍÍÍÍÍÍÍÍØÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ͵ |
³ 0 ³ eq ³ equal ³ |
³ 1 ³ lt ³ less than ³ |
³ 2 ³ le ³ less than or equal ³ |
³ 3 ³ unord ³ unordered ³ |
³ 4 ³ neq ³ not equal ³ |
³ 5 ³ nlt ³ not less than ³ |
³ 6 ³ nle ³ not less than nor equal ³ |
³ 7 ³ ord ³ ordered ³ |
ÀÄÄÄÄÄÄÁÄÄÄÄÄÄÄÄÄÄÁÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ |
"comiss" and "ucomiss" compare the single precision values and set the ZF, |
PF and CF flags to show the result. The destination operand must be a SSE |
register, the source operand can be a 32-bit memory location or SSE register. |
"shufps" moves any two of the four single precision values from the |
destination operand into the low quad word of the destination operand, and any |
two of the four values from the source operand into the high quad word of the |
destination operand. The destination operand must be a SSE register, the |
source operand can be a 128-bit memory location or SSE register, the third |
operand must be an 8-bit immediate value selecting which values will be moved |
into the destination operand. Bits 0 and 1 select the value to be moved from |
destination operand to the low double word of the result, bits 2 and 3 select |
the value to be moved from the destination operand to the second double word, |
bits 4 and 5 select the value to be moved from the source operand to the third |
double word, and bits 6 and 7 select the value to be moved from the source |
operand to the high double word of the result. |
shufps xmm0,xmm0,10010011b ; shuffle double words |
"unpckhps" performs an interleaved unpack of the values from the high parts |
of the source and destination operands and stores the result in the |
destination operand, which must be a SSE register. The source operand can be |
a 128-bit memory location or a SSE register. "unpcklps" performs an |
interleaved unpack of the values from the low parts of the source and |
destination operand and stores the result in the destination operand, |
the rules for operands are the same. |
"cvtpi2ps" converts packed two double word integers into the the packed two |
single precision floating point values and stores the result in the low quad |
word of the destination operand, which should be a SSE register. The source |
operand can be a 64-bit memory location or MMX register. |
cvtpi2ps xmm0,mm0 ; convert integers to single precision values |
"cvtsi2ss" converts a double word integer into a single precision floating |
point value and stores the result in the low double word of the destination |
operand, which should be a SSE register. The source operand can be a 32-bit |
memory location or 32-bit general register. |
cvtsi2ss xmm0,eax ; convert integer to single precision value |
"cvtps2pi" converts packed two single precision floating point values into |
packed two double word integers and stores the result in the destination |
operand, which should be a MMX register. The source operand can be a 64-bit |
memory location or SSE register, only low quad word of SSE register is used. |
"cvttps2pi" performs the similar operation, except that truncation is used to |
round a source values to integers, rules for the operands are the same. |
cvtps2pi mm0,xmm0 ; convert single precision values to integers |
"cvtss2si" convert a single precision floating point value into a double |
word integer and stores the result in the destination operand, which should be |
a 32-bit general register. The source operand can be a 32-bit memory location |
or SSE register, only low double word of SSE register is used. "cvttss2si" |
performs the similar operation, except that truncation is used to round a |
source value to integer, rules for the operands are the same. |
cvtss2si eax,xmm0 ; convert single precision value to integer |
"pextrw" copies the word in the source operand specified by the third |
operand to the destination operand. The source operand must be a MMX register, |
the destination operand must be a 32-bit general register (but only the low |
word of it is affected), the third operand must an 8-bit immediate value. |
pextrw eax,mm0,1 ; extract word into eax |
"pinsrw" inserts a word from the source operand in the destination operand |
at the location specified with the third operand, which must be an 8-bit |
immediate value. The destination operand must be a MMX register, the source |
operand can be a 16-bit memory location or 32-bit general register (only low |
word of the register is used). |
pinsrw mm1,ebx,2 ; insert word from ebx |
"pavgb" and "pavgw" compute average of packed bytes or words. "pmaxub" |
return the maximum values of packed unsigned bytes, "pminub" returns the |
minimum values of packed unsigned bytes, "pmaxsw" returns the maximum values |
of packed signed words, "pminsw" returns the minimum values of packed signed |
words. "pmulhuw" performs a unsigned multiply of the packed words and stores |
the high words of the results in the destination operand. "psadbw" computes |
the absolute differences of packed unsigned bytes, sums the differences, and |
stores the sum in the low word of destination operand. All these instructions |
follow the same rules for operands as the general MMX operations described in |
previous section. |
"pmovmskb" creates a mask made of the most significant bit of each byte in |
the source operand and stores the result in the low byte of destination |
operand. The source operand must be a MMX register, the destination operand |
must a 32-bit general register. |
"pshufw" inserts words from the source operand in the destination operand |
from the locations specified with the third operand. The destination operand |
must be a MMX register, the source operand can be a 64-bit memory location or |
MMX register, third operand must an 8-bit immediate value selecting which |
values will be moved into destination operand, in the similar way as the third |
operand of the "shufps" instruction. |
"movntq" moves the quad word from the source operand to memory using a |
non-temporal hint to minimize cache pollution. The source operand should be a |
MMX register, the destination operand should be a 64-bit memory location. |
"movntps" stores packed single precision values from the SSE register to |
memory using a non-temporal hint. The source operand should be a SSE register, |
the destination operand should be a 128-bit memory location. "maskmovq" stores |
selected bytes from the first operand into a 64-bit memory location using a |
non-temporal hint. Both operands should be a MMX registers, the second operand |
selects wich bytes from the source operand are written to memory. The |
memory location is pointed by DI (or EDI) register in the segment selected |
by DS. |
"prefetcht0", "prefetcht1", "prefetcht2" and "prefetchnta" fetch the line |
of data from memory that contains byte specified with the operand to a |
specified location in hierarchy. The operand should be an 8-bit memory |
location. |
"sfence" performs a serializing operation on all instruction storing to |
memory that were issued prior to it. This instruction has no operands. |
"ldmxcsr" loads the 32-bit memory operand into the MXCSR register. "stmxcsr" |
stores the contents of MXCSR into a 32-bit memory operand. |
"fxsave" saves the current state of the FPU, MXCSR register, and all the FPU |
and SSE registers to a 512-byte memory location specified in the destination |
operand. "fxrstor" reloads data previously stored with "fxsave" instruction |
from the specified 512-byte memory location. The memory operand for both those |
instructions must be aligned on 16 byte boundary, it should declare operand |
of no specified size. |
2.1.16 SSE2 instructions |
The SSE2 extension introduces the operations on packed double precision |
floating point values, extends the syntax of MMX instructions, and adds also |
some new instructions. |
"movapd" and "movupd" transfer a double quad word operand containing packed |
double precision values from source operand to destination operand. These |
instructions are analogous to "movaps" and "movups" and have the same rules |
for operands. |
"movlpd" moves double precision value between the memory and the low quad |
word of SSE register. "movhpd" moved double precision value between the memory |
and the high quad word of SSE register. These instructions are analogous to |
"movlps" and "movhps" and have the same rules for operands. |
"movmskpd" transfers the most significant bit of each of the two double |
precision values in the SSE register into low two bits of a general register. |
This instruction is analogous to "movmskps" and has the same rules for |
operands. |
"movsd" transfers a double precision value between source and destination |
operand (only the low quad word is trasferred). At least one of the operands |
have to be a SSE register, the second one can be also a SSE register or 64-bit |
memory location. |
Arithmetic operations on double precision values are: "addpd", "addsd", |
"subpd", "subsd", "mulpd", "mulsd", "divpd", "divsd", "sqrtpd", "sqrtsd", |
"maxpd", "maxsd", "minpd", "minsd", and they are analoguous to arithmetic |
operations on single precision values described in previous section. When the |
mnemonic ends with "pd" instead of "ps", the operation is performed on packed |
two double precision values, but rules for operands are the same. When the |
mnemonic ends with "sd" instead of "ss", the source operand can be a 64-bit |
memory location or a SSE register, the destination operand must be a SSE |
register and the operation is performed on double precision values, only low |
quad words of SSE registers are used in this case. |
"andpd", "andnpd", "orpd" and "xorpd" perform the logical operations on |
packed double precision values. They are analoguous to SSE logical operations |
on single prevision values and have the same rules for operands. |
"cmppd" compares packed double precision values and returns and returns a |
mask result into the destination operand. This instruction is analoguous to |
"cmpps" and has the same rules for operands. "cmpsd" performs the same |
operation on double precision values, only low quad word of destination |
register is affected, in this case source operand can be a 64-bit memory or |
SSE register. Variant with only two operands are obtained by attaching the |
condition mnemonic from table 2.3 to the "cmp" mnemonic and then attaching |
the "pd" or "sd" at the end. |
"comisd" and "ucomisd" compare the double precision values and set the ZF, |
PF and CF flags to show the result. The destination operand must be a SSE |
register, the source operand can be a 128-bit memory location or SSE register. |
"shufpd" moves any of the two double precision values from the destination |
operand into the low quad word of the destination operand, and any of the two |
values from the source operand into the high quad word of the destination |
operand. This instruction is analoguous to "shufps" and has the same rules for |
operand. Bit 0 of the third operand selects the value to be moved from the |
destination operand, bit 1 selects the value to be moved from the source |
operand, the rest of bits are reserved and must be zeroed. |
"unpckhpd" performs an unpack of the high quad words from the source and |
destination operands, "unpcklpd" performs an unpack of the low quad words from |
the source and destination operands. They are analoguous to "unpckhps" and |
"unpcklps", and have the same rules for operands. |
"cvtps2pd" converts the packed two single precision floating point values to |
two packed double precision floating point values, the destination operand |
must be a SSE register, the source operand can be a 64-bit memory location or |
SSE register. "cvtpd2ps" converts the packed two double precision floating |
point values to packed two single precision floating point values, the |
destination operand must be a SSE register, the source operand can be a |
128-bit memory location or SSE register. "cvtss2sd" converts the single |
precision floating point value to double precision floating point value, the |
destination operand must be a SSE register, the source operand can be a 32-bit |
memory location or SSE register. "cvtsd2ss" converts the double precision |
floating point value to single precision floating point value, the destination |
operand must be a SSE register, the source operand can be 64-bit memory |
location or SSE register. |
"cvtpi2pd" converts packed two double word integers into the the packed |
double precision floating point values, the destination operand must be a SSE |
register, the source operand can be a 64-bit memory location or MMX register. |
"cvtsi2sd" converts a double word integer into a double precision floating |
point value, the destination operand must be a SSE register, the source |
operand can be a 32-bit memory location or 32-bit general register. "cvtpd2pi" |
converts packed double precision floating point values into packed two double |
word integers, the destination operand should be a MMX register, the source |
operand can be a 128-bit memory location or SSE register. "cvttpd2pi" performs |
the similar operation, except that truncation is used to round a source values |
to integers, rules for operands are the same. "cvtsd2si" converts a double |
precision floating point value into a double word integer, the destination |
operand should be a 32-bit general register, the source operand can be a |
64-bit memory location or SSE register. "cvttsd2si" performs the similar |
operation, except that truncation is used to round a source value to integer, |
rules for operands are the same. |
"cvtps2dq" and "cvttps2dq" convert packed single precision floating point |
values to packed four double word integers, storing them in the destination |
operand. "cvtpd2dq" and "cvttpd2dq" convert packed double precision floating |
point values to packed two double word integers, storing the result in the low |
quad word of the destination operand. "cvtdq2ps" converts packed four |
double word integers to packed single precision floating point values. |
"cvtdq2pd" converts packed two double word integers from the low quad word |
of the source operand to packed double precision floating point values. |
For all these instruction destination operand must be a SSE register, the |
source operand can be a 128-bit memory location or SSE register. |
"movdqa" and "movdqu" transfer a double quad word operand containing packed |
integers from source operand to destination operand. At least one of the |
operands have to be a SSE register, the second one can be also a SSE register |
or 128-bit memory location. Memory operands for "movdqa" instruction must be |
aligned on boundary of 16 bytes, operands for "movdqu" instruction don't have |
to be aligned. |
"movq2dq" moves the contents of the MMX source register to the low quad word |
of destination SSE register. "movdq2q" moves the low quad word from the source |
SSE register to the destination MMX register. |
movq2dq xmm0,mm1 ; move from MMX register to SSE register |
movdq2q mm0,xmm1 ; move from SSE register to MMX register |
All MMX instructions operating on the 64-bit packed integers (those with |
mnemonics starting with "p") are extended to operate on 128-bit packed |
integers located in SSE registers. Additional syntax for these instructions |
needs an SSE register where MMX register was needed, and the 128-bit memory |
location or SSE register where 64-bit memory location of MMX register were |
needed. The exception is "pshufw" instruction, which doesn't allow extended |
syntax, but has two new variants: "pshufhw" and "pshuflw", which allow only |
the extended syntax, and perform the same operation as "pshufw" on the high |
or low quad words of operands respectively. Also the new instruction "pshufd" |
is introduced, which performs the same operation as "pshufw", but on the |
double words instead of words, it allows only the extended syntax. |
psubb xmm0,[esi] ; substract 16 packed bytes |
pextrw eax,xmm0,7 ; extract highest word into eax |
"paddq" performs the addition of packed quad words, "psubq" performs the |
substraction of packed quad words, "pmuludq" performs an unsigned multiply |
of low double words from each corresponding quad words and returns the results |
in packed quad words. These instructions follow the same rules for operands as |
the general MMX operations described in 2.1.14. |
"pslldq" and "psrldq" perform logical shift left or right of the double |
quad word in the destination operand by the amount of bits specified in the |
source operand. The destination operand should be a SSE register, source |
operand should be an 8-bit immediate value. |
"punpckhqdq" interleaves the high quad word of the source operand and the |
high quad word of the destination operand and writes them to the destination |
SSE register. "punpcklqdq" interleaves the low quad word of the source operand |
and the low quad word of the destination operand and writes them to the |
destination SSE register. The source operand can be a 128-bit memory location |
or SSE register. |
"movntdq" stores packed integer data from the SSE register to memory using |
non-temporal hint. The source operand should be a SSE register, the |
destination operand should be a 128-bit memory location. "movntpd" stores |
packed double precision values from the SSE register to memory using a |
non-temporal hint. Rules for operand are the same. "movnti" stores integer |
from a general register to memory using a non-temporal hint. The source |
operand should be a 32-bit general register, the destination operand should |
be a 32-bit memory location. "maskmovdqu" stores selected bytes from the first |
operand into a 128-bit memory location using a non-temporal hint. Both |
operands should be a SSE registers, the second operand selects wich bytes from |
the source operand are written to memory. The memory location is pointed by DI |
(or EDI) register in the segment selected by DS and does not need to be |
aligned. |
"clflush" writes and invalidates the cache line associated with the address |
of byte specified with the operand, which should be a 8-bit memory location. |
"lfence" performs a serializing operation on all instruction loading from |
memory that were issued prior to it. "mfence" performs a serializing operation |
on all instruction accesing memory that were issued prior to it, and so it |
combines the functions of "sfence" (described in previous section) and |
"lfence" instructions. These instructions have no operands. |
2.1.17 SSE3 instructions |
Prescott technology introduced some new instructions to improve the performance |
of SSE and SSE2 - this extension is called SSE3. |
"fisttp" behaves like the "fistp" instruction and accepts the same operands, |
the only difference is that it always used truncation, irrespective of the |
rounding mode. |
"movshdup" loads into destination operand the 128-bit value obtained from |
the source value of the same size by filling the each quad word with the two |
duplicates of the value in its high double word. "movsldup" performs the same |
action, except it duplicates the values of low double words. The destination |
operand should be SSE register, the source operand can be SSE register or |
128-bit memory location. |
"movddup" loads the 64-bit source value and duplicates it into high and low |
quad word of the destination operand. The destination operand should be SSE |
register, the source operand can be SSE register or 64-bit memory location. |
"lddqu" is functionally equivalent to "movdqu" instruction with memory as |
source operand, but it may improve performance when the source operand crosses |
a cacheline boundary. The destination operand has to be SSE register, the |
source operand must be 128-bit memory location. |
"addsubps" performs single precision addition of second and fourth pairs and |
single precision substracion of the first and third pairs of floating point |
values in the operands. "addsubpd" performs double precision addition of the |
second pair and double precision substraction of the first pair of floating |
point values in the operand. "haddps" performs the addition of two single |
precision values within the each quad word of source and destination operands, |
and stores the results of such horizontal addition of values from destination |
operand into low quad word of destination operand, and the results from the |
source operand into high quad word of destination operand. "haddpd" performs |
the addition of two double precision values within each operand, and stores |
the result from destination operand into low quad word of destination operand, |
and the result from source operand into high quad word of destination operand. |
All these instruction need the destination operand to be SSE register, source |
operand can be SSE register or 128-bit memory location. |
"monitor" sets up an address range for monitoring of write-back stores. It |
need its three operands to be EAX, ECX and EDX register in that order. "mwait" |
waits for a write-back store to the address range set up by the "monitor" |
instruction. It uses two operands with additional parameters, first being the |
EAX and second the ECX register. |
2.1.18 AMD 3DNow! instructions |
The 3DNow! extension adds a new MMX instructions to those described in 2.1.14, |
and introduces operation on the 64-bit packed floating point values, each |
consisting of two single precision floating point values. |
These instructions follow the same rules as the general MMX operations, the |
destination operand should be a MMX register, the source operand can be a MMX |
register or 64-bit memory location. "pavgusb" computes the rounded averages |
of packed unsigned bytes. "pmulhrw" performs a signed multiply of the packed |
words, round the high word of each double word results and stores them in the |
destination operand. "pi2fd" converts packed double word integers into |
packed floating point values. "pf2id" converts packed floating point values |
into packed double word integers using truncation. "pi2fw" converts packed |
word integers into packed floating point values, only low words of each |
double word in source operand are used. "pf2iw" converts packed floating |
point values to packed word integers, results are extended to double words |
using the sign extension. "pfadd" adds packed floating point values. "pfsub" |
and "pfsubr" substracts packed floating point values, the first one substracts |
source values from destination values, the second one substracts destination |
values from the source values. "pfmul" multiplies packed floating point |
values. "pfacc" adds the low and high floating point values of the destination |
operand, storing the result in the low double word of destination, and adds |
the low and high floating point values of the source operand, storing the |
result in the high double word of destination. "pfnacc" substracts the high |
floating point value of the destination operand from the low, storing the |
result in the low double word of destination, and substracts the high floating |
point value of the source operand from the low, storing the result in the high |
double word of destination. "pfpnacc" substracts the high floating point value |
of the destination operand from the low, storing the result in the low double |
word of destination, and adds the low and high floating point values of the |
source operand, storing the result in the high double word of destination. |
"pfmax" and "pfmin" compute the maximum and minimum of floating point values. |
"pswapd" reverses the high and low double word of the source operand. "pfrcp" |
returns an estimates of the reciprocals of floating point values from the |
source operand, "pfrsqrt" returns an estimates of the reciprocal square |
roots of floating point values from the source operand, "pfrcpit1" performs |
the first step in the Newton-Raphson iteration to refine the reciprocal |
approximation produced by "pfrcp" instruction, "pfrsqit1" performs the first |
step in the Newton-Raphson iteration to refine the reciprocal square root |
approximation produced by "pfrsqrt" instruction, "pfrcpit2" performs the |
second final step in the Newton-Raphson iteration to refine the reciprocal |
approximation or the reciprocal square root approximation. "pfcmpeq", |
"pfcmpge" and "pfcmpgt" compare the packed floating point values and sets |
all bits or zeroes all bits of the correspoding data element in the |
destination operand according to the result of comparison, first checks |
whether values are equal, second checks whether destination value is greater |
or equal to source value, third checks whether destination value is greater |
than source value. |
"prefetch" and "prefetchw" load the line of data from memory that contains |
byte specified with the operand into the data cache, "prefetchw" instruction |
should be used when the data in the cache line is expected to be modified, |
otherwise the "prefetch" instruction should be used. The operand should be an |
8-bit memory location. |
"femms" performs a fast clear of MMX state. This instruction has no |
operands. |
2.1.19 The x86-64 long mode instructions |
The AMD64 and EM64T architectures (we will use the common name x86-64 for them |
both) extend the x86 instruction set for the 64-bit processing. While legacy |
and compatibility modes use the same set of registers and instructions, the |
new long mode extends the x86 operations to 64 bits and introduces several new |
registers. You can turn on generating the code for this mode with the "use64" |
directive. |
Each of the general purpose registers is extended to 64 bits and the eight |
whole new general purpose registers and also eight new SSE registers are added. |
See table 2.4 for the summary of new registers (only the ones that was not |
listed in table 1.2). The general purpose registers of smallers sizes are the |
low order portions of the larger ones. You can still access the "ah", "bh", |
"ch" and "dh" registers in long mode, but you cannot use them in the same |
instruction with any of the new registers. |
Table 2.4 New registers in long mode |
ÚÄÄÄÄÄÄÂÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÂÄÄÄÄÄÄÄ¿ |
³ Type ³ General ³ SSE ³ |
ÃÄÄÄÄÄÄÅÄÄÄÄÄÄÂÄÄÄÄÄÄÂÄÄÄÄÄÄÂÄÄÄÄÄÄÅÄÄÄÄÄÄÄ´ |
³ Bits ³ 8 ³ 16 ³ 32 ³ 64 ³ 128 ³ |
ÆÍÍÍÍÍÍØÍÍÍÍÍÍØÍÍÍÍÍÍØÍÍÍÍÍÍØÍÍÍÍÍÍØÍÍÍÍÍÍ͵ |
³ ³ ³ ³ ³ rax ³ ³ |
³ ³ ³ ³ ³ rcx ³ ³ |
³ ³ ³ ³ ³ rdx ³ ³ |
³ ³ ³ ³ ³ rbx ³ ³ |
³ ³ spl ³ ³ ³ rsp ³ ³ |
³ ³ bpl ³ ³ ³ rbp ³ ³ |
³ ³ sil ³ ³ ³ rsi ³ ³ |
³ ³ dil ³ ³ ³ rdi ³ ³ |
³ ³ r8b ³ r8w ³ r8d ³ r8 ³ xmm8 ³ |
³ ³ r9b ³ r9w ³ r9d ³ r9 ³ xmm9 ³ |
³ ³ r10b ³ r10w ³ r10d ³ r10 ³ xmm10 ³ |
³ ³ r11b ³ r11w ³ r11d ³ r11 ³ xmm11 ³ |
³ ³ r12b ³ r12w ³ r12d ³ r12 ³ xmm12 ³ |
³ ³ r13b ³ r13w ³ r13d ³ r13 ³ xmm13 ³ |
³ ³ r14b ³ r14w ³ r14d ³ r14 ³ xmm14 ³ |
³ ³ r15b ³ r15w ³ r15d ³ r15 ³ xmm15 ³ |
ÀÄÄÄÄÄÄÁÄÄÄÄÄÄÁÄÄÄÄÄÄÁÄÄÄÄÄÄÁÄÄÄÄÄÄÁÄÄÄÄÄÄÄÙ |
In general any instruction from x86 architecture, which allowed 16-bit or |
32-bit operand sizes, in long mode allows also the 64-bit operands. The 64-bit |
registers should be used for addressing in long mode, the 32-bit addressing |
is also allowed, but it's not possible to use the addresses based on 16-bit |
registers. Below are the samples of new operations possible in long mode on the |
example of "mov" instruction: |
mov rax,r8 ; transfer 64-bit general register |
mov al,[rbx] ; transfer memory addressed by 64-bit register |
The long mode uses also the instruction pointer based addresses, you can |
specify it manually with the special RIP register symbol, but such addressing |
is also automatically generated by flat assembler, since there is no 64-bit |
absolute addressing in long mode. You can still force the assembler to use the |
32-bit absolute addressing by putting the "dword" size override for address |
inside the square brackets. There is also one exception, where the 64-bit |
absolute addressing is possible, it's the "mov" instruction with one of the |
operand being accumulator register, and second being the memory operand. |
To force the assembler to use the 64-bit absolute addressing there, use the |
"qword" size operator for address inside the square brackets. When no size |
operator is applied to address, assembler generates the optimal form |
automatically. |
mov [qword 0],rax ; absolute 64-bit addressing |
mov [dword 0],r15d ; absolute 32-bit addressing |
mov [0],rsi ; automatic RIP-relative addressing |
mov [rip+3],sil ; manual RIP-relative addressing |
Also as the immediate operands for 64-bit operations only the signed 32-bit |
values are possible, with the only exception being the "mov" instruction with |
destination operand being 64-bit general purpose register. Trying to force the |
64-bit immediate with any other instruction will cause an error. |
If any operation is performed on the 32-bit general registers in long mode, |
the upper 32 bits of the 64-bit registers containing them are filled with |
zeros. This is unlike the operations on 16-bit or 8-bit portions of those |
registers, which preserve the upper bits. |
Three new type conversion instructions are available. The "cdqe" sign extends |
the double word in EAX into quad word and stores the result in RAX register. |
"cqo" sign extends the quad word in RAX into double quad word and stores the |
extra bits in the RDX register. These instructions have no operands. "movsxd" |
sign extends the double word source operand, being either the 32-bit register |
or memory, into 64-bit destination operand, which has to be register. |
No analogous instruction is needed for the zero extension, since it is done |
automatically by any operations on 32-bit registers, as noted in previous |
paragraph. And the "movzx" and "movsx" instructions, conforming to the general |
rule, can be used with 64-bit destination operand, allowing extension of byte |
or word values into quad words. |
All the binary arithmetic and logical instruction are promoted to allow |
64-bit operands in long mode. The use of decimal arithmetic instructions in |
long mode is prohibited. |
The stack operations, like "push" and "pop" in long mode default to 64-bit |
operands and it's not possible to use 32-bit operands with them. The "pusha" |
and "popa" are disallowed in long mode. |
The indirect near jumps and calls in long mode default to 64-bit operands and |
it's not possible to use the 32-bit operands with them. On the other hand, the |
indirect far jumps and calls allow any operands that were allowed by the x86 |
architecture and also 80-bit memory operand is allowed (though only EM64T seems |
to implement such variant), with the first eight bytes defining the offset and |
two last bytes specifying the selector. The direct far jumps and calls are not |
allowed in long mode. |
The I/O instructions, "in", "out", "ins" and "outs" are the exceptional |
instructions that are not extended to accept quad word operands in long mode. |
But all other string operations are, and there are new short forms "movsq", |
"cmpsq", "scasq", "lodsq" and "stosq" introduced for the variants of string |
operations for 64-bit string elements. The RSI and RDI registers are used by |
default to address the string elements. |
The "lfs", "lgs" and "lss" instructions are extended to accept 80-bit source |
memory operand with 64-bit destination register (though only EM64T seems to |
implement such variant). The "lds" and "les" are disallowed in long mode. |
The system instructions like "lgdt" which required the 48-bit memory operand, |
in long mode require the 80-bit memory operand. |
The "cmpxchg16b" is the 64-bit equivalent of "cmpxchg8b" instruction, it uses |
the double quad word memory operand and 64-bit registers to perform the |
analoguous operation. |
"swapgs" is the new instruction, which swaps the contents of GS register and |
the KernelGSbase model-specific register (MSR address 0C0000102h). |
"syscall" and "sysret" is the pair of new instructions that provide the |
functionality similar to "sysenter" and "sysexit" in long mode, where the |
latter pair is disallowed. |
2.2 Control directives |
This section describes the directives that control the assembly process, they |
are processed during the assembly and may cause some blocks of instructions |
to be assembled differently or not assembled at all. |
2.2.1 Numerical constants |
The "=" directive allows to define the numerical constant. It should be |
preceded by the name for the constant and followed by the numerical expression |
providing the value. The value of such constants can be a number or an address, |
but - unlike labels - the numerical constants are not allowed to hold the |
register-based addresses. Besides this difference, in their basic variant |
numerical constants behave very much like labels and you can even |
forward-reference them (access their values before they actually get defined). |
There is, however, a second variant of numerical constants, which is |
recognized by assembler when you try to define the constant of name, under |
which there already was a numerical constant defined. In such case assembler |
treats that constant as an assembly-time variable and allows it to be assigned |
with new value, but forbids forward-referencing it (for obvious reasons). Let's |
see both the variant of numerical constants in one example: |
dd sum |
x = 1 |
x = x+2 |
sum = x |
Here the "x" is an assembly-time variable, and every time it is accessed, the |
value that was assigned to it the most recently is used. Thus if we tried to |
access the "x" before it gets defined the first time, like if we wrote "dd x" |
in place of the "dd sum" instruction, it would cause an error. And when it is |
re-defined with the "x = x+2" directive, the previous value of "x" is used to |
calculate the new one. So when the "sum" constant gets defined, the "x" has |
value of 3, and this value is assigned to the "sum". Since this one is defined |
only once in source, it is the standard numerical constant, and can be |
forward-referenced. So the "dd sum" is assembled as "dd 3". To read more about |
how the assembler is able to resolve this, see section 2.2.6. |
The value of numerical constant can be preceded by size operator, which can |
ensure that the value will fit in the range for the specified size, and can |
affect also how some of the calculations inside the numerical expression are |
performed. This example: |
c8 = byte -1 |
c32 = dword -1 |
defines two different constants, the first one fits in 8 bits, the second one |
fits in 32 bits. |
When you need to define constant with the value of address, which may be |
register-based (and thus you cannot employ numerical constant for this |
purpose), you can use the extended syntax of "label" directive (already |
described in section 1.2.3), like: |
label myaddr at ebp+4 |
which declares label placed at "ebp+4" address. However remember that labels, |
unlike numerical constants, cannot become assembly-time variables. |
2.2.2 Conditional assembly |
"if" directive causes come block of instructions to be assembled only under |
certain condition. It should be followed by logical expression specifying the |
condition, instructions in next lines will be assembled only when this |
condition is met, otherwise they will be skipped. The optional "else if" |
directive followed with logical expression specifying additional condition |
begins the next block of instructions that will be assembled if previous |
conditions were not met, and the additional condition is met. The optional |
"else" directive begins the block of instructions that will be assembled if |
all the conditions were not met. The "end if" directive ends the last block of |
instructions. |
You should note that "if" directive is processed at assembly stage and |
therefore it doesn't affect any preprocessor directives, like the definitions |
of symbolic constants and macroinstructions - when the assembler recognizes the |
"if" directive, all the preprocessing has been already finished. |
The logical expression consist of logical values and logical operators. The |
logical operators are "~" for logical negation, "&" for logical and, "|" for |
logical or. The negation has the highest priority. Logical value can be a |
numerical expression, it will be false if it is equal to zero, otherwise it |
will be true. Two numerical expression can be compared using one of the |
following operators to make the logical value: "=" (equal), "<" (less), |
">" (greater), "<=" (less or equal), ">=" (greater or equal), |
"<>" (not equal). |
The "used" operator followed by a symbol name, is the logical value that |
checks whether the given symbol is used somewhere (it returns correct result |
even if symbol is used only after this check). The "defined" operator can be |
followed by any expression, usually just by a single symbol name; it checks |
whether the given expression contains only symbols that are defined in the |
source and accessible from the current position. |
The following simple example uses the "count" constant that should be |
defined somewhere in source: |
if count>0 |
mov cx,count |
rep movsb |
end if |
These two assembly instructions will be assembled only if the "count" constant |
is greater than 0. The next sample shows more complex conditional structure: |
if count & ~ count mod 4 |
mov cx,count/4 |
rep movsd |
else if count>4 |
mov cx,count/4 |
rep movsd |
mov cx,count mod 4 |
rep movsb |
else |
mov cx,count |
rep movsb |
end if |
The first block of instructions gets assembled when the "count" is non zero and |
divisible by four, if this condition is not met, the second logical expression, |
which follows the "else if", is evaluated and if it's true, the second block |
of instructions get assembled, otherwise the last block of instructions, which |
follows the line containing only "else", is assembled. |
There are also operators that allow comparison of values being any chains of |
symbols. The "eq" compares two such values whether they are exactly the same. |
The "in" operator checks whether given value is a member of the list of values |
following this operator, the list should be enclosed between "<" and ">" |
characters, its members should be separated with commas. The symbols are |
considered the same when they have the same meaning for the assembler - for |
example "pword" and "fword" for assembler are the same and thus are not |
distinguished by the above operators. In the same way "16 eq 10h" is the true |
condition, however "16 eq 10+4" is not. |
The "eqtype" operator checks whether the two compared values have the same |
structure, and whether the structural elements are of the same type. The |
distinguished types include numerical expressions, individual quoted strings, |
floating point numbers, address expressions (the expressions enclosed in square |
brackets or preceded by "ptr" operator), instruction mnemonics, registers, size |
operators, jump type and code type operators. And each of the special |
characters that act as a separators, like comma or colon, is the separate type |
itself. For example, two values, each one consisting of register name followed |
by comma and numerical expression, will be regarded as of the same type, no |
matter what kind of register and how complicated numerical expression is used; |
with exception for the quoted strings and floating point values, which are the |
special kinds of numerical expressions and are treated as different types. Thus |
"eax,16 eqtype fs,3+7" condition is true, but "eax,16 eqtype eax,1.6" is false. |
2.2.3 Repeating blocks of instructions |
"times" directive repeats one instruction specified number of times. It |
should be followed by numerical expression specifying number of repeats and |
the instruction to repeat (optionally colon can be used to separate number and |
instruction). When special symbol "%" is used inside the instruction, it is |
equal to the number of current repeat. For example "times 5 db %" will define |
five bytes with values 1, 2, 3, 4, 5. Recursive use of "times" directive is |
also allowed, so "times 3 times % db %" will define six bytes with values |
1, 1, 2, 1, 2, 3. |
"repeat" directive repeats the whole block of instructions. It should be |
followed by numerical expression specifying number of repeats. Instructions |
to repeat are expected in next lines, ended with the "end repeat" directive, |
for example: |
repeat 8 |
mov byte [bx],% |
inc bx |
end repeat |
The generated code will store byte values from one to eight in the memory |
addressed by BX register. |
Number of repeats can be zero, in that case the instructions are not |
assembled at all. |
The "break" directive allows to stop repeating earlier and continue assembly |
from the first line after the "end repeat". Combined with the "if" directive it |
allows to stop repeating under some special condition, like: |
s = x/2 |
repeat 100 |
if x/s = s |
break |
end if |
s = (s+x/s)/2 |
end repeat |
The "while" directive repeats the block of instructions as long as the |
condition specified by the logical expression following it is true. The block |
of instructions to be repeated should end with the "end while" directive. |
Before each repetition the logical expression is evaluated and when its value |
is false, the assembly is continued starting from the first line after the |
"end while". Also in this case the "%" symbol holds the number of current |
repeat. The "break" directive can be used to stop this kind of loop in the same |
way as with "repeat" directive. The previous sample can be rewritten to use the |
"while" instead of "repeat" this way: |
s = x/2 |
while x/s <> s |
s = (s+x/s)/2 |
if % = 100 |
break |
end if |
end while |
The blocks defined with "if", "repeat" and "while" can be nested in any |
order, however they should be closed in the same order in which they were |
started. The "break" directive always stops processing the block that was |
started last with either the "repeat" or "while" directive. |
2.2.4 Addressing spaces |
"org" directive sets address at which the following code is expected to |
appear in memory. It should be followed by numerical expression specifying |
the address. This directive begins the new addressing space, the following |
code itself is not moved in any way, but all the labels defined within it |
and the value of "$" symbol are affected as if it was put at the given |
address. However it's the responsibility of programmer to put the code at |
correct address at run-time. |
The "load" directive allows to define constant with a binary value loaded |
from the already assembled code. This directive should be followed by the name |
of the constant, then optionally size operator, then "from" operator and a |
numerical expression specifying a valid address in current addressing space. |
The size operator has unusual meaning in this case - it states how many bytes |
(up to 8) have to be loaded to form the binary value of constant. If no size |
operator is specified, one byte is loaded (thus value is in range from 0 to |
255). The loaded data cannot exceed current offset. |
The "store" directive can modify the already generated code by replacing |
some of the previously generated data with the value defined by given |
numerical expression, which follow. The expression can be preceded by the |
optional size operator to specify how large value the expression defines, and |
therefore how much bytes will be stored, if there is no size operator, the |
size of one byte is assumed. Then the "at" operator and the numerical |
expression defining the valid address in current addressing code space, at |
which the given value have to be stored should follow. This is a directive for |
advanced appliances and should be used carefully. |
Both "load" and "store" directives are limited to operate on places in |
current addressing space. The "$$" symbol is always equal to the base address |
of current addressing space, and the "$" symbol is the address of current |
position in that addressing space, therefore these two values define limits |
of the area, where "load" and "store" can operate. |
Combining the "load" and "store" directives allows to do things like encoding |
some of the already generated code. For example to encode the whole code |
generated in current addressing space you can use such block of directives: |
repeat $-$$ |
load a byte from $$+%-1 |
store byte a xor c at $$+%-1 |
end repeat |
and each byte of code will be xored with the value defined by "c" constant. |
"virtual" defines virtual data at specified address. This data won't be |
included in the output file, but labels defined there can be used in other |
parts of source. This directive can be followed by "at" operator and the |
numerical expression specifying the address for virtual data, otherwise is |
uses current address, the same as "virtual at $". Instructions defining data |
are expected in next lines, ended with "end virtual" directive. The block of |
virtual instructions itself is an independent addressing space, after it's |
ended, the context of previous addressing space is restored. |
The "virtual" directive can be used to create union of some variables, for |
example: |
GDTR dp ? |
virtual at GDTR |
GDT_limit dw ? |
GDT_address dd ? |
end virtual |
It defines two labels for parts of the 48-bit variable at "GDTR" address. |
It can be also used to define labels for some structures addressed by a |
register, for example: |
virtual at bx |
LDT_limit dw ? |
LDT_address dd ? |
end virtual |
With such definition instruction "mov ax,[LDT_limit]" will be assembled |
to "mov ax,[bx]". |
Declaring defined data values or instructions inside the virtual block would |
also be useful, because the "load" directive can be used to load the values |
from the virtually generated code into a constants. This directive should be |
used after the code it loads but before the virtual block ends, because it can |
only load the values from the same addressing space. For example: |
virtual at 0 |
xor eax,eax |
and edx,eax |
load zeroq dword from 0 |
end virtual |
The above piece of code will define the "zeroq" constant containing four bytes |
of the machine code of the instructions defined inside the virtual block. |
This method can be also used to load some binary value from external file. |
For example this code: |
virtual at 0 |
file 'a.txt':10h,1 |
load char from 0 |
end virtual |
loads the single byte from offset 10h in file "a.txt" into the "char" |
constant. |
Any of the "section" directives described in 2.4 also begins a new |
addressing space. |
2.2.5 Other directives |
"align" directive aligns code or data to the specified boundary. It should |
be followed by a numerical expression specifying the number of bytes, to the |
multiply of which the current address has to be aligned. The boundary value |
has to be the power of two. |
The "align" directive fills the bytes that had to be skipped to perform the |
alignment with the "nop" instructions and at the same time marks this area as |
uninitialized data, so if it is placed among other uninitialized data that |
wouldn't take space in the output file, the alignment bytes will act the same |
way. If you need to fill the alignment area with some other values, you can |
combine "align" with "virtual" to get the size of alignment needed and then |
create the alignment yourself, like: |
virtual |
align 16 |
a = $ - $$ |
end virtual |
db a dup 0 |
The "a" constant is defined to be the difference between address after |
alignment and address of the "virtual" block (see previous section), so it is |
equal to the size of needed alignment space. |
"display" directive displays the message at the assembly time. It should |
be followed by the quoted strings or byte values, separated with commas. It |
can be used to display values of some constants, for example: |
bits = 16 |
display 'Current offset is 0x' |
repeat bits/4 |
d = '0' + $ shr (bits-%*4) and 0Fh |
if d > '9' |
d = d + 'A'-'9'-1 |
end if |
display d |
end repeat |
display 13,10 |
This block of directives calculates the four hexadecimal digits of 16-bit value |
and converts them into characters for displaying. Note that this won't work if |
the adresses in current addressing space are relocatable (as it might happen |
with PE or object output formats), since only absolute values can be used this |
way. The absolute value may be obtained by calculating the relative address, |
like "$-$$", or "rva $" in case of PE format. |
2.2.6 Multiple passes |
Because the assembler allows to reference some of the labels or constants |
before they get actually defined, it has to predict the values of such labels |
and if there is even a suspicion that prediction failed in at least one case, |
it does one more pass, assembling the whole source, this time doing better |
prediction based on the values the labels got in the previous pass. |
The changing values of labels can cause some instructions to have encodings |
of different length, and this can cause the change in values of labels again. |
And since the labels and constants can also be used inside the expressions that |
affect the behavior of control directives, the whole block of source can be |
processed completely differently during the new pass. Thus the assembler does |
more and more passes, each time trying to do better predictions to approach |
the final solution, when all the values get predicted correctly. It uses |
various method for predicting the values, which has been chosen to allow |
finding in a few passes the solution of possibly smallest length for the most |
of the programs. |
Some of the errors, like the values not fitting in required boundaries, are |
not signaled during those intermediate passes, since it may happen that when |
some of the values are predicted better, these errors will disappear. However |
if assembler meets some illegal syntax construction or unknown instruction, it |
always stops immediately. Also defining some label more than once causes such |
error, because it makes the predictions groundless. |
Only the messages created with the "display" directive during the last |
performed pass get actually displayed. In case when the assembly has been |
stopped due to an error, these messages may reflect the predicted values that |
are not yet resolved correctly. |
The solution may sometimes not exist and in such cases the assembler will |
never manage to make correct predictions - for this reason there is a limit for |
a number of passes, and when assembler reaches this limit, it stops and |
displays the message that it is not able to generate the correct output. |
Consider the following example: |
if ~ defined alpha |
alpha: |
end if |
The "defined" operator gives the true value when the expression following it |
could be calculated in this place, what in this case means that the "alpha" |
label is defined somewhere. But the above block causes this label to be defined |
only when the value given by "defined" operator is false, what leads to an |
antynomy and makes it impossible to resolve such code. When processing the "if" |
directive assembler has to predict whether the "alpha" label will be defined |
somewhere (it wouldn't have to predict only if the label was already defined |
earlier in this pass), and whatever the prediction is, the opposite always |
happens. Thus the assembly will fail, unless the "alpha" label is defined |
somewhere in source preceding the above block of instructions - in such case, |
as it was already noted, the prediction is not needed and the block will just |
get skipped. |
The above sample might have been written as a try to define the label only |
when it was not yet defined. It fails, because the "defined" operator does |
check whether the label is defined anywhere, and this includes the definition |
inside this conditionally processed block. However adding some additional |
condition may make it possible to get it resolved: |
if ~ defined alpha | defined @f |
alpha: |
@@: |
end if |
The "@f" is always the same label as the nearest "@@" symbol in the source |
following it, so the above sample would mean the same if any unique name was |
used instead of the anonymous label. When "alpha" is not defined in any other |
place in source, the only possible solution is when this block gets defined, |
and this time this doesn't lead to the antynomy, because of the anonymous |
label which makes this block self-establishing. To better understand this, |
look at the blocks that has nothing more than this self-establishing: |
if defined @f |
@@: |
end if |
This is an example of source that may have more than one solution, as both |
cases when this block gets processed or not are equally correct. Which one of |
those two solutions we get depends on the algorithm on the assembler, in case |
of flat assembler - on the algorithm of predictions. Back to the previous |
sample, when "alpha" is not defined anywhere else, the condition for "if" block |
cannot be false, so we are left with only one possible solution, and we can |
hope the assembler will arrive at it. On the other hand, when "alpha" is |
defined in some other place, we've got two possible solutions again, but one of |
them causes "alpha" to be defined twice, and such an error causes assembler to |
abort the assembly immediately, as this is the kind of error that deeply |
disturbs the process of resolving. So we can get such source either correctly |
resolved or causing an error, and what we get may depend on the internal |
choices made by the assembler. |
However there are some facts about such choices that are certain. When |
assembler has to check whether the given symbol is defined and it was already |
defined in the current pass, no prediction is needed - it was already noted |
above. And when the given symbol has been defined never before, including all |
the already finished passes, the assembler predicts it to be not defined. |
Knowing this, we can expect that the simple self-establishing block shown |
above will not be assembled at all and that the previous sample will resolve |
correctly when "alpha" is defined somewhere before our conditional block, |
while it will itself define "alpha" when it's not already defined earlier, thus |
potentially causing the error because of double definition if the "alpha" is |
also defined somewhere later. |
The "used" operator may be expected to behave in a similar manner in |
analogous cases, however any other kinds of predictions my not be so simple and |
you should never rely on them this way. |
2.3 Preprocessor directives |
All preprocessor directives are processed before the main assembly process, |
and therefore are not affected by the control directives. At this time also |
all comments are stripped out. |
2.3.1 Including source files |
"include" directive includes the specified source file at the position where |
it is used. It should be followed by the quoted name of file that should be |
included, for example: |
include 'macros.inc' |
The whole included file is preprocessed before preprocessing the lines next |
to the line containing the "include" directive. There are no limits to the |
number of included files as long as they fit in memory. |
The quoted path can contain environment variables enclosed within "%" |
characters, they will be replaced with their values inside the path, both the |
"\" and "/" characters are allowed as a path separators. If no absolute path |
is given, the file is first searched for in the directory containing file |
which included it and when it's not found there, in the directory containing |
the main source file (the one specified in command line). These rules concern |
also paths given with the "file" directive. |
2.3.2 Symbolic constants |
The symbolic constants are different from the numerical constants, before the |
assembly process they are replaced with their values everywhere in source |
lines after their definitions, and anything can become their values. |
The definition of symbolic constant consists of name of the constant |
followed by the "equ" directive. Everything that follows this directive will |
become the value of constant. If the value of symbolic constant contains |
other symbolic constants, they are replaced with their values before assigning |
this value to the new constant. For example: |
d equ dword |
NULL equ d 0 |
d equ edx |
After these three definitions the value of "NULL" constant is "dword 0" and |
the value of "d" is "edx". So, for example, "push NULL" will be assembled as |
"push dword 0" and "push d" will be assembled as "push edx". And if then the |
following line was put: |
d equ d,eax |
the "d" constant would get the new value of "edx,eax". This way the growing |
lists of symbols can be defined. |
"restore" directive allows to get back previous value of redefined symbolic |
constant. It should be followed by one more names of symbolic constants, |
separated with commas. So "restore d" after the above definitions will give |
"d" constant back the value "edx", the second one will restore it to value |
"dword", and one more will revert "d" to original meaning as if no such |
constant was defined. If there was no constant defined of given name, |
"restore" won't cause an error, it will be just ignored. |
Symbolic constant can be used to adjust the syntax of assembler to personal |
preferences. For example the following set of definitions provides the handy |
shortcuts for all the size operators: |
b equ byte |
w equ word |
d equ dword |
p equ pword |
f equ fword |
q equ qword |
t equ tword |
x equ dqword |
Because symbolic constant may also have an empty value, it can be used to |
allow the syntax with "offset" word before any address value: |
offset equ |
After this definition "mov ax,offset char" will be valid construction for |
copying the offset of "char" variable into "ax" register, because "offset" is |
replaced with an empty value, and therefore ignored. |
The "define" directive followed by the name of constant and then the value, |
is the alternative way of defining symbolic constant. The only difference |
between "define" and "equ" is that "define" assigns the value as it is, it does |
not replace the symbolic constants with their values inside it. |
Symbolic constants can also be defined with the "fix" directive, which has |
the same syntax as "equ", but defines constants of high priority - they are |
replaced with their symbolic values even before processing the preprocessor |
directives and macroinstructions, the only exception is "fix" directive |
itself, which has the highest possible priority, so it allows redefinition of |
constants defined this way. |
The "fix" directive can be used for syntax adjustments related to directives |
of preprocessor, what cannot be done with "equ" directive. For example: |
incl fix include |
defines a short name for "include" directive, while the similar definition done |
with "equ" directive wouldn't give such result, as standard symbolic constants |
are replaced with their values after searching the line for preprocessor |
directives. |
2.3.3 Macroinstructions |
"macro" directive allows you to define your own complex instructions, called |
macroinstructions, using which can greatly simplify the process of |
programming. In its simplest form it's similar to symbolic constant |
definition. For example the following definition defines a shortcut for the |
"test al,0xFF" instruction: |
macro tst {test al,0xFF} |
After the "macro" directive there is a name of macroinstruction and then its |
contents enclosed between the "{" and "}" characters. You can use "tst" |
instruction anywhere after this definition and it will be assembled as |
"test al,0xFF". Defining symbolic constant "tst" of that value would give the |
similar result, but the difference is that the name of macroinstruction is |
recognized only as an instruction mnemonic. Also, macroinstructions are |
replaced with corresponding code even before the symbolic constants are |
replaced with their values. So if you define macroinstruction and symbolic |
constant of the same name, and use this name as an instruction mnemonic, it |
will be replaced with the contents of macroinstruction, but it will be |
replaced with value if symbolic constant if used somewhere inside the |
operands. |
The definition of macroinstruction can consist of many lines, because |
"{" and "}" characters don't have to be in the same line as "macro" directive. |
For example: |
macro stos0 |
{ |
xor al,al |
stosb |
} |
The macroinstruction "stos0" will be replaced with these two assembly |
instructions anywhere it's used. |
Like instructions which needs some number of operands, the macroinstruction |
can be defined to need some number of arguments separated with commas. The |
names of needed argument should follow the name of macroinstruction in the |
line of "macro" directive and should be separated with commas if there is more |
than one. Anywhere one of these names occurs in the contents of |
macroinstruction, it will be replaced with corresponding value, provided when |
the macroinstruction is used. Here is an example of a macroinstruction that |
will do data alignment for binary output format: |
macro align value { rb (value-1)-($+value-1) mod value } |
When the "align 4" instruction is found after this macroinstruction is |
defined, it will be replaced with contents of this macroinstruction, and the |
"value" will there become 4, so the result will be "rb (4-1)-($+4-1) mod 4". |
If a macroinstruction is defined that uses an instruction with the same name |
inside its definition, the previous meaning of this name is used. Useful |
redefinition of macroinstructions can be done in that way, for example: |
macro mov op1,op2 |
{ |
if op1 in <ds,es,fs,gs,ss> & op2 in <cs,ds,es,fs,gs,ss> |
push op2 |
pop op1 |
else |
mov op1,op2 |
end if |
} |
This macroinstruction extends the syntax of "mov" instruction, allowing both |
operands to be segment registers. For example "mov ds,es" will be assembled as |
"push es" and "pop ds". In all other cases the standard "mov" instruction will |
be used. The syntax of this "mov" can be extended further by defining next |
macroinstruction of that name, which will use the previous macroinstruction: |
macro mov op1,op2,op3 |
{ |
if op3 eq |
mov op1,op2 |
else |
mov op1,op2 |
mov op2,op3 |
end if |
} |
It allows "mov" instruction to have three operands, but it can still have two |
operands only, because when macroinstruction is given less arguments than it |
needs, the rest of arguments will have empty values. When three operands are |
given, this macroinstruction will become two macroinstructions of the previous |
definition, so "mov es,ds,dx" will be assembled as "push ds", "pop es" and |
"mov ds,dx". |
By placing the "*" after the name of argument you can mark the argument as |
required - preprocessor won't allow it to have an empty value. For example the |
above macroinstruction could be declared as "macro mov op1*,op2*,op3" to make |
sure that first two arguments will always have to be given some non empty |
values. |
When it's needed to provide macroinstruction with argument that contains |
some commas, such argument should be enclosed between "<" and ">" characters. |
If it contains more than one "<" character, the same number of ">" should be |
used to tell that the value of argument ends. |
"purge" directive allows removing the last definition of specified |
macroinstruction. It should be followed by one or more names of |
macroinstructions, separated with commas. If such macroinstruction has not |
been defined, you won't get any error. For example after having the syntax of |
"mov" extended with the macroinstructions defined above, you can disable |
syntax with three operands back by using "purge mov" directive. Next |
"purge mov" will disable also syntax for two operands being segment registers, |
and all the next such directives will do nothing. |
If after the "macro" directive you enclose some group of arguments' names in |
square brackets, it will allow giving more values for this group of arguments |
when using that macroinstruction. Any more argument given after the last |
argument of such group will begin the new group and will become the first |
argument of it. That's why after closing the square bracket no more argument |
names can follow. The contents of macroinstruction will be processed for each |
such group of arguments separately. The simplest example is to enclose one |
argument name in square brackets: |
macro stoschar [char] |
{ |
mov al,char |
stosb |
} |
This macroinstruction accepts unlimited number of arguments, and each one |
will be processed into these two instructions separately. For example |
"stoschar 1,2,3" will be assembled as the following instructions: |
mov al,1 |
stosb |
mov al,2 |
stosb |
mov al,3 |
stosb |
There are some special directives available only inside the definitions of |
macroinstructions. "local" directive defines local names, which will be |
replaced with unique values each time the macroinstruction is used. It should |
be followed by names separated with commas. If the name given as parameter to |
"local" directive begins with a dot or two dots, the unique labels generated |
by each evaluation of macroinstruction will have the same properties. |
This directive is usually needed for the constants or labels that |
macroinstruction defines and uses internally. For example: |
macro movstr |
{ |
local move |
move: |
lodsb |
stosb |
test al,al |
jnz move |
} |
Each time this macroinstruction is used, "move" will become other unique name |
in its instructions, so you won't get an error you normally get when some |
label is defined more than once. |
"forward", "reverse" and "common" directives divide macroinstruction into |
blocks, each one processed after the processing of previous is finished. They |
differ in behavior only if macroinstruction allows multiple groups of |
arguments. Block of instructions that follows "forward" directive is processed |
for each group of arguments, from first to last - exactly like the default |
block (not preceded by any of these directives). Block that follows "reverse" |
directive is processed for each group of argument in reverse order - from last |
to first. Block that follows "common" directive is processed only once, |
commonly for all groups of arguments. Local name defined in one of the blocks |
is available in all the following blocks when processing the same group of |
arguments as when it was defined, and when it is defined in common block it is |
available in all the following blocks not depending on which group of |
arguments is processed. |
Here is an example of macroinstruction that will create the table of |
addresses to strings followed by these strings: |
macro strtbl name,[string] |
{ |
common |
label name dword |
forward |
local label |
dd label |
forward |
label db string,0 |
} |
First argument given to this macroinstruction will become the label for table |
of addresses, next arguments should be the strings. First block is processed |
only once and defines the label, second block for each string declares its |
local name and defines the table entry holding the address to that string. |
Third block defines the data of each string with the corresponding label. |
The directive starting the block in macroinstruction can be followed by the |
first instruction of this block in the same line, like in the following |
example: |
macro stdcall proc,[arg] |
{ |
reverse push arg |
common call proc |
} |
This macroinstruction can be used for calling the procedures using STDCALL |
convention, arguments are pushed on stack in the reverse order. For example |
"stdcall foo,1,2,3" will be assembled as: |
push 3 |
push 2 |
push 1 |
call foo |
If some name inside macroinstruction has multiple values (it is either one |
of the arguments enclosed in square brackets or local name defined in the |
block following "forward" or "reverse" directive) and is used in block |
following the "common" directive, it will be replaced with all of its values, |
separated with commas. For example the following macroinstruction will pass |
all of the additional arguments to the previously defined "stdcall" |
macroinstruction: |
macro invoke proc,[arg] |
{ common stdcall [proc],arg } |
It can be used to call indirectly (by the pointer stored in memory) the |
procedure using STDCALL convention. |
Inside macroinstruction also special operator "#" can be used. This |
operator causes two names to be concatenated into one name. It can be useful, |
because it's done after the arguments and local names are replaced with their |
values. The following macroinstruction will generate the conditional jump |
according to the "cond" argument: |
macro jif op1,cond,op2,label |
{ |
cmp op1,op2 |
j#cond label |
} |
For example "jif ax,ae,10h,exit" will be assembled as "cmp ax,10h" and |
"jae exit" instructions. |
The "#" operator can be also used to concatenate two quoted strings into one. |
Also conversion of name into a quoted string is possible, with the "`" operator, |
which likewise can be used inside the macroinstruction. It convert the name |
that follows it into a quoted string - but note, that when it is followed by |
a macro argument which is being replaced with value containing more than one |
symbol, only the first of them will be converted, as the "`" operator converts |
only one symbol that immediately follows it. Here's an example of utilizing |
those two features: |
macro label name |
{ |
label name |
if ~ used name |
display `name # " is defined but not used.",13,10 |
end if |
} |
When label defined with such macro is not used in the source, macro will warn |
you with the message, informing to which label it applies. |
To make macroinstruction behaving differently when some of the arguments are |
of some special type, for example a quoted strings, you can use "eqtype" |
comparison operator. Here's an example of utilizing it to distinguish a |
quoted string from an other argument: |
macro message arg |
{ |
if arg eqtype "" |
local str |
jmp @f |
str db arg,0Dh,0Ah,24h |
@@: |
mov dx,str |
else |
mov dx,arg |
end if |
mov ah,9 |
int 21h |
} |
The above macro is designed for displaying messages in DOS programs. When the |
argument of this macro is some number, label, or variable, the string from |
that address is displayed, but when the argument is a quoted string, the |
created code will display that string followed by the carriage return and |
line feed. |
It is also possible to put a declaration of macroinstruction inside another |
macroinstruction, so one macro can define another, but there is a problem |
with such definitions caused by the fact, that "}" character cannot occur |
inside the macroinstruction, as it always means the end of definition. To |
overcome this problem, the escaping of symbols inside macroinstruction can be |
used. This is done by placing one or more backslashes in front of any other |
symbol (even the special character). Preprocessor sees such sequence as a |
single symbol, but each time it meets such symbol during the macroinstruction |
processing, it cuts the backslash character from the front of it. For example |
"\{" is treated as single symbol, but during processing of the macroinstruction |
it becomes the "{" symbol. This allows to put one definition of |
macroinstruction inside another: |
macro ext instr |
{ |
macro instr op1,op2,op3 |
\{ |
if op3 eq |
instr op1,op2 |
else |
instr op1,op2 |
instr op2,op3 |
end if |
\} |
} |
ext add |
ext sub |
The macro "ext" is defined correctly, but when it is used, the "\{" and "\}" |
become the "{" and "}" symbols. So when the "ext add" is processed, the |
contents of macro becomes valid definition of a macroinstruction and this way |
the "add" macro becomes defined. In the same way "ext sub" defines the "sub" |
macro. The use of "\{" symbol wasn't really necessary here, but is done this |
way to make the definition more clear. |
If some directives specific to macroinstructions, like "local" or "common" |
are needed inside some macro embedded this way, they can be escaped in the same |
way. Escaping the symbol with more than one backslash is also allowed, which |
allows multiple levels of nesting the macroinstruction definitions. |
The another technique for defining one macroinstruction by another is to |
use the "fix" directive, which becomes useful when some macroinstruction only |
begins the definition of another one, without closing it. For example: |
macro tmacro [params] |
{ |
common macro params { |
} |
MACRO fix tmacro |
ENDM fix } |
defines an alternative syntax for defining macroinstructions, which looks like: |
MACRO stoschar char |
mov al,char |
stosb |
ENDM |
Note that symbol that has such customized definition must be defined with "fix" |
directive, because only the prioritized symbolic constants are processed before |
the preprocessor looks for the "}" character while defining the macro. This |
might be a problem if one needed to perform some additional tasks one the end |
of such definition, but there is one more feature which helps in such cases. |
Namely it is possible to put any directive, instruction or macroinstruction |
just after the "}" character that ends the macroinstruction and it will be |
processed in the same way as if it was put in the next line. |
2.3.4 Structures |
"struc" directive is a special variant of "macro" directive that is used to |
define data structures. Macroinstruction defined using the "struc" directive |
must be preceded by a label (like the data definition directive) when it's |
used. This label will be also attached at the beginning of every name starting |
with dot in the contents of macroinstruction. The macroinstruction defined |
using the "struc" directive can have the same name as some other |
macroinstruction defined using the "macro" directive, structure |
macroinstruction won't prevent the standard macroinstruction being processed |
when there is no label before it and vice versa. All the rules and features |
concerning standard macroinstructions apply to structure macroinstructions. |
Here is the sample of structure macroinstruction: |
struc point x,y |
{ |
.x dw x |
.y dw y |
} |
For example "my point 7,11" will define structure labeled "my", consisting of |
two variables: "my.x" with value 7 and "my.y" with value 11. |
If somewhere inside the definition of structure the name consisting of a |
single dot it found, it is replaced by the name of the label for the given |
instance of structure and this label will not be defined automatically in |
such case, allowing to completely customize the definition. The following |
example utilizes this feature to extend the data definition directive "db" |
with ability to calculate the size of defined data: |
struc db [data] |
{ |
common |
. db data |
.size = $ - . |
} |
With such definition "msg db 'Hello!',13,10" will define also "msg.size" |
constant, equal to the size of defined data in bytes. |
Defining data structures addressed by registers or absolute values should be |
done using the "virtual" directive with structure macroinstruction |
(see 2.2.4). |
"restruc" directive removes the last definition of the structure, just like |
"purge" does with macroinstructions and "restore" with symbolic constants. |
It also has the same syntax - should be followed by one or more names of |
structure macroinstructions, separated with commas. |
2.3.5 Repeating macroinstructions |
The "rept" directive is a special kind of macroinstruction, which makes given |
amount of duplicates of the block enclosed with braces. The basic syntax is |
"rept" directive followed by number (it cannot be an expression, since |
preprocessor doesn't do calculations, if you need repetitions based on values |
calculated by assembler, use one of the code repeating directives that are |
processed by assembler, see 2.2.3), and then block of source enclosed between |
the "{" and "}" characters. The simplest example: |
rept 5 { in al,dx } |
will make five duplicates of the "in al,dx" line. The block of instructions |
is defined in the same way as for the standard macroinstruction and any |
special operators and directives which can be used only inside |
macroinstructions are also allowed here. When the given count is zero, the |
block is simply skipped, as if you defined macroinstruction but never used |
it. The number of repetitions can be followed by the name of counter symbol, |
which will get replaced symbolically with the number of duplicate currently |
generated. So this: |
rept 3 counter |
{ |
byte#counter db counter |
} |
will generate lines: |
byte1 db 1 |
byte2 db 2 |
byte3 db 3 |
The repetition mechanism applied to "rept" blocks is the same as the one used |
to process multiple groups of arguments for macroinstructions, so directives |
like "forward", "common" and "reverse" can be used in their usual meaning. |
Thus such macroinstruction: |
rept 7 num { reverse display `num } |
will display digits from 7 to 1 as text. The "local" directive behaves in the |
same way as inside macroinstruction with multiple groups of arguments, so: |
rept 21 |
{ |
local label |
label: loop label |
} |
will generate unique label for each duplicate. |
The counter symbol by default counts from 1, but you can declare different |
base value by placing the number preceded by colon immediately after the name |
of counter. For example: |
rept 8 n:0 { pxor xmm#n,xmm#n } |
will generate code which will clear the contents of eight SSE registers. |
You can define multiple counters separated with commas, and each one can have |
different base. |
The "irp" directive iterates the single argument through the given list of |
parameters. The syntax is "irp" followed by the argument name, then the comma |
and then the list of parameters. The parameters are specified in the same |
way like in the invocation of standard macroinstruction, so they have to be |
separated with commas and each one can be enclosed with the "<" and ">" |
characters. Also the name of argument may be followed by "*" to mark that it |
cannot get an empty value. Such block: |
irp value, 2,3,5 |
{ db value } |
will generate lines: |
db 2 |
db 3 |
db 5 |
The "irps" directive iterates through the given list of symbols, it should |
be followed by the argument name, then the comma and then the sequence of any |
symbols. Each symbol in this sequence, no matter whether it is the name |
symbol, symbol character or quoted string, becomes an argument value for one |
iteration. If there are no symbols following the comma, no iteration is done |
at all. This example: |
irps reg, al bx ecx |
{ xor reg,reg } |
will generate lines: |
xor al,al |
xor bx,bx |
xor ecx,ecx |
The blocks defined by the "irp" and "irps" directives are also processed in |
the same way as any macroinstructions, so operators and directives specific |
to macroinstructions may be freely used also in this case. |
2.3.6 Conditional preprocessing |
"match" directive causes some block of source to be preprocessed and passed |
to assembler only when the given sequence of symbols matches the specified |
pattern. The pattern comes first, ended with comma, then the symbols that have |
to be matched with the pattern, and finally the block of source, enclosed |
within braces as macroinstruction. |
There are the few rules for building the expression for matching, first is |
that any of symbol characters and any quoted string should be matched exactly |
as is. In this example: |
match +,+ { include 'first.inc' } |
match +,- { include 'second.inc' } |
the first file will get included, since "+" after comma matches the "+" in |
pattern, and the second file won't be included, since there is no match. |
To match any other symbol literally, it has to be preceded by "=" character |
in the pattern. Also to match the "=" character itself, or the comma, the |
"==" and "=," constructions have to be used. For example the "=a==" pattern |
will match the "a=" sequence. |
If some name symbol is placed in the pattern, it matches any sequence |
consisting of at least one symbol and then this name is replaced with the |
matched sequence everywhere inside the following block, analogously to the |
parameters of macroinstruction. For instance: |
match a-b, 0-7 |
{ dw a,b-a } |
will generate the "dw 0,7-0" instruction. Each name is always matched with |
as few symbols as possible, leaving the rest for the following ones, so in |
this case: |
match a b, 1+2+3 { db a } |
the "a" name will match the "1" symbol, leaving the "+2+3" sequence to be |
matched with "b". But in this case: |
match a b, 1 { db a } |
there will be nothing left for "b" to match, so the block won't get processed |
at all. |
The block of source defined by match is processed in the same way as any |
macroinstruction, so any operators specific to macroinstructions can be used |
also in this case. |
What makes "match" directive more useful is the fact, that it replaces the |
symbolic constants with their values in the matched sequence of symbols (that |
is everywhere after comma up to the beginning of the source block) before |
performing the match. Thanks to this it can be used for example to process |
some block of source under the condition that some symbolic constant has the |
given value, like: |
match =TRUE, DEBUG { include 'debug.inc' } |
which will include the file only when the symbolic constant "DEBUG" was |
defined with value "TRUE". |
2.3.7 Order of processing |
When combining various features of the preprocessor, it's important to know |
the order in which they are processed. As it was already noted, the highest |
priority has the "fix" directive and the replacements defined with it. This |
is done completely before doing any other preprocessing, therefore this |
piece of source: |
V fix { |
macro empty |
V |
V fix } |
V |
becomes a valid definition of an empty macroinstruction. It can be interpreted |
that the "fix" directive and prioritized symbolic constants are processed in |
a separate stage, and all other preprocessing is done after on the resulting |
source. |
The standard preprocessing that comes after, on each line begins with |
recognition of the first symbol. It begins with checking for the preprocessor |
directives, and when none of them is detected, preprocessor checks whether the |
first symbol is macroinstruction. If no macroinstruction is found, it moves |
to the second symbol of line, and again begins with checking for directives, |
which in this case is only the "equ" directive, as this is the only one that |
occurs as the second symbol in line. If there's no directive, the second |
symbol is checked for the case of structure macroinstruction and when none |
of those checks gives the positive result, the symbolic constants are replaced |
with their values and such line is passed to the assembler. |
To see it on the example, assume that there is defined the macroinstruction |
called "foo" and the structure macroinstruction called "bar". Those lines: |
foo equ |
foo bar |
would be then both interpreted as invocations of macroinstruction "foo", since |
the meaning of the first symbol overrides the meaning of second one. |
The macroinstructions generate the new lines from their definition blocks, |
replacing the parameters with their values and then processing the "#" and "`" |
operators. The conversion operator has the higher priority than concatenation. |
After this is completed, the newly generated line goes through the standard |
preprocessing, as described above. |
Though the symbolic constants are usually only replaced in the lines, where |
no preprocessor directives nor macroinstructions has been found, there are some |
special cases where those replacements are performed in the parts of lines |
containing directives. First one is the definition of symbolic constant, where |
the replacements are done everywhere after the "equ" keyword and the resulting |
value is then assigned to the new constant (see 2.3.2). The second such case |
is the "match" directive, where the replacements are done in the symbols |
following comma before matching them with pattern. These features can be used |
for example to maintain the lists, like this set of definitions: |
list equ |
macro append item |
{ |
match any, list \{ list equ list,item \} |
match , list \{ list equ item \} |
} |
The "list" constant is here initialized with empty value, and the "append" |
macroinstruction can be used to add the new items into this list, separating |
them with commas. The first match in this macroinstruction occurs only when |
the value of list is not empty (see 2.3.6), in such case the new value for the |
list is the previous one with the comma and the new item appended at the end. |
The second match happens only when the list is still empty, and in such case |
the list is defined to contain just the new item. So starting with the empty |
list, the "append 1" would define "list equ 1" and the "append 2" following it |
would define "list equ 1,2". One might then need to use this list as the |
parameters to some macroinstruction. But it cannot be done directly - if "foo" |
is the macroinstruction, then "foo list" would just pass the "list" symbol |
as a parameter to macro, since symbolic constants are not unrolled at this |
stage. For this purpose again "match" directive comes in handy: |
match params, list { foo params } |
The value of "list", if it's not empty, matches the "params" keyword, which is |
then replaced with matched value when generating the new lines defined by the |
block enclosed with braces. So if the "list" had value "1,2", the above line |
would generate the line containing "foo 1,2", which would then go through the |
standard preprocessing. |
There is one more special case - when preprocessor goes to checking the |
second symbol in the line and it happens to be the colon character (what is |
then interpreted by assembler as definition of a label), it stops in this |
place and finishes the preprocessing of the first symbol (so if it's the |
symbolic constant it gets unrolled) and if it still appears to be the label, |
it performs the standard preprocessing starting from the place after the |
label. This allows to place preprocessor directives and macroinstructions |
after the labels, analogously to the instructions and directives processed |
by assembler, like: |
start: include 'start.inc' |
However if the label becomes broken during preprocessing (for example when |
it is the symbolic constant with empty value), only replacing of the symbolic |
constants is continued for the rest of line. |
It should be remembered, that the jobs performed by preprocessor are the |
preliminary operations on the texts symbols, that are done in a simple |
single pass before the main process of assembly. The text that is the |
result of preprocessing is passed to assembler, and it then does its |
multiple passes on it. Thus the control directives, which are recognized and |
processed only by the assembler - as they are dependent on the numerical |
values that may even vary between passes - are not recognized in any way by |
the preprocessor and have no effect on the preprocessing. Consider this |
example source: |
if 0 |
a = 1 |
b equ 2 |
end if |
dd b |
When it is preprocessed, they only directive that is recognized by the |
preprocessor is the "equ", which defines symbolic constant "b", so later |
in the source the "b" symbol is replaced with the value "2". Except for this |
replacement, the other lines are passes unchanged to the assembler. So |
after preprocessing the above source becomes: |
if 0 |
a = 1 |
end if |
dd 2 |
Now when assembler processes it, the condition for the "if" is false, and |
the "a" constant doesn't get defined. However symbolic constant "b" was |
processed normally, even though its definition was put just next to the one |
of "a". So because of the possible confusion you should be very careful |
every time when mixing the features of preprocessor and assembler - always |
try to imagine what your source will become after the preprocessing, and |
thus what the assembler will see and do its multiple passes on. |
2.4 Formatter directives |
These directives are actually also a kind of control directives, with the |
purpose of controlling the format of generated code. |
"format" directive followed by the format identifier allows to select the |
output format. This directive should be put at the beginning of the source. |
Default output format is a flat binary file, it can also be selected by using |
"format binary" directive. |
"use16" and "use32" directives force the assembler to generate 16-bit or |
32-bit code, omitting the default setting for selected output format. "use64" |
enables generating the code for the long mode of x86-64 processors. |
Below are described different output formats with the directives specific to |
these formats. |
2.4.1 MZ executable |
To select the MZ output format, use "format MZ" directive. The default code |
setting for this format is 16-bit. |
"segment" directive defines a new segment, it should be followed by label, |
which value will be the number of defined segment, optionally "use16" or |
"use32" word can follow to specify whether code in this segment should be |
16-bit or 32-bit. The origin of segment is aligned to paragraph (16 bytes). |
All the labels defined then will have values relative to the beginning of this |
segment. |
"entry" directive sets the entry point for MZ executable, it should be |
followed by the far address (name of segment, colon and the offset inside |
segment) of desired entry point. |
"stack" directive sets up the stack for MZ executable. It can be followed by |
numerical expression specifying the size of stack to be created automatically |
or by the far address of initial stack frame when you want to set up the stack |
manually. When no stack is defined, the stack of default size 4096 bytes will |
be created. |
"heap" directive should be followed by a 16-bit value defining maximum size |
of additional heap in paragraphs (this is heap in addition to stack and |
undefined data). Use "heap 0" to always allocate only memory program really |
needs. Default size of heap is 65535. |
2.4.2 Portable Executable |
To select the Portable Executable output format, use "format PE" directive, it |
can be followed by additional format settings: use "console", "GUI" or |
"native" operator selects the target subsystem (floating point value |
specifying subsystem version can follow), "DLL" marks the output file as a |
dynamic link library. Then can follow the "at" operator and the numerical |
expression specifying the base of PE image and then optionally "on" operator |
followed by the quoted string containing file name selects custom MZ stub for |
PE program (when specified file is not a MZ executable, it is treated as a |
flat binary executable file and converted into MZ format). The default code |
setting for this format is 32-bit. The example of fully featured PE format |
declaration: |
format PE GUI 4.0 DLL at 7000000h on 'stub.exe' |
To create PE file for the x86-64 architecture, use "PE64" keyword instead of |
"PE" in the format declaration, in such case the long mode code is generated |
by default. |
"section" directive defines a new section, it should be followed by quoted |
string defining the name of section, then one or more section flags can |
follow. Available flags are: "code", "data", "readable", "writeable", |
"executable", "shareable", "discardable", "notpageable". The origin of section |
is aligned to page (4096 bytes). Example declaration of PE section: |
section '.text' code readable executable |
Among with flags also one of the special PE data identifiers can be specified |
to mark the whole section as a special data, possible identifiers are |
"export", "import", "resource" and "fixups". If the section is marked to |
contain fixups, they are generated automatically and no more data needs to be |
defined in this section. Also resource data can be generated automatically |
from the resource file, it can be achieved by writing the "from" operator and |
quoted file name after the "resource" identifier. Below are the examples of |
sections containing some special PE data: |
section '.reloc' data discardable fixups |
section '.rsrc' data readable resource from 'my.res' |
"entry" directive sets the entry point for Portable Executable, the value of |
entry point should follow. |
"stack" directive sets up the size of stack for Portable Executable, value |
of stack reserve size should follow, optionally value of stack commit |
separated with comma can follow. When stack is not defined, it's set by |
default to size of 4096 bytes. |
"heap" directive chooses the size of heap for Portable Executable, value of |
heap reserve size should follow, optionally value of heap commit separated |
with comma can follow. When no heap is defined, it is set by default to size |
of 65536 bytes, when size of heap commit is unspecified, it is by default set |
to zero. |
"data" directive begins the definition of special PE data, it should be |
followed by one of the data identifiers ("export", "import", "resource" or |
"fixups") or by the number of data entry in PE header. The data should be |
defined in next lines, ended with "end data" directive. When fixups data |
definition is chosen, they are generated automatically and no more data needs |
to be defined there. The same applies to the resource data when the "resource" |
identifier is followed by "from" operator and quoted file name - in such case |
data is taken from the given resource file. |
The "rva" operator can be used inside the numerical expressions to obtain |
the RVA of the item addressed by the value it is applied to. |
2.4.3 Common Object File Format |
To select Common Object File Format, use "format COFF" or "format MS COFF" |
directive whether you want to create classic or Microsoft's COFF file. The |
default code setting for this format is 32-bit. To create the file in |
Microsoft's COFF format for the x86-64 architecture, use "format MS64 COFF" |
setting, in such case long mode code is generated by default. |
"section" directive defines a new section, it should be followed by quoted |
string defining the name of section, then one or more section flags can |
follow. Section flags available for both COFF variants are "code" and "data", |
while "readable", "writeable", "executable", "shareable", "discardable", |
"notpageable", "linkremove" and "linkinfo" are flags available only with |
Microsoft COFF variant. |
By default section is aligned to double word (four bytes), in case of |
Microsoft COFF variant other alignment can be specified by providing the |
"align" operator followed by alignment value (any power of two up to 8192) |
among the section flags. |
"extrn" directive defines the external symbol, it should be followed by the |
name of symbol and optionally the size operator specifying the size of data |
labeled by this symbol. The name of symbol can be also preceded by quoted |
string containing name of the external symbol and the "as" operator. |
Some example declarations of external symbols: |
extrn exit |
extrn '__imp__MessageBoxA@16' as MessageBox:dword |
"public" directive declares the existing symbol as public, it should be |
followed by the name of symbol, optionally it can be followed by the "as" |
operator and the quoted string containing name under which symbol should be |
available as public. Some examples of public symbols declarations: |
public main |
public start as '_start' |
2.4.4 Executable and Linkable Format |
To select ELF output format, use "format ELF" directive. The default code |
setting for this format is 32-bit. To create ELF file for the x86-64 |
architecture, use "format ELF64" directive, in such case the long mode code is |
generated by default. |
"section" directive defines a new section, it should be followed by quoted |
string defining the name of section, then can follow one or both of the |
"executable" and "writeable" flags, optionally also "align" operator followed |
by the number specifying the alignment of section (it has to be the power of |
two), if no alignment is specified, the default value is used, which is 4 or 8, |
depending on which format variant has been chosen. |
"extrn" and "public" directives have the same meaning and syntax as when the |
COFF output format is selected (described in previous section). |
The "rva" operator can be used also in the case of this format (however not |
when target architecture is x86-64), it converts the address into the offset |
relative to the GOT table, so it may be useful to create position-independent |
code. |
To create executable file, follow the format choice directive with the |
"executable" keyword. It allows to use "entry" directive followed by the value |
to set as entry point of program. On the other hand it makes "extrn" and |
"public" directives unavailable, and instead of "section" there should be the |
"segment" directive used, followed only by one or more segment permission |
flags. The origin of segment is aligned to page (4096 bytes), and available |
flags for are: "readable", "writeable" and "executable". |
EOF |
/data/rus/docs/GNU.TXT |
---|
0,0 → 1,447 |
GNU |
¥àá¨ï 2 (¨îì 1991 £.) |
Copyright (C) 1989, 1991 Free Software Foundation, Inc. |
675 Mass Ave, Cambridge, MA 02139, USA |
ë© «¨æ¥§¨®ë© ¤®ªã¬¥â à §à¥è ¥âáï ª®¯¨à®¢ âì ¨ à á¯à®áâà ïâì |
¥£® â®çë¥ ª®¯¨¨. ®á¨âì ª ª¨¥-«¨¡® ¨§¬¥¥¨ï ¢ ⥪áâ ¤ ®£® ¤®ªã¬¥â |
§ ¯à¥é ¥âáï. |
¢®¤ ï ç áâì |
¨æ¥§¨®ë¥ ᮣ« è¥¨ï ¯®«ì§®¢ ¨¥ ¡®«ìè¨á⢮¬ ¯à®£à ¬¬ëå ¯à®¤ãªâ®¢ |
á®áâ ¢«¥ë â ª, çâ®¡ë ¨áª«îç¨âì ¢®§¬®¦®áâì ᮢ¬¥á⮣® ¯®«ì§®¢ ¨ï ¨¬¨ ¨«¨ |
¨å ¨§¬¥¥¨ï. â ¤ àâ ï ¯ã¡«¨ç ï «¨æ¥§¨ï GNU, ¯à®â¨¢, £ à â¨àã¥â ¢ ¬ |
¢®§¬®¦®áâì ᢮¡®¤® ᮢ¬¥áâ® ¨á¯®«ì§®¢ âì ¨ ᢮¡®¤® ¨§¬¥ïâì ᢮¡®¤® |
à á¯à®áâà ï¥¬ë¥ ¯à®£à ¬¬ë¥ ¯à®¤ãªâë - â® ¥áâì ®¡¥á¯¥ç¨¢ ¥â ¢á¥¬ |
¯®«ì§®¢ â¥«ï¬ ¥®£à ¨ç¥ë© ¤®áâ㯠ª ¯à®£à ¬¬ë¬ ¯à®¤ãªâ ¬. ¥©á⢨¥ ¤ ®© |
áâ ¤ à⮩ ¯ã¡«¨ç®© «¨æ¥§¨¨ à á¯à®áâà ï¥âáï ¡®«ìèãî ç áâì ¯à®£à ¬¬ëå |
¯à®¤ãªâ®¢, ¢ë¯ãé¥ëå "Free Software Foundation" ¨ «î¡ë¥ ¤à㣨¥ ¯à®£à ¬¬ë, |
¢â®àë ª®â®àëå ¯®§¢®«ïî⠨ᯮ«ì§®¢ âì ¨å â ª¨¬ ®¡à §®¬. ( ¥ª®â®àë¥ ¤à㣨¥ |
à §à ¡®âª¨ "Free Software Foundation" à á¯à®áâà ï¥âáï ¤¥©á⢨¥ áâ ¤ à⮩ |
¯ã¡«¨ç®© «¨æ¥§¨¨ ¡¨¡«¨®â¥ª¨ GNU.) |
ë ¬®¦¥â¥ ¨á¯®«ì§®¢ âì íâã «¨æ¥§¨î ¨ ¯à¨¬¥¨â¥«ì® ª à §à ¡®â ë¬ |
¢ ¬¨ ¯à®£à ¬¬ë¬ ¯à®¤ãªâ ¬. |
®¢®àï ® ᢮¡®¤®© à á¯à®áâà 塞®á⨠¯à®£à ¬¬ëå ¯à®¤ãªâ å, ¬ë ¨¬¥¥¬ ¢ ¢¨¤ã |
®âáãâá⢨¥ ®£à ¨ç¥¨© à á¯à®áâà ¥¨¥, ¥ ¡¥á¯« â®áâì à á¯à®áâà ¥¨ï. |
è¨ áâ ¤ àâë¥ ¯ã¡«¨çë¥ «¨æ¥§¨¨ á®áâ ¢«¥ë á ⥬ à áç¥â®¬, ç⮡ë |
®¡¥á¯¥ç¨âì ¯®«ì§®¢ â¥«î ¢®§¬®¦®áâì ᢮¡®¤® à á¯à®áâà ïâì ª®¯¨¨ |
᢮¡®¤® à á¯à®áâà 塞ëå ¯à®£à ¬¬ëå ¯à®¤ãªâ®¢ (¨ ¯à¨ ¦¥« ¨¨ ¢§¨¬ âì ¯« âã |
§ íâã ãá«ã£ã); ¯®«ã票¥, ¥á«¨ ® ⮣® § å®ç¥â, ¨á室®© ¯à®£à ¬¬ë; |
¢®§¬®¦®áâì ¢®á¨âì ¨§¬¥¥¨ï ¢ ¯à®£à ¬¬ë¥ ¯à®¤ãªâë ¨«¨ ¨á¯®«ì§®¢ âì ¨å |
äà £¬¥âë ¢ ®¢ëå ᢮¡®¤® à á¯à®áâà 塞ëå ¯à®£à ¬¬ å, ¨ ¤®¢¥á⨠¤® |
ᢥ¤¥¨ï ¯®«ì§®¢ ⥫ï, çâ® ® ¢á¥ íâ® ¬®¦¥â ¤¥« âì. |
â®¡ë § é¨â¨âì è¨ ¯à ¢ íâ®, ¬ë ¢¢®¤¨¬ àï¤ ®£à ¨ç¥¨©, ¨áª«îç îé¨å |
ª ªãî ¡ë â® ¨ ¡ë«® ¢®§¬®¦®áâì ®âª § âì ¬ ¢ è¨å ¯à ¢ å ¨«¨ âॡ®¢ âì ®â |
á ®âª § âìáï ®â íâ¨å ¯à ¢. ⨠®£à ¨ç¥¨ï « £ îâ á ®¯à¥¤¥«¥ãî |
®â¢¥âá⢥®áâì ¢ á«ãç ¥, ¥á«¨ ë à á¯à®áâà ï¥â¥ ª®¯¨¨ ¯à®£à ¬¬®£® |
¯à®¤ãªâ ¨«¨ ¢¨¤®¨§¬¥ï¥â¥ (¬®¤¨ä¨æ¨àã¥â¥) ¥£®. |
ç áâ®áâ¨, à á¯à®áâà ïï ª®¯¨¨ ¯®¤®¡®© ¯à®£à ¬¬ë, ¡¥á¯« â® ¨«¨ § ¯« âã, |
ë ¤®«¦ë ¯¥à¥¤ âì ®¢®¬ã ®¡« ¤ â¥«î ¢á¥ ¯à ¢ , ª®â®à묨 ¯®«ì§ã¥â¥áì. |
¬ â ª¦¥ á«¥¤ã¥â ¯®§ ¡®â¨âáï, çâ®¡ë ® ¯®«ã稫 ¨áå®¤ë¥ ª®¤ë ¯à®£à ¬¬ë |
¨«¨ ¨¬¥« ¢®§¬®¦®áâì ¯à¨ ¦¥« ¨¨ ¯®«ãç¨âì ¨å, â ª¦¥ ®§ ª®¬¨âì ®¢®£® |
®¡« ¤ ⥫ï á ãá«®¢¨ï¬¨ ¤ ®£® «¨æ¥§¨®®£® ᮣ« 襨ï, ç⮡ë |
® § « ᢮¨ ¯à ¢ . |
«ï § é¨âë ¢ è¨å ¯à ¢ ¬ë: (1) ®áâ ¢«ï¥¬ § ᮡ®© ¢â®à᪨¥ ¯à ¢ |
¯à®£à ¬¬ë© ¯à®¤ãªâ ¨ (2) ¯à¨« £ ¥¬ ª ¥¬ã ¤ ®¥ «¨æ¥§¨®®¥ ᮣ« 襨¥, |
®ä¨æ¨ «ì® à §à¥è î饥 ¬ ª®¯¨à®¢ âì, à á¯à®áâà ïâì ¨\¨«¨ ¬®¤¨ä¨æ¨à®¢ âì |
íâ®â ¯à®£à ¬¬ë© ¯à®¤ãªâ. ஬¥ ⮣®, ¤«ï ¡¥§®¯ á®á⨠¢á¥ à §à ¡®â稪®¢ |
â ª¨å ¯à®£à ¬¬ëå ¯à®¤ãªâ®¢, ¬ë ¤®¢®¤¨¬ ¤® ¢á¥®¡é¥£® ᢥ¤¥¨ï, çâ® £ à ⨩ |
í⨠¯à®£à ¬¬ë¥ ¯à®¤ãªâë ¥ áãé¥áâ¢ã¥â. |
᫨ ªâ®-«¨¡® ¢®á¨â ¨§¬¥¥¨ï ¢ ¯à®£à ¬¬ë© ¯à®¤ãªâ ¨ à á¯à®áâà ï¥â ¥£® |
¢ ¨§¬¥¥®¬ ¢¨¤¥, ® ¤®«¦¥, çâ®¡ë ¢®§¬®¦ë¥ ¢®§¨ªè¨¥ ¢ á¢ï§¨ á í⨬ |
¯à®¡«¥¬ë ¥ ®âà §¨«¨áì ९ãâ 樨 ¢â®à®¢ ¨á室®£® ¯à®¤ãªâ , á®®¡é âì |
®¢ë¬ ®¡« ¤ ⥫ï¬, çâ® ®¨ ¯®«ãç îâ ¥ ®à¨£¨ «. |
ᮢ ï ã£à®§ ¤«ï ¢á¥å ᢮¡®¤® à á¯à®áâà 塞ëå ¯à®£à ¬¬ëå ¯à®¤ãªâ®¢ - |
¯ â¥â®¥ § ª®®¤ ⥫ìá⢮. ¥¤¨áâਡãâ®àë ᢮¡®¤® à á¯à®áâà 塞®£® |
¯à®£à ¬¬®£® ¯à®¤ãªâ ¬®£ãâ ç áâë¬ ¯®à浪®¬ ¯®«ãç¨âì ¯ â¥âãî «¨æ¥§¨î, |
¯à¥¢à ⨢ ⥬ á ¬ë¬ íâ®â ¯à®£à ¬¬ë© ¯à®¤ãªâ ¢ ᢮î ᮡá⢥®áâì. |
® ¨§¡¥¦ ¨¥ ¢®§¬®¦ëå îਤ¨ç¥áª¨å ¯à®â¨¢®à¥ç¨© ¬ë § 塞, çâ® «î¡®© |
â ª®© ¯ â¥â ¤®«¦¥ ¡ëâì «¨æ¥§¨à®¢ ¤«ï ¢á¥®¡é¥£® ᢮¡®¤®£® |
¨á¯®«ì§®¢ ¨ï ¨«¨ ¥ «¨æ¥§¨à®¢ ¢®®¡é¥. |
«¥¥ ¯à¨¢®¤ïâáï â®çë¥ ãá«®¢¨ï ¨§£®â®¢«¥¨ï ª®¯¨©, à á¯à®áâà ¥¨ï |
¨ ¬®¤¨ä¨ª 樨. |
, |
0. ¥©á⢨¥ ¤ ®£® «¨æ¥§¨®®£® ᮣ« 襨ï à á¯à®áâà ï¥âáï ¢á¥ |
¯à®£à ¬¬ë¥ ¯à®¤ãªâë ¨«¨ ¨ë¥ à §à ¡®âª¨, ¢ ª®â®àëå ¢« ¤¥«ì楬 ¢â®à᪨å |
¯à ¢ 㪠§ ®, çâ® ¤ ï ¯à®£à ¬¬ (à §à ¡®âª ) ¬®¦¥â à á¯à®áâà ïâìáï |
⮫쪮 ãá«®¢¨ïå ¤ ®£® áâ ¤ à⮣® ¯ã¡«¨ç®£® «¨æ¥§¨®®£® ᮣ« 襨ï. |
¥à¬¨ "à®£à ¬¬ë© ¯à®¤ãªâ", 㯮âॡ«ï¥¬ë© ¨¦¥, ¢ ¯à¨¬¥¥¨¨ ª â ª®© |
¯à®£à ¬¬¥ (à §à ¡®âª¥) ¨ â¥à¬¨ "à §à ¡®âª ®á®¢¥ à®£à ¬¬®£® |
¯à®¤ãªâ " ¯®¤à §ã¬¥¢ îâ «¨¡® á ¬ à®£à ¬¬ë© ¯à®¤ãªâ, «¨¡® «î¡ãî |
¯à®¨§¢¥¤¥ãî ¥¥ ®á®¢¥ à §à ¡®âªã, § é¨é ¥¬ãî § ª®®¬ ®¡ ¢â®à᪮¬ |
¯à ¢¥, â® ¥áâì à §à ¡®âªã, ᮤ¥à¦ éãî à®£à ¬¬ë© ¯à®¤ãªâ ¨«¨ ¥£® |
ç á⨠- ¡¥§ ¨§¬¥¥¨© ¨«¨ ¬®¤¨ä¨æ¨à®¢ ë¥ ¨\¨«¨ ¯¥à¥¢¥¤¥ë¥ ¤à㣮© |
ï§ëª. ( ¤ «ì¥©è¥¬ ¯®ï⨥ "¯¥à¥¢®¤" ¢ á ¬®¬ è¨à®ª®¬ á¬ëá«¥ ¢ª«îç ¥âáï |
¢ ¯®ï⨥ "¬®¤¨ä¨ª æ¨ï" ¨«¨ "¨§¬¥¥¨¥".) |
ª ¯à¨ïâ® ¢® ¢á¥å «¨æ¥§¨®ëå ᮣ« 襨ïå, ®® ¤à¥á®¢ ® ¬ ¨ |
§ ª«îç ¥âáï á ¬¨. |
®¥ «¨æ¥§¨®®¥ ᮣ« 襨¥ à á¯à®áâà ï¥âáï ⮫쪮 ¨§£®â®¢«¥¨¥ |
ª®¯¨©, à á¯à®áâà ¥¨¥ ¨ ¬®¤¨ä¨ª æ¨î; ¨ë¥ ¢¨¤ë ¤¥©á⢨© ¤ à®£à ¬¬ë¬ |
¯à®¤ãªâ®¬ ¢ë室ïâ § ¥£® à ¬ª¨. ¥¯®á।á⢥® ¨á¯®«ì§®¢ ¨¥ à®£à ¬¬®£® |
¯à®¤ãªâ ¥ ®£à ¨ç¨¢ ¥âáï ¨ç¥¬. ¥©á⢨¥ «¨æ¥§¨®®£® ᮣ« 襨ï |
à á¯à®áâà ï¥âáï १ã«ìâ âë ¨á¯®«ì§®¢ ¨ï à®£à ¬¬®£® ¯à®¤ãªâ «¨èì |
¢ ⮬ á«ãç ¥, ¥á«¨ ®¨ ¯à¥¤áâ ¢«ïîâ ᮡ®© à §à ¡®âªã, ®á®¢ ãî í⮬ |
à®£à ¬¬®¬ ¯à®¤ãªâ¥ (¢¥ § ¢¨á¨¬®á⨠®â ⮣®, ïîâáï «¨ ®¨ १ã«ìâ ⮬ |
¨á¯®«¥¨ï à®£à ¬¬®£® ¯à®¤ãªâ ). ®«¥¥ â®ç® íâ® ®¯à¥¤¥«ï¥âáï |
¢®§¬®¦®áâﬨ á ¬®£® à®£à ¬¬®£® ¯à®¤ãªâ . |
1. §à¥è ¥âáï ¤¥« âì ª®¯¨¨ ¨ à á¯à®áâà ïâì â®çë¥ ª®¯¨¨ ¨á室ëå ª®¤®¢ |
à®£à ¬¬®£® ¯à®¤ãªâ ¢ ⮬ ¢¨¤¥, ¢ ª ª®¬ ë ¨å ¯®«ã稫¨, «î¡®¬ ®á¨â¥«¥ |
¯à¨ ãá«®¢¨¨, çâ® ª ¦¤ãî ª®¯¨î ë á ¡¦ ¥â¥ - ¨ ®¡à é ¥â¥ íâ® ¢¨¬ ¨¥ |
®¢®£® ®¡« ¤ ⥫ï - 㯮¬¨ ¨ï¬¨ ®¡ ¢â®à᪮¬ ¯à ¢¥ ¨ ®âª §®¬ ®â £ à ⨩; |
á®åà ï¥â¥ ¡¥§ ¨§¬¥¥¨© ¢á¥, ®â®áï饥áï ª ¤ ®¬ã «¨æ¥§¨®®¬ã ᮣ« 襨î |
¨ ®âáãâáâ¢¨î ª ª¨å-«¨¡® £ à ⨩, ¨ ¯¥à¥¤ ¥â¥ ¢á¥¬ áâ®à®¨¬ ¯®«ãç â¥«ï¬ |
à®£à ¬¬®£® ¯à®¤ãªâ ª®¯¨î ¤ ®£® «¨æ¥§¨®®£® ᮣ« è¥¨ï ¢¬¥á⥠á |
à®£à ¬¬ë¬ ¯à®¤ãªâ®¬. ¥¯®á।á⢥® § á ¬ ªâ ¯¥à¥¤ ç¨ ª®¯¨¨ à §à¥è ¥âáï |
¢§¨¬ âì ¯« âã. ë ¬®¦¥â¥ â ª¦¥, ¯® ᢮¥¬ã ãᬮâ२î, ¯à¥¤« £ âì ¯« âãî |
¯®¤¤¥à¦ªã ¯® ¨á¯®«ì§®¢ ¨î ¯à®£à ¬¬®£® ¯à®¤ãªâ . |
2. á¢®î ª®¯¨î à®£à ¬¬®£® ¯à®¤ãªâ ¨ ¢ «î¡ãî ¥£® ç áâì ë ¬®¦¥â¥ |
¢®á¨âì ¨§¬¥¥¨ï, ᮧ¤ ¢ ï, â ª¨¬ ®¡à §®¬, à §à ¡®âªã ®á®¢¥ |
à®£à ¬¬®£® ¯à®¤ãªâ , ¨ ¤¥« âì ª®¯¨¨ ¨ à á¯à®áâà ïâì í⨠¬®¤¨ä¨ª 樨 |
¨«¨ à §à ¡®âª¨ ãá«®¢¨ïå, ¯¥à¥ç¨á«¥ëå ¢ëè¥, ¢ à §¤¥«¥ 1, ¢ ⮬ á«ãç ¥, |
¥á«¨ ¡ã¤ãâ ᮡ«î¤¥ë â ª¦¥ á«¥¤ãî騥 ãá«®¢¨ï: |
) ¢ë ®¡ï§ ë ¢ â®ç®á⨠㪠§ âì, ª ª¨¥ ä ©«ë ¡ë«¨ ¨§¬¥¥ë, çâ® ¨¬¥® |
¡ë«® ¨§¬¥¥®, ¨ ¯à®áâ ¢¨âì ¤ âã ¢¥á¥¨ï ¨§¬¥¥¨©. |
¡) «î¡ë¥ à á¯à®áâà ï¥¬ë¥ ¨«¨ ¯ã¡«¨ªã¥¬ë¥ ¢ ¬¨ à §à ¡®âª¨, ª®â®àë¥ |
¢ª«îç îâ ¢ ᥡï 楫¨ª®¬ à®£à ¬¬ë© ¯à®¤ãªâ ¨«¨ ª ª¨¥-«¨¡® ¥£® ç á⨠|
¨«¨ ᤥ« ë ®á®¢¥ à®£à ¬¬®£® ¯à®¤ãªâ ¨«¨ ª ª¨å-«¨¡® ¥£® ç á⥩, |
ë ¤®«¦ë ¢ ®¡ï§ ⥫쮬 ¯®à浪¥ «¨æ¥§¨à®¢ âì ãá«®¢¨ïå ¤ ®£® |
«¨æ¥§¨®®£® ᮣ« è¥¨ï ¢ 楫ì®áâ¨, ¡¥§ ¨§¬¥¥¨© (¢®§¬®¦®, á |
¤®¯®«¥¨ï¬¨). |
c) ᫨ ¬®¤¨ä¨æ¨à㥬 ï ¯à®£à ¬¬ ¯à¥¤ § ç¥ ¤«ï ¨â¥à ªâ¨¢®© à ¡®âë, |
â® ¯à¨ ç «¥ à ¡®âë á 楫ìî ¯®¤®¡®£® ¨â¥à ªâ¨¢®£® ¨á¯®«ì§®¢ ¨ï |
¢ ®¡ë箬 ¯®à浪¥ ®¡ï§ â¥«ì® ¤®«¦ ¡ëâì ¯®ª § ¨«¨ ¤®«¦® ¡ëâì |
á®®¡é¥® ® «¨ç¨¥ ¨ ¢®§¬®¦®á⨠¯à®á¬®âà 㢥¤®¬«¥¨© ®¡ ¢â®à᪮¬ ¯à ¢¥ ¨ |
®¡ ®âáãâá⢨¨ (¨«¨ «¨ç¨¨ ®¡¥á¯¥ç¨¢ ¥¬ëå ¢ ¬¨) £ à ⨩ ¨ ® ⮬, çâ® |
¯®«ì§®¢ ⥫¨ ¬®£ãâ ãá«®¢¨ïå ¤ ®£® ᮣ« è¥¨ï ¯¥à¥¤ ¢ âì ¯à®£à ¬¬ë© |
¯à®¤ãªâ ¤à㣨¬ ¯®«ì§®¢ ⥫ï¬, â ª¦¥ 㪠§ ¨ï ¤«ï ¯®«ì§®¢ ⥫ï, ª ª |
¯à®á¬®âà¥âì ª®¯¨î ¤ ®£® «¨æ¥§¨®®£® ᮣ« 襨ï. (᪫î票¥: ¥á«¨ |
à®£à ¬¬ë© ¯à®¤ãªâ à ¡®â ¥â ¨â¥à ªâ¨¢®, ® ¥ ᮤ¥à¦¨â ¨ä®à¬ æ¨î |
â ª®£® த , ¢ è à §à ¡®âª ®á®¢¥ â ª®£® à®£à ¬¬®£® ¯à®¤ãªâ ¥ |
®¡ï§ ¤¥¬®áâà¨à®¢ âì ¯®¤®¡ãî ¨ä®à¬ æ¨î.) |
⨠âॡ®¢ ¨ï à á¯à®áâà ïîâáï ¬®¤¨ä¨æ¨à®¢ ãî à §à ¡®âªã ¢ 楫®¬. |
᫨ «®£¨ç¥áª¨ ¢ë¤¥«¥ë¥ á®áâ ¢ë¥ ç á⨠襩 à §à ¡®âª¨ ¥ ®á®¢ ë |
í⮬ à®£à ¬¬ë© ¯à®¤ãªâ ¨ ¨å ¬®¦® ¯®«®¯à ¢® áç¨â âì ¥§ ¢¨á¨¬ë¬¨ |
¨ á ¬®áâ®ï⥫ì묨 à §à ¡®âª ¬¨, ¤ ®¥ «¨æ¥§¨®®¥ ᮣ« 襨¥ ¨ ¥¥ |
ãá«®¢¨ï ¥ à á¯à®áâà ïîâáï 㯮¬ïãâë¥ à §¤¥«ë ¢ â¥å á«ãç ïå, ª®£¤ ¢ë |
à á¯à®áâà ï¥â¥ ¨å ª ª ®â¤¥«ìë¥ à §à ¡®âª¨. |
᫨ ¦¥ í⨠á®áâ ¢ë¥ ç á⨠à á¯à®áâà ïîâáï ª ª ç áâì 楫®á⮩ à §à ¡®âª¨ |
®á®¢¥ à®£à ¬¬®£® ¯à®¤ãªâ , ¢áâ㯠¥â ¢ ᨫ㠤 ®¥ «¨æ¥§¨®®¥ |
ᮣ« 襨¥, à §à¥è î饥 «¨æ¥§¨à®¢ ¨¥ í⮩ 楫®á⮩ à §à ¡®âª¨, ¨, |
á«¥¤®¢ ⥫ì®, ¯à¨¬¥¨¬®¥ ¤«ï ¢á¥å ¨ ª á î饥áï ¢á类© ¥¥ ç áâ¨, ¢¥ |
§ ¢¨á¨¬®á⨠®â ⮣®, ªâ® ï¥âáï ¥¥ ¢â®à®¬. |
ª¨¬ ®¡à §®¬, 楫ìî ¤ ®£® à §¤¥« ï¥âáï ¥ § âì ® ᢮¨å ¯à ¢ å |
¨«¨ ®á¯®à¨âì ¢ è¨ ¯à ¢ à §à ¡®âªã, ¢ë¯®«¥ãî 楫¨ª®¬ ¨ ¯®«®áâìî |
¢ ¬¨. ª®à¥¥, ¢ è¨ ¬¥à¥¨ï ¢å®¤¨â £ à â¨à®¢ âì ᢮¥ ¯à ¢® |
ª®â஫¨à®¢ âì à á¯à®áâà ¥¨¥ ¯à®¨§¢®¤ëå ¨«¨ ᮢ®ªã¯ëå à §à ¡®â®ª, |
®á®¢ ëå à®£à ¬¬®¬ ¯à®¤ãªâ¥. |
à®á⮥ ᮢ¬¥á⮥ åà ¥¨¥ á à®£à ¬¬ë¬ ¯à®¤ãªâ®¬ (¨«¨ à §à ¡®âª®©, |
ᮧ¤ ®© ®á®¢¥ à®£à ¬¬®£® ¯à®¤ãªâ ) à §à ¡®â®ª, ᮧ¤ ëå ¥ |
®á®¢¥ à®£à ¬¬®£® ¯à®¤ãªâ , ®¤®¬ ãáâனá⢥ åà ¥¨ï ¨«¨ ®¤®¬ |
®á¨â¥«¥ ¥ ¯®¤¢®¤¨â íâã ¤àã£ãî à §à ¡®âªã ¯®¤ ¤¥©á⢨¥ ¤ ®£® «¨æ¥§¨®®£® |
ᮣ« 襨ï. |
ë ¬®¦¥â¥ ¤¥« âì ª®¯¨¨ ¨ à á¯à®áâà ïâì à®£à ¬¬ë© ¯à®¤ãªâ (¨«¨ ®á®¢ ãî |
¥¬ à §à ¡®âªã - á¬. à §¤¥« 2) ¢ ¢¨¤¥ ®¡ê¥ªâëå ª®¤®¢ ¨«¨ ¢ ¢¨¤¥ ¨á¯®«ï¥¬ëå |
¬®¤ã«¥© ¯à¨¢¥¤¥ëå ¢ëè¥ ãá«®¢¨ïå à §¤¥«®¢ 1 ¨ 2 ¢ ⮬ ¨ ⮫쪮 ⮬ |
á«ãç ¥, ¥á«¨ ¡ã¤¥â ¢ë¯®«¥® ®¤® ¨§ á«¥¤ãîé¨å ãá«®¢¨©: |
a) ë á ¡¦ ¥â¥ ª®¯¨î ¯®«ë¬¨ ᮮ⢥âáâ¢ãî騬¨ ¬ 訮-ç¨â ¥¬ë¬¨ |
¨á室묨 ª®¤ ¬¨, ª®â®àë¥ á«¥¤ã¥â à á¯à®áâà ïâì ¯à¨¢¥¤¥ëå ¢ëè¥ |
ãá«®¢¨ïå à §¤¥«®¢ 1 ¨ 2 ®á¨â¥«ïå, âà ¤¨æ¨®® ¨á¯®«ì§ã¥¬ëå ¤«ï |
¯¥à¥¤ ç¨ ¯à®£à ¬¬®£® ®¡¥á¯¥ç¥¨ï, |
¨«¨ |
b) ë á ¡¦ ¥â¥ ª®¯¨î ¯¨áì¬¥ë¬ ®¡ï§ ⥫ìá⢮¬, îਤ¨ç¥áª¨ |
¤¥©áâ¢ãî騬 ¢ â¥ç¥¨¥ ¥ ¬¥¥¥ âà¥å «¥â, ¢ë¤ ¢ âì «î¡®© âà¥â쥩 |
áâ®à®¥ § ¯« âã, ¥ ¯à¥¢ëè îéãî ¢ è¨ á®¡áâ¢¥ë¥ ¨§¤¥à¦ª¨, |
á¢ï§ ë¥ á 䨧¨ç¥áª¨¬ ªâ®¬ à á¯à®áâà ¥¨ï ¨á室ëå ª®¤®¢, ¯®«ãî |
¬ 訮-ç¨â ¥¬ãî ª®¯¨î ᮮ⢥âáâ¢ãîé¨å ¨á室ëå ª®¤®¢ ¯à®£à ¬¬®£® |
¯à®¤ãªâ , ¯®¤«¥¦ é¨å à á¯à®áâà ¥¨î ¯à¨¢¥¤¥ëå ¢ëè¥ ãá«®¢¨ïå |
à §¤¥«®¢ 1 ¨ 2, ®á¨â¥«¥, âà ¤¨æ¨®® ¨á¯®«ì§ã¥¬®¬ ¤«ï ¯¥à¥¤ ç¨ |
¯à®£à ¬¬®£® ®¡¥á¯¥ç¥¨ï, |
¨«¨ |
c) ¬¥áâ¥ á ª®¯¨¥© ë ¤ ¥â¥ á®®¡é¥ãî ¬ ¨ä®à¬ æ¨î ®â®á¨â¥«ì® |
⮣®, ª ª ¬®¦® ¯®«ãç¨âì ᮮ⢥âáâ¢ãî騥 ¨áå®¤ë¥ ª®¤ë. (â®â |
¢ ਠ⠤®¯ãá⨬ «¨èì ¢ á«ãç ¥ ¥ª®¬¬¥àç¥áª®£® à á¯à®áâà ¥¨ï ¨ |
⮫쪮 ¥á«¨ ë ¨ á ¬¨ ¯®«ã稫¨ ¯à®£à ¬¬ë© ¯à®¤ãªâ ¢ ¢¨¤¥ ®¡ê¥ªâëå |
ª®¤®¢ ¨«¨ ¨á¯®«ï¥¬ëå ¬®¤ã«¥© ¢¬¥áâ¥ á «®£¨ç®© ¨ä®à¬ 樥© ® |
¢®§¬®¦®á⨠¯®«ãç¥¨ï ¨á室ëå ª®¤®¢, 㤮¢«¥â¢®àïî饩 ¯à¨¢¥¤¥®¬ã |
¢ëè¥ ¯®¤à §¤¥«ã b.) |
"áå®¤ë¥ ª®¤ë" ¯à¨¬¥¨â¥«ì® ª à §à ¡®âª¥ ®§ ç ¥â âã ä®à¬ã à §à ¡®âª¨, |
¢ ª®â®àãî ¯à¥¤¯®çâ¨â¥«ì¥¥ ¢®á¨âì ¨§¬¥¥¨ï. á«ãç ¥ à §à ¡®âª¨, |
¯à¥¤áâ ¢«ïî饩 ᮡ®© ¨á¯®«ï¥¬ãî ¯à®£à ¬¬ã, â¥à¬¨ "¯®«ë¥ ¨áå®¤ë¥ ª®¤ë" |
®§ ç ¥â ᮢ®ªã¯®áâì ¨á室ëå ª®¤®¢ ¢á¥å á« £ îé¨å ¥¥ ¬®¤ã«¥©, ¯«îá ¢á¥ |
ä ©«ë, ¨¬¥î騥 ®â®è¥¨¥ ª ®¯¨á ¨î ¨â¥à䥩á , ¯«îá ¢á¥ ä ©«ë áæ¥ à¨¥¢, |
¨á¯®«ì§ã¥¬ë¥ ¤«ï ª®âà®«ï § ª®¬¯¨«ï樥© ¨ ᮧ¤ ¨¥¬ ¨á¯®«ï¥¬ëå ¬®¤ã«¥©. |
¤ ª®, ª ª ®á®¡®¥ ¨áª«î票¥, ¯à¨ à á¯à®áâà ¥¨¨ ¨á室ëå ª®¤®¢ ¥ |
âॡã¥âáï ¯à¨« £ âì ¨ç¥£® ¨§ ⮣®, çâ®, ª ª ¯à ¢¨«®, à á¯à®áâà ï¥âáï (¢ |
¨á室®© ¨«¨ ¡¨ ன ä®à¬¥) ¢¬¥áâ¥ á ®á®¢ë¬¨ ª®¬¯®¥â ¬¨ (ª®¬¯¨«ïâ®à, |
ï¤à® ¨ â.¯.) ®¯¥à 樮®© á¨á⥬ë, ª®â®àãî à ááç¨â ë ¨á¯®«ï¥¬ë¥ |
¬®¤ã«¨, ¥á«¨ «¨ç¨¥ ¨¬¥® íâ¨å ª®¬¯®¥â®¢ ¨¬¥® ¢ â ª®¬ ¢¨¤¥ ¥ |
ï¥âáï ®¡ï§ ⥫ìë¬ ¤«ï íâ¨å ¨á¯®«ï¥¬ëå ¬®¤ã«¥©. |
᫨ à á¯à®áâà ¥¨¥ ¨á¯®«ï¥¬ëå ¨«¨ ®¡ê¥ªâëå ª®¤®¢ ¯à®£à ¬¬ë ¯à®¨á室¨â |
¢ ä®à¬¥ ¯à¥¤«®¦¥¨ï ¢®§¬®¦®á⨠ᤥ« âì ª®¯¨î ¨§ ®¯à¥¤¥«¥®£® ¬¥áâ , |
â® ¢®§¬®¦®áâì ᤥ« âì ®ââ㤠¦¥ ª®¯¨î ¨á室ëå ª®¤®¢ ¯à®£à ¬¬ë à á楨¢ ¥âáï |
ª ª à á¯à®áâà ¥¨¥ ¨á室ëå ª®¤®¢ ¯à®£à ¬¬ë, ¤ ¦¥ ¥á«¨ âà¥âìî áâ®à®ã ¥ |
®¡ï§ãîâ ¤¥« âì ª®¯¨î ¨á室ëå ª®¤®¢ ¢¬¥áâ¥ á ª®¯¨¥© ®¡ê¥ªâëå ª®¤®¢ ¯à®£à ¬¬ë. |
4. ¥« âì ª®¯¨¨, ¢®á¨âì ¨§¬¥¥¨ï, áã¡«¨æ¥§¨à®¢ âì ¨«¨ à á¯à®áâà ïâì |
à®£à ¬¬ë© ¯à®¤ãªâ ¬®¦® «¨èì ãá«®¢¨ïå, ¯àאַ ®£®¢®à¥ëå ¢ ¤ ®¬ |
«¨æ¥§¨®®¬ ᮣ« 襨¨. î¡ë¥ ¨ë¥ ¯®¯ë⪨ ¤¥« âì ª®¯¨¨, ¨§¬¥ïâì, |
áã¡«¨æ¥§¨à®¢ âì ¨«¨ à á¯à®áâà ïâì à®£à ¬¬ë© ¯à®¤ãªâ áç¨â îâáï |
àã襨¥¬ «¨æ¥§¨®®£® ᮣ« è¥¨ï ¨ ¢â®¬ â¨ç¥áª¨ «¨è îâ ¢ á ¯à ¢, |
¯à¥¤®áâ ¢«ï¥¬ëå ¤ ë¬ á®£« 襨¥¬. |
¤ ª® «¨æ¥§¨¨ âà¥âì¨å «¨æ, 㦥 ¯®«ã稢è¨å ®â á ª®¯¨¨ ¨«¨ ª ª¨¥-«¨¡® |
¯à ¢ ãá«®¢¨ïå ¤ ®£® «¨æ¥§¨®®£® ᮣ« 襨ï, ¡ã¤ãâ á®åà ïâì |
îਤ¨ç¥áªãî ᨫ㠤® â¥å ¯®à, ¯®ª í⨠«¨æ ¯®«®áâìî ¢ë¯®«ïîâ ãá«®¢¨ï |
ᮣ« 襨ï. |
5. ë ¥ ®¡ï§ ë ¯à¨¨¬ âì ãá«®¢¨ï ¤ ®£® «¨æ¥§¨®®£® ᮣ« 襨ï, |
¯®áª®«ìªã ¢ë ¥ ¯®¤¯¨áë¢ «¨ ¥£®. ¤ ª® ¨çâ® ¨®¥ ¥ ¤ ¥â ¢ ¬ ¯®§¢®«¥¨ï |
¨§¬¥ïâì ¨«¨ à á¯à®áâà ïâì à®£à ¬¬ë© ¯à®¤ãªâ ¨«¨ ᮧ¤ ë¥ ¥£® |
®á®¢¥ à §à ¡®âª¨. ®¤®¡ë¥ ¤¥©áâ¢¨ï § ¯à¥é¥ë ¤¥©áâ¢ãî騬 |
§ ª®®¤ ⥫ìá⢮¬, ¥á«¨ ¢ë ¥ ¯à¨ï«¨ ãá«®¢¨ï ¤ ®£® ᮣ« 襨ï. |
«¥¤®¢ ⥫ì®, ¢®áï ª ª¨¥-«¨¡® ¨§¬¥¥¨ï ¨«¨ ¯¥à¥¤ ¢ ï ª®¬ã-«¨¡® ª®¯¨î |
à®£à ¬¬®£® ¯à®¤ãªâ (¨«¨ «î¡®© à §à ¡®âª¨, ᮧ¤ ®© ¥£® ®á®¢¥), ¢ë |
⥬ á ¬ë¬ ¯®ª §ë¢ ¥â¥, çâ® ¯à¨ï«¨ ¤ ®¥ «¨æ¥§¨®®¥ ᮣ« 襨¥, á® |
¢á¥¬¨ ¥£® ãá«®¢¨ï¬¨ ¨ ®£à ¨ç¥¨ï¬¨ ®â®á¨â¥«ì® ᮧ¤ ¨ï ª®¯¨©, |
à á¯à®áâà ¥¨ï ¨«¨ ¨§¬¥¥¨ï à®£à ¬¬®£® ¯à®¤ãªâ ¨«¨ ᮧ¤ ëå |
¥£® ®á®¢¥ à §à ¡®â®ª. |
6. á直© à §, ª®£¤ ë ¯¥à¥¤ ¥â¥ ª®¬ã-«¨¡® ª®¯¨î à®£à ¬¬®£® ¯à®¤ãªâ |
(¨«¨ à §à ¡®âª¨, ᮧ¤ ®© ®á®¢¥ à®£à ¬¬®£® ¯à®¤ãªâ ), ®¢ë© |
®¡« ¤ â¥«ì ¢â®¬ â¨ç¥áª¨ ¯®«ãç ¥â ®â ¨á室®£® ¯à ¢®®¡« ¤ ⥫ï à §à¥è¥¨¥ |
¤¥« âì ª®¯¨¨, à á¯à®áâà ïâì ¨ ¢®á¨âì ¨§¬¥¥¨ï ¢ à®£à ¬¬ë© ¯à®¤ãªâ |
¢ ᮮ⢥âá⢨¨ á ãá«®¢¨ï¬¨ ¨ ®£à ¨ç¥¨ï¬¨ ¤ ®£® «¨æ¥§¨®®£® ᮣ« 襨ï. |
ë ¥ ¬®¦¥â¥ ¢¢®¤¨âì ª ª¨¥-«¨¡® ¤®¯®«¨â¥«ìë¥ ®£à ¨ç¥¨ï ¤«ï ¯à ¢ ®¢®£® |
®¡« ¤ ⥫ï, ¯à¥¤®áâ ¢«ï¥¬ëå ¥¬ã ¤ ë¬ «¨æ¥§¨®ë¬ ᮣ« 襨¥¬. |
ë ¥ ®¡ï§ ë á«¥¤¨âì § ᮡ«î¤¥¨¥¬ âà¥â쨬¨ «¨æ ¬¨ ãá«®¢¨© ¤ ®£® |
ᮣ« 襨ï. |
7. ᫨ ¢á«¥¤á⢨¥ á㤥¡®£® à §¡¨à ⥫ìá⢠, ¨«¨ ®¡ê¥¨ï ª®¯¨¨ |
ª®âà ä ªâ®©, ¨«¨ ¯® ª ª®©-«¨¡® ¨®© ¯à¨ç¨¥ (¥ ®¡ï§ â¥«ì® ¯ â¥â®£® |
å à ªâ¥à ), ¢ë (à¥è¥¨¥¬ á㤠, ¢§ ¨¬ë¬ ᮣ« 襨¥¬ ¨«¨ ª ª-«¨¡® ¨ ç¥) |
¯®áâ ¢«¥ë ¢ ãá«®¢¨ï, ¯à®â¨¢®à¥ç 騥 ãá«®¢¨ï¬ ¤ ®£® «¨æ¥§¨®®£® |
ᮣ« 襨ï, íâ® ¥ ®á¢®¡®¦¤ ¥â ¢ á ®â ®¡ï§ ®á⨠ᮡ«î¤ âì ãá«®¢¨ï |
¤ ®£® «¨æ¥§¨®®£® ᮣ« 襨ï. |
᫨ ë ¥ ¬®¦¥â¥ ®¤®¢à¥¬¥® ¢ë¯®«ïâì ®¡ï§ ⥫ìá⢠, « £ ¥¬ë¥ ¤ ë¬ |
«¨æ¥§¨®ë¬ ᮣ« 襨¥¬, ¨ ¨ë¥ ¢§ïâë¥ á¥¡ï ®¡ï§ ⥫ìá⢠, â®, ª ª |
á«¥¤á⢨¥, ë ¥ ¤®«¦ë à á¯à®áâà ïâì à®£à ¬¬ë© ¯à®¤ãªâ. |
¯à¨¬¥à, ¥á«¨ ¯ â¥â®¥ ᮣ« 襨¥ ¥ ¤®¯ã᪠¥â ¡¥§¢®§¬¥§¤®£® ¤ «ì¥©è¥£® |
à á¯à®áâà ¥¨ï à®£à ¬¬®£® ¯à®¤ãªâ ⥬¨, ªâ®, ¯àאַ ¨«¨ ª®á¢¥®, |
¯®«ã稫 ¥£® ª®¯¨î ®â ¢ á, â® ¥¤¨áâ¢¥ë© á¯®á®¡ ¥ àãè¨âì ¨ ¥£® |
ãá«®¢¨ï, ¨ ãá«®¢¨ï ¤ ®£® «¨æ¥§¨®®£® ᮣ« 襨ï - íâ® ¯®«®áâìî |
¢®§¤¥à¦ âìáï ®â à á¯à®áâà ¥¨ï à®£à ¬¬®£® ¯à®¤ãªâ . |
᫨ ª ª ï-«¨¡® ç áâì ¤ ®£® à §¤¥« ¯à¨§ ¥âáï ¥ ¨¬¥î饩 îਤ¨ç¥áªãî |
ᨫ㠨«¨ ¥¯à¨¬¥¨¬®© ¢ ª®ªà¥âëå ®¡áâ®ï⥫ìá⢠å, ®áâ «ì ï |
ç áâì à §¤¥« ®áâ ¥âáï ¢ ᨫ¥, à §¤¥« ¢ 楫®¬ ¯à¨¬¥¨¬ ¯à¨ ¨ëå |
®¡áâ®ï⥫ìá⢠å. |
¥«ìî í⮣® à §¤¥« ¥ ï¥âáï ¯à¨ã¦¤¥¨¥ á àãè âì ª ª¨å-«¨¡® |
¯ â¥âë ¨«¨ ¨ë¥ ¯à ¢ ᮡá⢥®á⨠¨«¨ ®á¯ ਢ âì ¨å îਤ¨ç¥áªãî ᨫã; |
¤ ë© à §¤¥« ¯à¥á«¥¤ã¥â ¥¤¨á⢥ãî 楫ì - § é¨â¨âì á ¬ã á¨á⥬ã |
᢮¡®¤®£® à á¯à®áâà ¥¨ï ¯à®£à ¬¬ëå ¯à®¤ãªâ®¢, ¡ §¨àãîéãîáï |
¯à ªâ¨ª¥ ¯ã¡«¨ç®£® «¨æ¥§¨à®¢ ¨ï. ®£® «î¤¥© ¢¥á«¨ ᢮© 饤àë© ¢ª« ¤ |
¢ ᮧ¤ ¨¥ è¨à®ª®£® ¤¨ ¯ §® ¯à®£à ¬¬, à á¯à®áâà 塞ëå ¯®á।á⢮¬ |
¤ ®© á¨á⥬ë, à ááç¨âë¢ ï ¯®áâ®ï®¥ ¨á¯®«ì§®¢ ¨¥ ¤ ®© á¨á⥬ë; |
¢â®à, ᮧ¤ ¢è¨© çâ®-«¨¡® ¯®«¥§®¥ ¤«ï ¤à㣨å, ¢¯à ¢¥ á ¬ à¥è âì, å®ç¥â |
«¨ ®\® à á¯à®áâà ïâì ᢮© ¯à®£à ¬¬ë© ¯à®¤ãªâ ª ª¨¬-«¨¡® ¨ë¬ ᯮᮡ®¬, |
¨ «¨æ¥§¨ï ¥ ¬®¦¥â ¢«¨ïâì íâ®â ¢ë¡®à. |
â® § ¥¨¥ ¨¬¥¥â 楫ìî ïá® ¨ ¥¤¢ãá¬ëá«¥® ®¡êïá¨âì, çâ® ª ªãî 楫ì |
¯à¥á«¥¤ãîâ ¨¦¥á«¥¤ãî騥 ¯®«®¦¥¨ï ¤ ®£® «¨æ¥§¨®®£® ᮣ« 襨ï. |
8. ᫨ à á¯à®áâà ¥¨¥ ¨\¨«¨ ¨á¯®«ì§®¢ ¨¥ à®£à ¬¬®£® ¯à®¤ãªâ ¢ |
ª®ªà¥âëå áâà å ®£à ¨ç¥® ¯ â¥â묨 ᮣ« 襨ﬨ ¨«¨ ®â®è¥¨ï¬¨ ¢ |
®¡« á⨠¢â®àáª¨å ¯à ¢, ¨áå®¤ë© ®¡« ¤ â¥«ì ¢â®àáª¨å ¯à ¢, ¯®¬¥é î騩 |
᢮© à®£à ¬¬ë© ¯à®¤ãªâ ¯®¤ ¤¥©á⢨¥ ¤ ®£® «¨æ¥§¨®®£® ᮣ« 襨ï, |
¬®¦¥â ¤®¡ ¢¨âì ç¥âª® áä®à¬ã«¨à®¢ ë¥ £¥®£à ä¨ç¥áª¨¥ ®£à ¨ç¥¨ï |
à á¯à®áâà ¥¨ï, ¨áª«î稢 ¤ ë¥ áâà ë ¨§ ç¨á« â¥å, ¢ ª®â®àëå ¯®§¢®«¥® |
à á¯à®áâà ¥¨¥. â ª®¬ á«ãç ¥ ¤ ®¥ «¨æ¥§¨®®¥ ᮣ« 襨¥ ¤®«¦® |
ᮤ¥à¦ âì í⨠®£à ¨ç¥¨ï, § ¯¨á ë¥ ¥¯®á।á⢥® ¢ ᮡá⢥® ⥪á⥠|
ᮣ« 襨ï. |
9. "Free Software Foundation" ¬®¦¥â ¯® ᢮¥¬ã ãᬮâà¥¨î ¯ã¡«¨ª®¢ âì ¢à¥¬ï |
®â ¢à¥¬¥¨ ¯¥à¥á¬®âà¥ë© ¨«¨ ¨§¬¥¥ë© ⥪áâ â ¤ à⮩ ¯ã¡«¨ç®© |
«¨æ¥§¨¨ ¨«¨ ®¢ë© ¢ ਠ⠥¥. ⨠¢ ਠâë ¯® ¤ãåã ¡ã¤ãâ ᮢ¯ ¤ âì á |
áâ®ï饩 ¢¥àᨥ©, ® ¬®£ã⠮⫨ç âìáï ®â ¥¥ ¢ ¤¥â «ïå ¤«ï ᮮ⢥âá⢨ï |
¢®§¨ªè¨¬ ¯à®¡«¥¬ ¬ ¨ ¢®¯à®á ¬. |
¦¤®© ¢¥àᨨ ¨æ¥§¨¨ ¯à¨á¢ ¨¢ ¥âáï ®â«¨ç¨â¥«ìë© ®¬¥à ¢¥àᨨ. |
᫨ ¢ à®£à ¬¬®¬ ¯à®¤ãªâ¥ ª®ªà¥â® 㪠§ ®¬¥à ¢¥àᨨ «¨æ¥§¨®®£® |
ᮣ« è¥¨ï ¨ ®£®¢®à¥ ¯à¨¬¥¨¬®áâì "«î¡®© ¡®«¥¥ ¯®§¤¥© ¢¥àᨨ", ë |
¬®¦¥â¥, è¥ ãᬮâ२¥, á«¥¤®¢ âì ãá«®¢¨ï¬ ¨ ®£à ¨ç¥¨ï¬ ¤ ®© |
«¨¡® «î¡®© ¡®«¥¥ ¯®§¤¥© ¢¥àᨨ, ®¯ã¡«¨ª®¢ ®© "Free Software Foundation". |
᫨ ¢ ¯à®£à ¬¬®¬ ¯à®¤ãªâ¥ ª®ªà¥â® ¥ 㪠§ ®¬¥à ¢¥àᨨ «¨æ¥§¨®®£® |
ᮣ« 襨ï, ë ¬®¦¥â¥ ¢ë¡à âì ¤«ï ¨á¯®«ì§®¢ ¨ï «î¡ãî ¢¥àá¨î, ®¯ã¡«¨ª®¢ ãî |
"Free Software Foundation". |
10. ᫨ ¢ë å®â¨â¥ ¢ª«îç¨âì ç áâ¨ à®£à ¬¬®£® ¯à®¤ãªâ ¢ ¨ë¥ ᢮¡®¤® |
à á¯à®áâà ï¥¬ë¥ ¯à®£à ¬¬ë¥ ¯à®¤ãªâë, ® à á¯à®áâà ï¥¬ë¥ ¨ëå ãá«®¢¨ïå, |
¯¨á쬥® á¯à®á¨â¥ ¯®§¢®«¥¨ï ã ¢â®à . á«ãç ¥ ¯à®£à ¬¬ëå ¯à®¤ãªâ®¢, |
¢â®à᪨¥ ¯à ¢ ª®â®àë¥ ¯à¨ ¤«¥¦ â ¥¯®á।á⢥® "Free Software |
Foundation", ¯¨è¨â¥ ¢ "Free Software Foundation" - ¨®£¤ ¬ë ¤¥« ¥¬ ¢ |
â ª¨å á«ãç ïå ¨áª«î票ï. ਨ¬ ï ¢ â ª®¬ á«ãç ¥ à¥è¥¨¥, ¬ë ¡ã¤¥¬ |
à㪮¢®¤á⢮¢ âìáï á«¥¤ãî騬: á®åà ¥¨¥ ¢á¥¬ ¯à®¨§¢®¤ë¬ è¨å ᢮¡®¤® |
à á¯à®áâà 塞ëå ¯à®£à ¬¬ëå ¯à®¤ãªâ®¢ áâ âãá ᢮¡®¤® à á¯à®áâà 塞ëå, |
®¡¥á¯¥ç¥¨¥ á ¬®£® è¨à®ª®£® ¤®áâ㯠ª ¨¬ ¨ ¨å ¥®£à ¨ç¥®¥ ¨á¯®«ì§®¢ ¨¥. |
|
11. , , |
- , |
. , |
|
, " ", |
- , |
- , |
. , |
, . |
, , |
, . |
12. , , |
, , |
, \ |
|
, , , , |
, |
( |
, , , |
, |
- , |
|
. |
=============================================================== |
ª ᤥ« âì â ª, çâ®¡ë ¢á¥ íâ® ¡ë«® ¯à¨¬¥¨¬® ª |
¢ 襬㠮¢®¬ã ¯à®£à ¬¬®¬ã ¯à®¤ãªâã |
᫨ ¢ë à §à ¡ âë¢ ¥â¥ ®¢ë© ¯à®£à ¬¬ë© ¯à®¤ãªâ ¨ å®â¨â¥, çâ®¡ë ® áâ « |
ª ª ¬®¦® ¡®«¥¥ ¤®áâã¯ë¬ ¤«ï è¨à®ª®© ¯ã¡«¨ª¨, «ãç訩 ᯮᮡ ¤®¡¨âìáï |
í⮣® - ᤥ« âì ¥£® ᢮¡®¤® à á¯à®áâà ï¥¬ë¬ ¯à®£à ¬¬ë¬ ¯à®¤ãªâ®¬, ª®â®àë© |
ª ¦¤ë© ᬮ¦¥â à á¯à®áâà ïâì ¨ ¨§¬¥ïâì ãá«®¢¨ïå ¤ ®£® «¨æ¥§¨®®£® |
ᮣ« 襨ï. |
⮡ë ᤥ« âì ¥£® â ª¨¬, á ¡¤¨â¥ ¯à®£à ¬¬ë© ¯à®¤ãªâ á«¥¤ãî騬¨ |
§ ¬¥ç ¨ï¬¨ («ãçè¥ ¢á¥£® ¡ã¤¥â 㪠§ âì íâ® ¢ ç «¥ ª ¦¤®£® ä ©« ¨á室ëå |
ª®¤®¢, ç⮡ë á ¬ ªá¨¬ «ì®© íä䥪⨢®áâìî ¤®¢¥á⨠¤® ᢥ¤¥¨ï ¢á¥å ¨å |
¯®«ãç ⥫¥© ®âª § ®â £ à ⨩; ª ¦¤ë© ä ©« â ª¦¥ ¤®«¦¥ ᮤ¥à¦ âì |
"ª®¯¨à ©âãî" áâப㠨 㪠§ ¨¥ â®, £¤¥ ¬®¦® ©â¨ ¯®«ë© ⥪áâ |
㢥¤®¬«¥¨ï). |
Copyright (C) 19__ <¨¬ï ¢â®à > - ¨ ¤ «¥¥ 㪠§ë¢ ¥âáï §¢ ¨¥ |
¯à®£à ¬¬®£® ¯à®¤ãªâ ¨ ªà ⪠ï å à ªâ¥à¨á⨪ - ¤«ï 祣® ® ¯à¥¤ § ç¥. |
ï ¯à®£à ¬¬ ¯à¥¤áâ ¢«ï¥â ᮡ®© ᢮¡®¤® à á¯à®áâà ï¥¬ë© |
¯à®£à ¬¬ë© ¯à®¤ãªâ; ¢ë ¬®¦¥â¥ à á¯à®áâà ïâì ¥¥ ¤ «¥¥ ¨\¨«¨ ¨§¬¥ïâì |
ãá«®¢¨ïå â ¤ à⮩ ¯ã¡«¨ç®© «¨æ¥§¨¨ GNU, ®¯ã¡«¨ª®¢ ®© |
"Free Software Foundation" - «¨¡® ¥¥ ¢¥àᨨ ®¬¥à 2, «¨¡® (¯® ¢ 襬ã |
¢ë¡®àã) «î¡®© ¡®«¥¥ ¯®§¤¥© ¥¥ ¢¥àᨨ. |
á¯à®áâà ïï ¤ ë© ¯à®£à ¬¬ë© ¯à®¤ãªâ, ¬ë ¤¥¥¬áï çâ® ® ®ª ¦¥âáï |
¯®«¥§ë¬, ® , ¤ ¦¥ ¯®¤à §ã¬¥¢ ¥¬®© £ à ⨨ |
- ¨«¨ |
(á¬. "â ¤ àâãî ¯ã¡«¨çãî «¨æ¥§¨î GNU"). |
¬¥áâ¥ á ¤ ®© ¯à®£à ¬¬®© ¢ë ¤®«¦ë ¡ë«¨ ¯®«ãç¨âì ª®¯¨î "â ¤ à⮩ |
¯ã¡«¨ç®© «¨æ¥§¨¨ GNU"; ¥á«¨ íâ® ¥ â ª, ¯¨è¨â¥ ¢ Free Software |
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. |
®¡ ¢ì⥠⠪¦¥ ¨ä®à¬ æ¨î ® ⮬, ª ª á¢ï§ âìáï á ¢ ¬¨ ¯® í«¥ªâà®®© |
¨ ®¡ë箩 ¯®çâ ¬. |
᫨ ¯à®£à ¬¬ à ¡®â ¥â ¨â¥à ªâ¨¢®, ᤥ« ©â¥ â ª, çâ®¡ë ¯à¨ § ¯ã᪥ |
¢ ¨â¥à ªâ¨¢®¬ ०¨¬¥ ® ¢ë¢®¤¨« ª®à®âª¨© ⥪áâ ¯® á«¥¤ãî饬㠮¡à §æã: |
Gnomovision version 69, |
Copyright (C) 19__ <¨¬ï ¢â®à > |
à®£à ¬¬ Gnomovision à á¯à®áâà ï¥âáï |
. |
⮡ë 㧠âì ¯®¤à®¡®áâ¨, ¡¥à¨â¥ "show w". |
⮠᢮¡®¤® à á¯à®áâà ï¥¬ë© ¯à®£à ¬¬ë© ¯à®¤ãªâ. ®¡«î¤ ï |
®¯à¥¤¥«¥ë¥ ãá«®¢¨ï, ë ⮦¥ ¬®¦¥â¥ à á¯à®áâà ïâì ¥£®; ç⮡ë |
㧠âì ®¡ í⮬ ¡®«¥¥ ¯®¤à®¡®, ¡¥à¨â¥ "show c". |
।¯®« £ ¥¬ë¥ ª®¬ ¤ë "show w" ¨ "show c" ¤®«¦ë ¯à¨¢®¤¨âì ª ¯®ª §ã |
ᮮ⢥âáâ¢ãîé¨å à §¤¥«®¢ "â ¤ à⮩ ¯ã¡«¨ç®© «¨æ¥§¨¨". §ã¬¥¥âáï, ¢ë |
¬®¦¥â¥ ¨á¯®«ì§®¢ âì ¨ë¥ ª®¬ ¤ë; íâ® ¤ ¦¥ ¬®¦¥â ¡ëâì ¯à®áâ® ¦ ⨥ |
ª« ¢¨èã "¬ëè¨" ¨«¨ ¢ë¡®à ®¤®£® ¨§ ¯ãªâ®¢ ¢ ¬¥î. |
ਠ¥®¡å®¤¨¬®á⨠¢ë â ª¦¥ ¤®«¦ë ¤®¡¨âìáï ®â ¢ 襣® ¨¬ ⥫ï (¥á«¨ ¢ë |
à ¡®â ¥â¥ ¯à®£à ¬¬¨á⮬) ¨«¨ ®â ¢ 襩 誮«ë (¥á«¨ ãç¨â¥áì) ¯®¤¯¨á âì "®âª § |
®â ¯à¨âï§ ¨© ¢â®à᪨¥ ¯à ¢ " ¢ è ¯à®£à ¬¬ë© ¯à®¤ãªâ. (¨¦¥ ¯à¨¢¥¤¥ |
¯à¨¬¥à - § ¬¥¨â¥ ⮫쪮 §¢ ¨¥ ®à£ ¨§ 樨 ¨ ¨¬¥ ). |
"" áâ®ï騬 ®âª §ë¢ ¥âáï ®â ¢á¥å ¯à¨âï§ ¨© ¢â®à᪨¥ ¯à ¢ |
¯à®£à ¬¬ë© ¯à®¤ãªâ "______________________", ᮧ¤ ë© ¢ ®¬ |
¥â஢¨ç¥¬ ¨¤®à®¢ë¬. |
<¯®¤¯¨áì ¥¥à «ì®£® ¤¨à¥ªâ®à , ¯¥ç âì>, 1 ¯à¥«ï 1997 £. |
/< ¬¨«¨ï, .>./ - ¥¥à «ìë© ¤¨à¥ªâ®à |
ï â ¤ àâ ï ¯ã¡«¨ç ï «¨æ¥§¨ï ¥ à §à¥è ¥â ¢ª«î票¥ ¢ 襣® |
¯à®£à ¬¬®£® ¯à®¤ãªâ ¢ â ª¨¥ ¯à®£à ¬¬ë¥ ¯à®¤ãªâë, ª®â®àë¥ ª¥¬-«¨¡® |
¢¢¥¤¥ë ®£à ¨ç¥¨ï à á¯à®áâà ¥¨¥. ᫨ ¢ è ¯à®£à ¬¬ë© ¯à®¤ãªâ - íâ® |
¡¨¡«¨®â¥ª ¯®¤¯à®£à ¬¬, â®, ¢®§¬®¦®, ¡®«¥¥ ¯à ¢¨«ì® à §à¥è¨âì |
¨á¯®«ì§®¢ âì ¡¨¡«¨®â¥ªã ¢ ¯®¤®¡ëå ¯à®£à ¬¬ëå ¯à®¤ãªâ å. â ª®¬ á«ãç ¥ |
¢¬¥áâ® í⮩ ¨æ¥§¨¨ ¨á¯®«ì§ã©â¥ "â ¤ àâãî ¯ã¡«¨çãî «¨æ¥§¨î GNU ¤«ï |
¡¨¡«¨®â¥ª". |
/data/rus/docs/GROBFAR.TXT |
---|
0,0 → 1,48 |
|
¬ëá« ¨£àë á®á⮨⠢ ⮬, ç⮡ë, ¯¥à¥¬¥é ï ¨¥à®£«¨äë ¢å®¤¥ ¢ ®ç¥à¥¤ãî |
ª®¬ â㠣஡¨æë ä à ® (88), ®âªàëâì ¯à®å®¤. ë ¬®¦¥â¥ ¬¥ïâì ¬¥áâ ¬¨ ¤¢ |
¨¥à®£«¨ä à ᯮ«®¦¥ëå à冷¬ ¯® ¢¥à⨪ «¨ ¨«¨ £®à¨§®â «¨ ¢ á«ãç ¥, ¥á«¨ ¯à¨ |
â ª®© ¯¥à¥áâ ®¢ª¥ ®¡à §ã¥âáï ª®¬¡¨ æ¨ï ¨§ âà¥å ¨«¨ ¡®«¥¥ ®¤¨ ª®¢ëå ª à⨮ª |
¢ àï¤. ª¨¥ àï¤ë âãâ ¦¥ ¨á祧 îâ, ᢮¡®¤®¥ ¬¥áâ® § ¯®«ï¥âáï ¨¥à®£«¨ä ¬¨ |
"®áë¯ ¢è¨¬¨áï" ᢥàåã. ¥¤®áâ î騥 ¨¥à®£«¨äë £¥¥à¨àãîâáï á«ãç ©ë¬ ®¡à §®¬. |
¨á祧 î騥 ¨¥à®£«¨äë ç¨á«ïîâáï ®çª¨. ª®¬¡¨ æ¨î ¨§ ¨¥à®£«¨ä®¢ ¤ îâáï |
®çª¨ ¯® ä®à¬ã«¥ L+(L+1)^(N-3), ® ¥ ¡®«¥¥ 20*L*N, £¤¥ N - ç¨á«® ¨¥à®£«¨ä®¢ ¢ |
ª®¬¡¨ 樨, L - ®¬¥à ã஢ï. «ï ⮣®, çâ®¡ë ¯¥à¥©â¨ á ®¤®£® ã஢ï |
¤à㣮©, ¥®¡å®¤¨¬® ã¡à âì ®¯à¥¤¥«ñ®¥ ç¨á«® ¨¥à®£«¨ä®¢ ( ª ¦¤®¬ ã஢¥ |
à §®¥). ¨§ã ®â ¯ ¥«¨ á ¨¥à®£«¨ä ¬¨ à ᯮ«®¦¥ ¯®«®áª , ®â¬¥ç îé ï ᪮«ìª® |
¯à®©¤¥® ¨ ᪮«ìª® ®áâ «®áì ¨¥à®£«¨ä®¢. |
1-© ã஢¥ì - 500 |
2-© ã஢¥ì - 450 |
3-© ã஢¥ì - 400 |
4-© ã஢¥ì - 350 |
5-© ã஢¥ì - 300 |
6-© ¨ ¤ «¥¥ - 50*(L+1) |
¯¥à¢®¬ ã஢¥ ª®¬¡¨ 樨 á®áâ ¢«ïîâáï ¨§ 6 ¢¨¤®¢ ¨¥à®£«¨ä®¢. ª ¦¤ë¬ ®¢ë¬ |
ã஢¥¬ ¢ ª®¬¡¨ æ¨ïå ç¨ ¥â ãç á⢮¢ âì ®¤¨ ®¢ë© ¨¥à®£«¨ä, ® ¢á¥£® ¥ |
¡®«¥¥ 10 (â.¥. ç¨ ï á 5-£® ãà®¢ï ¨ ¤ «¥¥ ¢ ¨£à¥ ¡ã¤¥â 10 à §ëå ¨¥à®£«¨ä®¢, |
¥ ãç¨âë¢ ï á¯¥æ¨ «ìëå). |
ç¨ ï á® 2-£® ãà®¢ï § ª ¦¤ãî ª®¬¡¨ æ¨î ¨§ 4-å ¨ ¡®«¥¥ ¨¥à®£«¨ä®¢, â ª¦¥ |
§ ¯à®å®¦¤¥¨¥ ª ¦¤®© ç¥â¢¥à⨠ãà®¢ï ¨£à®ª ¯®«ãç ¥â "᢮¡®¤ë©" ¨¥à®£«¨ä - íâ® |
®¡ëçë© ¨¥à®£«¨ä (ᣥ¥à¨à®¢ ë© á«ãç ©ë¬ ®¡à §®¬), ª®â®àë© åà ¨âáï ã ¨£à®ª |
"¢ ª ଠ¥" ¨ ¯à¨ ¥®¡å®¤¨¬®á⨠¬®¦¥â ¡ëâì ¢áâ ¢«¥ ¨£à®ª®¬ «î¡®¥ ¬¥áâ®, |
§ ¬¥¨¢ ⥬ á ¬ë¬ à ᯮ«®¦¥ë© â ¬ ¨¥à®£«¨ä. |
ç¨ ï á 3-£® ãà®¢ï § ª ¦¤ãî ª®¬¡¨ æ¨î ¨§ 5-⨠¨ ¡®«¥¥ ¨¥à®£«¨ä®¢, â ª¦¥ |
§ ¯à®å®¦¤¥¨¥ ª ¦¤®© âà¥â¨ ãà®¢ï ¨£à®ª ¯®«ãç ¥â "㨢¥àá «ìë© ª«îç", |
¯®¤å®¤ï騩 ª «î¡®© ª®¬¡¨ 樨 ¨¥à®£«¨ä®¢ ¨ ª ¥áª®«ìª¨¬ à §ë¬ ª®¬¡¨ æ¨ï¬ |
®¤®¢à¥¬¥®. |
ç¨ ï á 4-£® ãà®¢ï § ª ¦¤ãî ª®¬¡¨ æ¨î ¨§ 6-⨠¨ ¡®«¥¥ ¨¥à®£«¨ä®¢, â ª¦¥ |
§ ¯à®å®¦¤¥¨¥ ¯®«®¢¨ë ãà®¢ï ¨£à®ª ¯®«ãç ¥â "¨áªà¨¢¨â¥«ì ¯à®áâà á⢠", |
¯®§¢®«ïî騩, ¯à¨ ¥£® ¯à¨¬¥¥¨¨, ᤥ« âì 3 室 (¥ ®¡ï§ â¥«ì® ¯®¤àï¤) ¯® |
¤¨ £® «¨. |
¨£à®ª ¥ ¬®¦¥â ¡ëâì ®¤®¢à¥¬¥® ¡®«¥¥ 1 ¤®¯®«¨â¥«ì®£® ¨¥à®£«¨ä ª ¦¤®£® |
⨯ (1 ¯à®á⮩, 1 ¤¦®ª¥à ¨ 1 ¨áªà¨¢¨â¥«ì). |
£à § ª 稢 ¥âáï, ¥á«¨ ¨£à®ª ¥ ¬®¦¥â á®áâ ¢¨âì ¨ ®¤®© ª®¬¡¨ 樨 |
¨¬¥î騬¨áï ã ¥£® ¢ à ᯮà殮¨¨ ¨¥à®£«¨ä ¬¨. |
/data/rus/docs/HOT_KEYS.TXT |
---|
0,0 → 1,10 |
«¥¤ãî騥 "£®àï稥" ª®¬¡¨ 樨 ª« ¢¨è ¨á¯®«ì§ãîâáï ¢ á¨á⥬¥: |
(㬥à æ¨ï ¯® ¢à¥¬¥¨ ¯®ï¢«¥¨ï ¢ á¨á⥬¥) |
1) Ctrl + Alt + Del § ¯ã᪠¯à¨«®¦¥¨ï CPU (¤¨á¯¥âç¥à ¯à®æ¥áᮢ), íâ® ¥¤¨á⢥ ï ª®¬¡¨ æ¨ï ¯®¤¤¥à¦ ï ã஢¥ ï¤à , ¢á¥ ®á⠫쮥 ॠ«¨§®¢ ® § áç¥â ¯à¨«®¦¥¨ï @PANEL. |
2) Ctrl + Shift - ¯¥à¥ª«î票¥ à ᪫ ¤ª¨ ª« ¢¨ âãàë. |
3) Win - § ¯ã᪠¯à¨«®¦¥¨ï MENU. |
4) Alt + Ctrl + F12 - § ¯ã᪠¯à¨«®¦¥¨ï END. |
5) Alt + F4 - § ¢¥à襨¥ ªâ¨¢®£® ¯à¨«®¦¥¨ï. |
6) Alt + Tab - ¯¥à¥ª«î票¥ á«¥¤ãî饥 (¢ ®ª®®¬ á⥪¥) ®ª® |
7) Alt + Shift + Tab - ¯¥à¥ª«î票¥ ¯à¥¤ë¤ã饥 (¢ ®ª®®¬ á⥪¥) ®ª® |
8) Alt + Shift + NumLock - § ¯ã᪠¯à¨«®¦¥¨ï MOUSEMUL, í¬ã«¨àãî饣® ¯à¨ ¢ª«îçñ®¬ NumLock ¬ëèì ª« ¢¨è ¬¨ 㬯 ¤ (¢¨¬ ¨¥! mousEmul ¥ ᮧ¤ ñâ ¨ ®ª , ¨ à¨á㪮¢ ¤«ï ¨¤¨ª 樨 ᢮¥© à ¡®âë!) |
/data/rus/docs/INI.TXT |
---|
0,0 → 1,27 |
Ini-ä ©«ë ¯à¥¤áâ ¢«ïîâ ¨§ ᥡï ⥪áâ®¢ë¥ ä ©«ë á¯¥æ¨ «ì®£® ¢¨¤ : |
[ §¢ ¨¥ ¯¥à¢®© ᥪ樨] |
à ¬¥âà1=§ 票¥1 |
à ¬¥âà2=§ 票¥2 |
;ª®¬¬¥â ਩ |
[ §¢ ¨¥ ¢â®à®© ᥪ樨] |
à ¬¥âà3=§ 票¥3 |
ᥠáâப¨, ç¨ î騥áï á ᨬ¢®« ';', áç¨â îâáï ª®¬¬¥â à¨ï¬¨ |
¨ ¨£®à¨àãîâáï. |
¨â ªá¨á ®¯¨á ¨ï ª®¬¡¨ 権 ª« ¢¨è: |
¯à®¨§¢®«ì®¥ ª®«¨ç¥á⢮ ¬®¤¨ä¨ª â®à®¢ Ctrl/Alt/Shift/LCtrl/LAlt/LShift/RCtrl/RAlt/RShift, |
¯®á«¥ ª®â®àëå á«¥¤ã¥â « â¨áª ï ¡ãª¢ , æ¨äà ¨«¨ ¨¬ï ª« ¢¨è¨. |
¬¥ ᮡáâ¢¥ë¥ ¨¬¥îâ á«¥¤ãî騥 ª« ¢¨è¨: |
F1 - F12 |
Home; End; PgUp; PgDn; Ins, ® ¦¥ Insert; Del, ® ¦¥ Delete; |
Tab; Plus; Esc; Enter; Backspace; Space (¯à®¡¥«); |
Left (áâ५ª ¢«¥¢®); Right (áâ५ª ¢¯à ¢®); Up (áâ५ª ¢¢¥àå); Down (áâ५ª ¢¨§). |
âப㠬®¦® ¯¨á âì á «î¡ë¬ ॣ¨áâ஬ ᨬ¢®«®¢. ⤥«ìë¥ ç á⨠¯¨èãâáï |
«¨¡® ᫨â®, «¨¡® à §¤¥«ïîâáï ¯«îᮬ. ¯à¨¬¥à: |
Ctrl+Alt+Backspace |
RCtrl+RShift |
ShiftA |
f10 |
shiftalt5 |
/data/rus/docs/KFAR_KEYS.TXT |
---|
0,0 → 1,100 |
¯à ¢«ïî騥 á®ç¥â ¨ï ª« ¢¨è ¢ KFar. |
¯ ¥«ïå: |
áâ५ª¨, Home, End - ¯¥à¥¬¥é¥¨¥ ªãàá®à ¯® ªâ¨¢®© ¯ ¥«¨ |
Tab - ¨§¬¥¥¨¥ ªâ¨¢®© ¯ ¥«¨ |
Enter - ¢å®¤ ¢ ¯ ¯ªã ¨«¨ § ¯ã᪠¯à®£à ¬¬ë, ª®â®àãî 㪠§ë¢ ¥â ªãàá®à |
F3 - ¯¥à¥å®¤ ª ¯à®á¬®âàã ä ©« ¯®¤ ªãàá®à®¬ |
F5 - ª®¯¨à®¢ ¨¥ ¢ë¤¥«¥ëå í«¥¬¥â®¢ ¨«¨ í«¥¬¥â ¯®¤ ªãàá®à®¬ ¤àã£ãî ¯ ¥«ì |
Shift+F5 - ª®¯¨à®¢ ¨¥ ¢ë¤¥«¥ëå í«¥¬¥â®¢ ¨«¨ í«¥¬¥â ¯®¤ ªãàá®à®¬ |
⥪ãéãî ¯ ¥«ì |
(㦮 ¡ã¤¥â § ¤ âì ¤à㣮¥ ¨¬ï; ¤«ï F5 íâ® â ª¦¥ ¬®¦® ᤥ« âì) |
F7 - ᮧ¤ ¨¥ ¯ ¯ª¨ |
F8 - 㤠«¥¨¥ ¢ë¤¥«¥ëå í«¥¬¥â®¢ ¨«¨ í«¥¬¥â ¯®¤ ªãàá®à®¬ |
F10 - ¢ë室 |
Alt+F1/Alt+F2 - ᬥ ¤¨áª , ®â®¡à ¦ ¥¬®£® «¥¢®©/¯à ¢®© ¯ ¥«¨ |
Alt+F9 - à §¢®à 稢 ¨¥ ®ª ª ¬ ªá¨¬ «ì® ¢®§¬®¦ë¬ à §¬¥à ¬ ¨ |
¢®ááâ ®¢«¥¨¥ à §¬¥à®¢ |
Ctrl+F3 - á®àâ¨à®¢ âì ä ©«ë/¯ ¯ª¨ ªâ¨¢®© ¯ ¥«¨ ¯® ¨¬¥¨ |
Ctrl+F4 - á®àâ¨à®¢ª ¯® à áè¨à¥¨î |
Ctrl+F5 - á®àâ¨à®¢ª ¯® ¤ â¥/¢à¥¬¥¨ ¯®á«¥¤¥© ¬®¤¨ä¨ª 樨 |
Ctrl+F6 - á®àâ¨à®¢ª ¯® à §¬¥àã |
Ctrl+F7 - ¥ á®àâ¨à®¢ âì (®â®¡à ¦ âì ¢ ⮬ ¦¥ ¯®à浪¥, çâ® ¨ ¤¨áª¥) |
Ctrl+F8 - á®àâ¨à®¢ª ¯® ¤ â¥/¢à¥¬¥¨ ᮧ¤ ¨ï |
Ctrl+F9 - á®àâ¨à®¢ª ¯® ¤ â¥/¢à¥¬¥¨ ¯®á«¥¤¥£® ®¡à 饨ï |
F12 - ¢ë§®¢ ¬¥î íªà ®¢ |
Ctrl+R - ¯¥à¥ç¨â âì ᮤ¥à¦¨¬®¥ ªâ¨¢®© ¯ ¥«¨ |
Menu - ¢ë§¢ âì ª®â¥ªá⮥ ¬¥î ¤«ï ä ©« ¯®¤ ªãàá®à®¬ |
LeftCtrl+1/2/3/4 - ¢ë¡à âì ०¨¬ ¯ ¥«¨ (ªà ⪨©/á।¨©/¯®«ë©/è¨à®ª¨©) |
RightCtrl+0..9 - ¯¥à¥©â¨ ª ¯ ¯ª¥, 㪠§ ®© ¢ à §¤¥«¥ [FolderShortcuts] |
¢ ini-ä ©«¥ ¯®¤ ¨¬¥¥¬ Shortcut0..9 ᮮ⢥âá⢥® |
Insert - ¢ë¤¥«¨âì/áïâì ¢ë¤¥«¥¨¥ á ⥪ã饣® ä ©« /¯ ¯ª¨ |
Grey[+] - ¢ë¤¥«¨âì ä ©«ë ¨ ¯ ¯ª¨ ¯® ¬ ᪥ |
Grey[-] - áïâì ¢ë¤¥«¥¨¥ á ä ©«®¢ ¨ ¯ ¯®ª ¯® ¬ ᪥ |
᪠¨¬¥¥â ¢¨¤ ⨯ "*.asm,*.inc|template.asm" (¯à¨¬¥à § ¤ ñâ ¢á¥ ä ©«ë |
á à áè¨à¥¨ï¬¨ ASM ¨ INC § ¨áª«î票¥¬ template.asm): ®¤ ¨«¨ ¡®«ìè¥ |
í«¥¬¥â à ï ¬ ᪠¢ª«î票ï á® áâ ¤ àâë¬ § 票¥¬ ᨬ¢®«®¢ '*' ¨ '?', |
à §¤¥«ñëå ',' ¨«¨ ';', ¯®á«¥ 祣® ¬®¦® ¯®áâ ¢¨âì '|' ¨ ®¤ã ¨«¨ ¡®«ìè¥ |
¬ ᮪ ¨áª«î票ï. ᪠"*.*" § ¤ ñâ ¢á¥ ä ©«ë á â®çª®© ¢ ¨¬¥¨ (â.¥. |
ä ©«ë á «î¡ë¬ ¥¯ãáâë¬ à áè¨à¥¨¥¬); çâ®¡ë § ¤ âì ¢á¥ ä ©«ë, ¨á¯®«ì§ã©â¥ "*". |
Grey[*] - ¨¢¥àâ¨à®¢ âì ¢ë¤¥«¥¨¥ |
Alt+<¡ãª¢ ¨«¨ æ¨äà > - ¯®§¨æ¨®¨à®¢ ¨¥ ªãàá®à ¨¬¥¨ ä ©« /¯ ¯ª¨, |
ç¨ î饬áï 㪠§ ãî ¡ãª¢ã ¨«¨ æ¨äàã; ¢ë§ë¢ ¥â ®ª® ¡ëáâண® ¯®¨áª , |
¢ ª®â®à®¬ ¬®¦® ¢¢®¤¨âì ¤ «ì¥©è¨¥ ᨬ¢®«ë ¨¬¥¨ ä ©« ¤«ï ãâ®ç¥¨ï, |
â ª¦¥ Ctrl+Enter/Shift+Ctrl+Enter ¤«ï ¯¥à¥¬¥é¥¨ï ª á«¥¤ãî饬ã/¯à¥¤ë¤ã饬ã |
í«¥¬¥âã ¯ ¥«¨, ¨¬ï ª®â®à®£® ç¨ ¥âáï á ¢¢¥¤ñëå ¡ãª¢ |
Alt+F7 - ¢ë§®¢ ¤¨ «®£ ¯®¨áª ä ©«®¢ |
¯à®á¬®âà騪¥: |
Esc = F3 = F10 = Numpad5 - ¢ë室 |
Down - áâப㠢¨§ |
PgDn - áâà ¨æã ¢¨§ |
Up - áâப㠢¢¥àå |
PgUp - áâà ¨æã ¢¢¥àå |
Home - ¢ ç «® ä ©« |
End - ¢ ª®¥æ ä ©« |
Left - ᨬ¢®« ¢«¥¢® |
Right - ᨬ¢®« ¢¯à ¢® |
Ctrl+Left - ¢ ०¨¬¥ Text 20 ᨬ¢®«®¢ ¢«¥¢®; |
¢ ०¨¬¥ Hex ¡ ©â ¢«¥¢® |
Ctrl+Right - ¢ ०¨¬¥ Text 20 ᨬ¢®«®¢ ¢¯à ¢®; |
¢ ०¨¬¥ Hex ¡ ©â ¢¯à ¢® |
Ctrl+Shift+Left - ¢ ç «® áâப íªà ¥ |
Ctrl+Shift+Right - ¢ ª®¥æ áâப íªà ¥ |
F2 - ¢ª«î票¥/¢ëª«î票¥ ¯¥à¥®á áâப |
F4 - ¯¥à¥ª«î票¥ ¯à®á¬®âà Text <-> Hex |
F8 - ¯¥à¥ª«î票¥ ª®¤¨à®¢ª¨ cp866 (DOS) <-> cp1251 (Win) |
Shift+F8 - ¬¥î ¢ë¡®à ª®¤¨à®¢ª¨ |
F12 - ¢ë§®¢ ¬¥î íªà ®¢ |
Alt+F9 - à §¢®à 稢 ¨¥ ®ª ª ¬ ªá¨¬ «ì® ¢®§¬®¦ë¬ à §¬¥à ¬ ¨ |
¢®ááâ ®¢«¥¨¥ à §¬¥à®¢ |
F7 - ¯®¨áª áâப¨ á ⥪ã饩 ¯®§¨æ¨¨ ¢ ä ©«¥ |
(áâப ¨ áâனª¨ ¯®¨áª § ¤ îâáï ¢ ¯®ï¢«ïî饬áï ¤¨ «®£¥) |
Shift+F7 - ¯à®¤®«¦¥¨¥ ¯®¨áª áâப¨ |
(¨á¯®«ì§ãîâáï ¯®á«¥¤¨¥ § ¤ ë¥ áâனª¨ ¯®¨áª ¨ áâப ) |
। ªâ®à¥: |
Esc = F10 - ¢ë室; ¥á«¨ ä ©« ¡ë« ¬®¤¨ä¨æ¨à®¢ , ¯®á«¥¤ã¥â ¢®¯à®á ® |
¥®¡å®¤¨¬®á⨠á®åà ¥¨ï |
Shift+F10 - ¢ë室 á á®åà ¥¨¥¬ |
F2 - á®åà ¨âì ä ©« |
Down - áâப㠢¨§ |
PgDn - áâà ¨æã ¢¨§ |
Up - áâப㠢¢¥àå |
PgUp - áâà ¨æã ¢¢¥àå |
Left - ¯à¥¤ë¤ã騩 ᨬ¢®« |
Right - ᨬ¢®« ¢¯à ¢® |
Home - ¢ ç «® áâப¨ |
End - ¢ ª®¥æ áâப¨ |
Backspace - 㤠«¨âì ᨬ¢®« ¯¥à¥¤ ªãàá®à®¬ |
Del - 㤠«¨âì ᨬ¢®« ¯®¤ ªãàá®à®¬ |
Ins - ¯¥à¥ª«îç¨âì ०¨¬ ¢áâ ¢ª¨/§ ¬¥ë ¯à¨ ¢¢®¤¥ |
F12 - ¢ë§®¢ ¬¥î íªà ®¢ |
Alt+F9 - à §¢®à 稢 ¨¥ ®ª ª ¬ ªá¨¬ «ì® ¢®§¬®¦ë¬ à §¬¥à ¬ ¨ |
¢®ááâ ®¢«¥¨¥ à §¬¥à®¢ |
F7 - ¯®¨áª áâப¨ á ⥪ã饩 ¯®§¨æ¨¨ ¢ ä ©«¥ |
(áâப ¨ áâனª¨ ¯®¨áª § ¤ îâáï ¢ ¯®ï¢«ïî饬áï ¤¨ «®£¥) |
Shift+F7 - ¯à®¤®«¦¥¨¥ ¯®¨áª áâப¨ |
(¨á¯®«ì§ãîâáï ¯®á«¥¤¨¥ § ¤ ë¥ áâனª¨ ¯®¨áª ¨ áâப ) |
diamond |
mailto:diamondz@land.ru |
/data/rus/docs/MTDBG.TXT |
---|
0,0 → 1,224 |
¢¥¤¥¨¥. |
mtdbg ¯à¥¤áâ ¢«ï¥â ᮡ®© ®â« ¤ç¨ª ¤«ï ®¯¥à 樮®© á¨á⥬ë Kolibri. ï |
¤®ªã¬¥â æ¨ï ®¯¨áë¢ ¥â ¢®§¬®¦®á⨠®â« ¤ç¨ª ¨ à ¡®âã á ¨¬. ᫨ ã¦ë |
ª ª¨¥-â® ¢®§¬®¦®á⨠®â« ¤ç¨ª , ª®â®àëå ¥éñ ¥â, «¨¡® ®¡à é ©â¥áì ä®à㬠|
meos.sysbin.com (à §¤¥« "à®£à ¬¬ë"), «¨¡® ¬ë«ì⥠¬¥ ¤à¥á, 㪠§ ë© ¢ |
ª®æ¥ ¤ ®£® ä ©« . |
¡é¥¥ ®¯¨á ¨¥. |
ª ¦¤ë© ¬®¬¥â ¢à¥¬¥¨ mtdbg ¬®¦¥â ®â« ¦¨¢ âì ⮫쪮 ®¤ã ¯à®£à ¬¬ã. §®¢ñ¬ |
â ªãî ¯à®£à ¬¬ã § £à㦥®© ¤«ï ®â« ¤ª¨. ᫨ ¨ª ª ï ¯à®£à ¬¬ ¥ § £à㦥 , |
¡á®«î⮥ ¡®«ìè¨á⢮ ¤¥©á⢨© ¯® ®â« ¤ª¥ ¥¤®áâ㯮. |
mtdbg ã¯à ¢«ï¥âáï ª®¬ ¤®© áâப®©, ¢¢®¤¨¬®© á ª« ¢¨ âãàë. ®¬ ¤ ï áâப |
¨§®¡à ¦ ¥âáï ¢ ¨¦¥© ç á⨠®ª ®â« ¤ç¨ª . ¡à ¡ âë¢ îâáï áâ ¤ àâë¥ ª« ¢¨è¨ |
¢¢®¤ Backspace,Delete,Home,End,áâ५ª¨ ¢«¥¢®/¢¯à ¢®. |
®¬ ¤ë ¥çã¢á⢨⥫ìë ª ॣ¨áâàã ᨬ¢®«®¢. ª ç¥á⢥ à §¤¥«¨â¥«ï |
¨á¯®«ì§ã¥âáï ¯à®¨§¢®«ì®¥ ¥ã«¥¢®¥ ç¨á«® ¯à®¡¥«®¢. |
«î¡®© ¬®¬¥â ®â« ¤ç¨ª ¬®¦® § ¢¥àè¨âì ª®¬ ¤®© "quit" (¡¥§ à£ã¬¥â®¢). |
¯à®ç¥¬, ¬®¦® ¨ ¯à®áâ® ¦ âì ª®¯ªã § ªàëâ¨ï ¢ «¥¢®¬ ¢¥à奬 㣫㠮ª . |
¯ã᪠®â« ¤ç¨ª ¡¥§ ¯ à ¬¥â஢ ª®¬ ¤®© áâப¨ ¯à¨¢®¤¨â ª ⮬ã, çâ® |
¨ª ª ï ¯à®£à ¬¬ ¥ § £à㦥 . ª¦¥ mtdbg ¬®¦® § ¯ã᪠âì á ª®¬ ¤®© |
áâப®©, ¢ í⮬ á«ãç ¥ ® ¯®¯ëâ ¥âáï § £à㧨âì ¯à®£à ¬¬ã á ¨¬¥¥¬, 㪠§ ë¬ |
ª ª ¯¥à¢ë© à£ã¬¥â ª®¬ ¤®© áâப¨, ¨ ¯ à ¬¥âà ¬¨, 㪠§ 묨 ª ª |
¯®á«¥¤ãî騥 (¥á«¨ ®¨ ¥áâì). |
᫨ ¨ª ª ï ¯à®£à ¬¬ ¥ § £à㦥 , â® ¬®¦® § £à㧨âì ¯à®£à ¬¬ã ª®¬ ¤®© |
load <¯®«®¥ ¨¬ï ¨á¯®«ï¥¬®£® ä ©« > [< à£ã¬¥âë>] |
¯à¨¬¥à: |
load /rd/1/example |
LOAD /rd/1/aclock w200 h200 |
LoaD /hd0/1/menuetos/dosbox/dosbox |
áñ, çâ® á⮨⠯®á«¥ ¯¥à¢®£® ¯à®¡¥« ¯®á«¥ ¨¬¥¨ ¨á¯®«ï¥¬®£® ä ©« , ¤®á«®¢® |
¯¥à¥¤ ñâáï ¯à®£à ¬¬¥ ¢ ª ç¥á⢥ ª®¬ ¤®© áâப¨. |
®¬ ¤ load á®®¡é ¥â ® १ã«ìâ ⥠¢ ®ª¥ á®®¡é¥¨© (¥¬®£® ¢ëè¥ ®ª |
ª®¬ ¤®© áâப¨). ᫨ ¯à®£à ¬¬ã 㤠«®áì § £à㧨âì, â® ®¡ í⮬ ¯®ï¢¨âáï |
ᮮ⢥âáâ¢ãî饥 á®®¡é¥¨¥; ¥á«¨ ¥ 㤠«®áì, â® ¢ á®®¡é¥¨¨ ¡ã¤¥â 㪠§ |
¯à¨ç¨ ®è¨¡ª¨. ¨¡®«¥¥ ¢¥à®ïâ ï - "file not found", ¥á«¨ ¥¯à ¢¨«ì® 㪠§ ® |
¨¬ï ä ©« . |
â« ¤ç¨ª ¬®¦¥â § £à㦠âì ä ©«ë á ¨ä®à¬ 樥© ®¡ ¨¬¥ å ¢ ¯à®£à ¬¬¥ (¬¥âª¨, |
£«®¡ «ìë¥ ¯¥à¥¬¥ë¥) - ⥪áâ®¢ë¥ ä ©«ë, ª ¦¤ ï áâப ª®â®àëå ¨¬¥¥â ¢¨¤ |
0x<hex_§ 票¥_ ¤à¥á > <¨¬ï> |
(áâப¨, ¥ ¨¬¥î騥 â ª®© ¢¨¤, ¨£®à¨àãîâáï). ª®© ä ©« ¬®¦¥â ¡ëâì ᮧ¤ |
¢àãçãî ¨«¨ ᣥ¥à¨à®¢ ¢â®¬ â¨ç¥áª¨ ¯à¨ ª®¬¯¨«ï樨 ¨á室¨ª fasm'®¬. |
¢ ï § £à㧪 ®áãé¥á⢫ï¥âáï ª®¬ ¤®© |
load-symbols <¯®«®¥ ¨¬ï ä ©« ᨬ¢®«®¢> |
஬¥ ⮣®, ¯à¨ ¢ë¯®«¥¨¨ ª®¬ ¤ë load ®â« ¤ç¨ª ¯à®¢¥àï¥â «¨ç¨¥ ä ©« |
á â ª¨¬ ¦¥ ¨¬¥¥¬, ª ª § £à㦠¥¬ë© ¡¨ ਪ, ¨ à áè¨à¥¨¥¬ .dbg |
(/rd/1/example.dbg ¤«ï ¯¥à¢®¬ ¨§ ¯à¨¬¥à®¢ ¢ëè¥), ¨ ¥á«¨ â ª®© ¥áâì, |
§ £à㦠¥â ¥£® ¢â®¬ â¨ç¥áª¨ (¢ë¤ ¢ ï á®®¡é¥¨¥ "Symbols loaded", ¥á«¨ ¢áñ ¢ |
¯®à浪¥). |
®¦¥â á«ãç¨âìáï â ª, çâ® § £à㦥 ï ¯à®£à ¬¬ 㯠ª®¢ . ¡é¨© ¯à¨æ¨¯ |
㯠ª®¢ª¨ ¯à®£à ¬¬ á«¥¤ãî騩: á ç « ¨áå®¤ë© ä ©« ¯ ªã¥âáï (ª ª¨¬-¨¡ã¤ì |
«£®à¨â¬®¬ ᦠâ¨ï), ¯®â®¬ ¯à¨¯¨áë¢ ¥âáï ¥¡®«ì让 ¯® à §¬¥àã ª®¤, ª®â®àë© |
¯®«ãç ¥â ã¯à ¢«¥¨¥ ¯à¨ § ¯ã᪥ ¯à®£à ¬¬ë, à ᯠª®¢ë¢ ¥â ¢ ¯ ¬ï⨠¨áå®¤ë© ª®¤, |
¯®á«¥ 祣® ¯¥à¥¤ ñâ ¥¬ã ã¯à ¢«¥¨¥. ᫨ ¯à®£à ¬¬ 㯠ª®¢ , â® ¥ñ " áâ®ï騩" |
ª®¤ ¥ ¢¨¤¥ ¨ ¤«ï ®â« ¤ª¨ 㦮 ¯à¥¤¢ à¨â¥«ì® ¯à®©â¨ ª®¤ à ᯠª®¢é¨ª . |
mtdbg ®¯à¥¤¥«ï¥â ¡®«ìè¨á⢮ áãé¥áâ¢ãîé¨å 㯠ª®¢é¨ª®¢ (mxp,mxp_lzo,mxp_nrv, |
mtappack) ¨ ¢ í⮬ á«ãç ¥ ¯à¥¤« £ ¥â ¢â®¬ â¨ç¥áª¨ ¯à®©â¨ ¤® " áâ®ï饣®" ª®¤ . |
¥ª®¬¥¤ã¥âáï ᮣ« á¨âìáï ( ¦ âì 'y' ¨«¨ <Enter>), ® ¬®¦® ¨ ®âª § âìáï. |
ਠ®âª §¥ ¨ ¢ á«ãç ¥, ª®£¤ ¯à®£à ¬¬ 㯠ª®¢ 祬-â® ¥¨§¢¥áâë¬, ¬®¦® |
¨á¯®«ì§®¢ âì ª®¬ ¤ã "unpack" (¡¥§ à£ã¬¥â®¢). ë§ë¢ ©â¥ ¥ñ ⮫쪮 ¢ á«ãç ¥, |
ª®£¤ ¢ë 㢥à¥ë, çâ® ¯à®£à ¬¬ 㯠ª®¢ ¨ çâ® ã¯à ¢«¥¨¥ ¥éñ ¥ ¤®è«® ¤® |
®á®¢®£® ª®¤ ! [ ç¨ ï á ¢¥àᨨ Kolibri 0.6.5.0, ¢¥áì íâ®â ¡§ æ 㦥 |
¥ ªâã «¥, ¯®áª®«ìªã ¯à¨«®¦¥¨ï ¬®¦® 㯠ª®¢ë¢ âì ª ª «î¡ë¥ ¤¢®¨çë¥ ä ©«ë |
kpack'®¬ ¨ ¯à¨ í⮬ ª®¤ à ᯠª®¢é¨ª 室¨âáï ¢ ï¤à¥ ¨ à ᯠª®¢ª ¯à®§à ç |
¤«ï ®â« ¤ª¨.] |
£à㦥ãî ¯à®£à ¬¬ã ¬®¦® ¯à¨¡¨âì ª®¬ ¤®© "terminate" (¡¥§ à£ã¬¥â®¢). |
®¬ ¤ "detach" (¡¥§ à£ã¬¥â®¢) ®âª«îç ¥âáï ®â ¯à®£à ¬¬ë, ¯®á«¥ 祣® |
¯à®£à ¬¬ ¯à®¤®«¦ ¥â ¢ë¯®«ïâìáï ®à¬ «ì®, ª ª ¥á«¨ ¡ë ®â« ¤ç¨ª ¥ ¡ë«®. |
®á«¥ ®¡¥¨å íâ¨å ª®¬ ¤ ¯à®£à ¬¬ ¯¥à¥áâ ñâ ¡ëâì ®â« ¦¨¢ ¥¬®©. |
®¦® § ®¢® § £à㧨âì ¯à®£à ¬¬ã ¤«ï ®â« ¤ª¨ ª®¬ ¤®© "reload" (¡¥§ |
à£ã¬¥â®¢). ᫨ 㦥 ¥áâì § £à㦥 ï ¯à®£à ¬¬ , â® ® ¯à¨¡¨¢ ¥âáï ¨ |
§ ¯ã᪠¥âáï (á á ¬®£® ç « ) ®¢ë© íª§¥¬¯«ïà (á ⮩ ¦¥ ª®¬ ¤®© áâப®©), |
¢ í⮬ á«ãç ¥ ª®¬ ¤ «®£¨ç ª®¬ ¤ ¬ |
terminate |
load <last program name> <last program arguments> |
¯à®â¨¢®¬ á«ãç ¥ § ®¢® § £à㦠¥âáï ¯à®£à ¬¬ , ª®â®àãî ®â« ¦¨¢ «¨ ¯®á«¥¤¥© |
(¢ ⥪ã饬 á¥ á¥ à ¡®âë á mtdbg) (á ⮩ ¦¥ ª®¬ ¤®© áâப®©), â.¥. ¯®ç⨠⮠|
¦¥ á ¬®¥, çâ® ¨ |
load <last program name> <last program arguments>, |
® ª®¬ ¤ reload ¢ ®¡®¨å á«ãç ïå ª®à®ç¥ ¨ 㤮¡¥¥; ªà®¬¥ ⮣®, load áç¨â ¥â, |
çâ® § £à㦠¥âáï ®¢ ï ¯à®£à ¬¬ , ¨ ¯¥à¥¢®¤¨â ®ª® ¤ ëå (á¬. ¨¦¥) |
ã«¥¢®© ¤à¥á, reload á®åà ï¥â ⥪ã騩 ¤à¥á. |
ᥣ¤ ¤®áâ㯠ª®¬ ¤ "help", ª®â®àãî ¬®¦® ᮪à é âì ¤® "h". |
ᥠª®¬ ¤ë à §¡¨âë £à㯯ë. |
help ¡¥§ à£ã¬¥â®¢ ¯®ª §ë¢ ¥â ᯨ᮪ £à㯯 ª®¬ ¤. |
help á 㪠§ ¨¥¬ £àã¯¯ë ¢ë¢®¤¨â ᯨ᮪ ª®¬ ¤ í⮩ £à㯯ë á ªà ⪨¬¨ |
ª®¬¬¥â à¨ï¬¨. |
help á 㪠§ ¨¥¬ ª®¬ ¤ë ¢ë¢®¤¨â ¨ä®à¬ æ¨î ® § ¤ ®© ª®¬ ¤¥. |
¯à¨¬¥à: |
help |
help control |
h LoaD |
ª® ®â« ¤ç¨ª á®á⮨⠨§ á«¥¤ãîé¨å í«¥¬¥â®¢, ¯¥à¥ç¨á«ï¥¬ëå ᢥàåã ¢¨§: |
- áâப á®áâ®ï¨ï. ਠ«¨ç¨¨ § £à㦥®© ¯à®£à ¬¬ë ¯®ª §ë¢ ¥â ¥¥ ¨¬ï ¨ |
á®áâ®ï¨¥ ("Running"/"Paused"), ¯à¨ ®âáãâá⢨¨ á®®¡é ¥â "No program loaded". |
- ®ª® ॣ¨áâ஢ - ¯®ª §ë¢ ¥â § 票ï ॣ¨áâ஢ ®¡é¥£® § 票ï, ॣ¨áâà |
eip ¨ ॣ¨áâà ä« £®¢. ®á«¥¤¨© § ¯¨á ¤¢ã¬ï ᯮᮡ ¬¨: ¯®«®¥ hex-§ 票¥ |
¨ á®áâ®ï¨ï ®â¤¥«ìëå ä« £®¢: CF,PF,AF,ZF,SF,DF,OF: ¥á«¨ ä« £ á¡à®è¥, â® |
¨§®¡à ¦ ¥âáï ¬ «¥ìª ï ¡ãª¢ , ¥á«¨ ãáâ ®¢«¥, â® § £« ¢ ï. |
¥£¨áâàë, ¨§¬¥¨¢è¨¥áï á ¯à¥¤ë¤ã饣® ¬®¬¥â , ¯®¤á¢¥ç¨¢ îâáï §¥«¥ë¬. |
- ®ª® ¤ ëå (®ª® ¤ ¬¯ ) - ¯®ª §ë¢ ¥â ᮤ¥à¦¨¬®¥ ¯ ¬ï⨠§ £à㦥®© ¯à®£à ¬¬ë |
- ®ª® ª®¤ (®ª® ¤¨§ áᥬ¡«¥à ) - ¯®ª §ë¢ ¥â ª®¤ ¯à®£à ¬¬ë ¢ ¢¨¤¥ |
¤¨§ áᥬ¡«¨à®¢ ëå ¨áâàãªæ¨© |
- ®ª® á®®¡é¥¨© |
- ®ª® ª®¬ ¤®© áâப¨ |
®ª¥ ¤ ¬¯ ¬®¦® ¯à®á¬ âਢ âì ¤ ë¥, ç¨ ï á «î¡®£® ¤à¥á , ¤«ï í⮣® |
¥áâì ª®¬ ¤ |
d <¢ëà ¦¥¨¥> |
®¬ ¤ d ¡¥§ à£ã¬¥â®¢ ¯à®«¨áâë¢ ¥â ®ª® ¤ ¬¯ ¢¨§. |
® ¦¥ á ¬®¥ ®â®á¨âáï ª ®ªã ª®¤ ¨ ª®¬ ¤¥ |
u <¢ëà ¦¥¨¥> |
¨«¨ ¯à®áâ® u. |
¯à¨¬¥à: |
d esi - ¯®ª §ë¢ ¥â ¤ ë¥, 室ï騥áï ¯® ¤à¥áã esi ( ¯à¨¬¥à, ¯®«¥§ ¯¥à¥¤ |
¢ë¯®«¥¨¥¬ ¨áâàãªæ¨¨ rep movsb) |
d esp - ¯®ª §ë¢ ¥â á⥪ |
u eip - ¤¨§ áᥬ¡«¨àã¥â ¨áâàãªæ¨¨, ç¨ ï á ⥪ã饩 |
ëà ¦¥¨ï ¢ mtdbg ¬®£ãâ ¢ª«îç âì |
- è¥áâ ¤æ â¥à¨çë¥ ª®áâ âë |
- ¨¬¥ ¢á¥å ॣ¨áâ஢ ®¡é¥£® § 票ï (8 32-¡¨âëå, 8 16-¡¨âëå ¨ |
8 8-¡¨âëå) ¨ ॣ¨áâà eip; § 票ï 16- ¨ 8-¡¨âëå ॣ¨áâ஢ à áè¨àïîâáï |
ã«ï¬¨ ¤® 32 ¡¨â |
- ç¥âëॠà¨ä¬¥â¨ç¥áª¨¥ ®¯¥à 樨 +,-,*,/ (á® áâ ¤ àâ묨 ¯à¨®à¨â¥â ¬¨) ¨ |
᪮¡ª¨ |
- [¥á«¨ ¥áâì ¨ä®à¬ æ¨ï ® ᨬ¢®« å] ¨¬¥ , § £àã¦¥ë¥ ¨§ dbg-ä ©« |
ᥠ¢ëç¨á«¥¨ï ¯à®¨§¢®¤ïâáï ¯® ¬®¤ã«î 2^32. |
ਬ¥àë ¢ëà ¦¥¨©: |
eax |
eip+2 |
ecx-esi-1F |
al+AH*bl |
ax + 2* bH*(eip+a73) |
3*esi*di/EAX |
®¬ ¤ |
? <¢ëà ¦¥¨¥> |
¢ëç¨á«ï¥â § 票¥ 㪠§ ®£® ¢ëà ¦¥¨ï. |
票ï ॣ¨áâ஢ § £à㦥®© ¯à®£à ¬¬ë ¬®¦® ¨§¬¥ïâì ª®¬ ¤®© r, ¨¬¥î饩 |
¤¢¥ ¡á®«îâ® íª¢¨¢ «¥âë¥ ä®à¬ë: |
r <ॣ¨áâà> <¢ëà ¦¥¨¥> |
r <ॣ¨áâà>=<¢ëà ¦¥¨¥> |
(¢ ®¡®¨å á«ãç ïå ¬®¦® à ááâ ¢«ïâì ¯à®¡¥«ë ¯® ¢ªãáã). ª ç¥á⢥ ॣ¨áâà ¬®¦® |
㪠§ë¢ âì «î¡®© ¨§ ¢ëè¥ã¯®¬ïãâëå - 24 ॣ¨áâà ®¡é¥£® § ç¥¨ï ¨ eip. |
®¯ãá⨬, ª®¬ ¤ load ãá¯¥è® § £à㧨« ¯à®£à ¬¬ã ¤«ï ®â« ¤ª¨. |
à §ã ¯®á«¥ § £à㧪¨ ¯à®£à ¬¬ ¯à¨®áâ ®¢«¥ ¨ ¥ ¢ë¯®«ï¥âáï. |
¦ ⨥ Ctrl+F7 ( «®£ ª®¬ ¤®© áâப¨ - ª®¬ ¤ "s") ¤¥« ¥â ®¤¨ è £ ¢ |
§ £à㦥®© ¯à®£à ¬¬¥, ¯®á«¥ 祣® ã¯à ¢«¥¨¥ ¢®§¢à é ¥âáï ®â« ¤ç¨ªã, ª®â®àë© |
¯®ª §ë¢ ¥â ®¢®¥ ᮤ¥à¦¨¬®¥ ॣ¨áâ஢ ¨ ¯ ¬ïâ¨. ¨áâ¥¬ë© ¢ë§®¢ int 40h |
( â ª¦¥ ¨áâàãªæ¨¨ sysenter ¨ syscall) ¯à¨ í⮬ áç¨â ¥âáï ®¤¨¬ è £®¬. |
¦ ⨥ Ctrl+F8 ( «®£ ª®¬ ¤®© áâப¨ - ª®¬ ¤ "p") â ª¦¥ ¤¥« ¥â è £ ¢ |
§ £à㦥®© ¯à®£à ¬¬¥, ® ¯à¨ í⮬ ¢ë§®¢ë ¯à®æ¥¤ãà, áâப®¢ë¥ ®¯¥à 樨 á |
¯à¥ä¨ªá®¬ rep/repz/repnz ¨ 横«ë loop ¢ë¯®«ïîâáï ª ª ®¤¨ è £. |
®¬ ¤ë ¯®è £®¢®£® ¢ë¯®«¥¨ï ¨á¯®«ì§ãîâáï, ª ª ¯à ¢¨«®, ®â¤¥«ìëå ãç á⪠å |
¯à®£à ¬¬ë, ª®£¤ 㦮, ¯à¨¬¥à, ॣã«ïà® ®âá«¥¦¨¢ âì § 票ï ॣ¨áâ஢ |
¨/¨«¨ ª ª¨å-â® ¯¥à¥¬¥ëå ¢ ¯ ¬ïâ¨. |
®¬ ¤ |
g <¢ëà ¦¥¨¥> |
¢®§®¡®¢«ï¥â ¢ë¯®«¥¨¥ ¯à®£à ¬¬ë ¨ ¦¤ñâ, ¯®ª ã¯à ¢«¥¨¥ ¤®©¤ñâ ¤® |
eip=ᮮ⢥âáâ¢ãî饬㠤à¥áã, ¢ íâ®â ¬®¬¥â ¯à¨®áâ ¢«¨¢ ¥â ¯à®£à ¬¬ã. |
®¬ ¤ "g" ¡¥§ à£ã¬¥â®¢ ¯à®áâ® ¢®§®¡®¢«ï¥â ¢ë¯®«¥¨¥ ¯à®£à ¬¬ë. |
ਮáâ ®¢¨âì ¢ë¯®«¥¨¥ ¯à®£à ¬¬ë ¬®¦® ª®¬ ¤®© "stop" (¡¥§ à£ã¬¥â®¢). |
¡ëç® âॡã¥âáï, çâ®¡ë ¯à®£à ¬¬ ®à¬ «ì® ¢ë¯®«ï« áì, ® ¯à¨ áâ㯫¥¨¨ |
®¯à¥¤¥«ñëå ãá«®¢¨© ¯à®£à ¬¬ ¯à¨®áâ ¢ « áì ¨ ã¯à ¢«¥¨¥ ¯®«ãç « ®â« ¤ç¨ª. |
®®â¢¥âáâ¢ãî騥 ãá«®¢¨ï §ë¢ îâáï â®çª ¬¨ ®áâ ®¢ , breakpoint(s), ¢ |
¯à®áâ®à¥ç¨¨ - ¡àïª ¬¨. à®á⥩訩 ⨯ â®ç¥ª ®áâ ®¢ - ª®ªà¥âë© ¤à¥á, |
â.¥. ¯à¥àë¢ âì ¢ë¯®«¥¨¥ ¯à¨ eip=<§ ¤ ®¥ § 票¥>. ª¨¥ â®çª¨ ®áâ ®¢ |
ãáâ ¢«¨¢ îâáï ª®¬ ¤®© |
bp <¢ëà ¦¥¨¥> |
¬¥ç ¨¥. ᫨ ¥áâì ⮫쪮 ®¤ â ª ï â®çª ®áâ ®¢ , 㤮¡¥¥ ¢¬¥áâ® ¥ñ |
¨á¯®«ì§®¢ âì ª®¬ ¤ã "g" á à£ã¬¥â®¬. |
à㣮© ⨯ â®ç¥ª ®áâ ®¢ - ¯® ®¡à é¥¨î ª § ¤ ®¬ã ãç áâªã ¯ ¬ïâ¨. |
ª¨å â®ç¥ª ®áâ ®¢ ¬®¦¥â ¡ëâì ¥ ¡®«ìè¥ ç¥âëàñå (¯®áª®«ìªã ¨á¯®«ì§ãîâáï |
¯¯ à âë¥ ¢®§¬®¦®á⨠¯à®æ¥áá®à®¢ x86, £¤¥ ¤®¯ã᪠îâáï ⮫쪮 4 â ª¨å â®çª¨). |
bpm <¢ëà ¦¥¨¥> - ¡àïª ¥âáï «î¡®© ¤®áâ㯠ª ¡ ©âã ¯® 㪠§ ®¬ã ¤à¥áã |
bpm w <¢ëà ¦¥¨¥> - ¡àïª ¥âáï § ¯¨áì ¡ ©â ¯® 㪠§ ®¬ã ¤à¥áã |
bpmb,bpmw,bpmd <¢ëà ¦¥¨¥> - ¡àïª îâáï ¤®áâ㯠ª ᮮ⢥âá⢥® ¡ ©âã, á«®¢ã |
¨ ¤¢®©®¬ã á«®¢ã ¯® 㪠§ ®¬ã ¤à¥áã. bpm ¨ bpmb - ᨮ¨¬ë. ਠ¨á¯®«ì§®¢ ¨¨ |
bpmw,bpmd ¤à¥á ¤®«¦¥ ¡ëâì ¢ë஢¥ ᮮ⢥âá⢥® £à ¨æã á«®¢ (â.¥. ¡ëâì |
çñâë¬) ¨«¨ £à ¨æã ¤¢®©®£® á«®¢ (â.¥. ¤¥«¨âìáï 4). |
bpmb,bpmw,bpmd w <¢ëà ¦¥¨¥> - «®£¨ç® ¤«ï ¡àïª § ¯¨áì. |
¯¨á®ª ãáâ ®¢«¥ëå â®ç¥ª ®áâ ®¢ ¬®¦® ¯à®á¬®âà¥âì ª®¬ ¤®© "bl", ¨ä®à¬ æ¨î |
® ª®ªà¥â®© â®çª¥ ®áâ ®¢ ¬®¦® ¯®«ãç¨âì á ¯®¬®éìî "bl <®¬¥à>". ¥ã¦ë¥ |
â®çª¨ ®áâ ®¢ 㤠«ïîâáï ª®¬ ¤®© "bc <®¬¥à>", ¢à¥¬¥® ¥ã¦ë¥ ¬®¦® |
§ ¯à¥â¨âì ª®¬ ¤®© "bd <®¬¥à>", ª®£¤ ®¨ áâ ãâ ᮢ ã¦ë, ¨á¯®«ì§ã©â¥ |
ª®¬ ¤ã "be <®¬¥à>". |
¬¥ç ¨ï. |
1. ਠ®â« ¤ª¥ ᮡá⢥ëå ¯à®£à ¬¬ ¬®¦® ¢áâ ¢«ïâì ¢ ª®¤ ¨áâàãªæ¨¨ |
int3 (®¡à â¨â¥ ¢¨¬ ¨¥ ®âáãâá⢨¥ ¯à®¡¥« !). ª ï ¨áâàãªæ¨ï ¢ë§ë¢ ¥â |
¨áª«î票¥ ¯à¨ ®à¬ «ì®¬ § ¯ã᪥, çâ® ¯à¨¢¥¤ñâ ª § ¢¥àè¥¨î ¯à®æ¥áá , |
® ¯à¨ à ¡®â¥ ¯®¤ ®â« ¤ç¨ª®¬ ¯à®áâ® ªâ¨¢¨§¨àã¥âáï ®â« ¤ç¨ª (á á®®¡é¥¨¥¬ |
"int3 command at xxx"). â® ¯®§¢®«ï¥â ¥ ¤ã¬ âì ® ⮬, ª ª¨¥ ¤à¥á |
¨á¯®«ì§®¢ âì ¢ ª®¬ ¤ å g ¨/¨«¨ bp. ®¦® â ª¦¥ £¥¥à¨à®¢ âì ä ©« á |
¨ä®à¬ 樥© ® ᨬ¢®« å ¨ § £à㦠âì ¥£®, ⮣¤ ¥ ⮫쪮 ¥â 㦤ë |
á ¬®áâ®ïâ¥«ì® ¢ëç¨á«ïâì ¤à¥á ¤«ï "g" ¨ "bp", ® ¨ "u","d","?" ¡ã¤ãâ |
¯®¨¬ âì 㪠§ ¨¥ ¨¬¥¨ ¬¥âª¨/¯¥à¥¬¥®©. |
2. ¥áì ¢ë¢®¤ ¨ ¢¥áì ¢¢®¤ ®à¨¥â¨à®¢ 16-à¨çãî á¨á⥬ã áç¨á«¥¨ï. |
3. ®£¤ ¯à®£à ¬¬ ¢ë¯®«ï¥âáï, ®ª ॣ¨áâ஢ ¨ ¤ ëå ¯®ª §ë¢ îâ ¨ä®à¬ æ¨î, |
®â®áïéãîáï ª ¬®¬¥âã ¤® ¢®§®¡®¢«¥¨ï; ãáâ ®¢ª § 票© ॣ¨áâ஢ ¢ |
í⮬ ०¨¬¥ ¥¢®§¬®¦ . ¯à®ç¥¬, ª®¬ ¤ "d" ¢ í⮬ ०¨¬¥ ¯®ª §ë¢ ¥â |
¨ä®à¬ æ¨î, ¢¥àãî ¢ ¬®¬¥â ¢ë¤ ç¨ ª®¬ ¤ë. |
diamond |
mailto:diamondz@land.ru |
/data/rus/docs/README.TXT |
---|
0,0 → 1,274 |
************************ |
* ®«¨¡à¨ OS 0.7.7.0+ * |
* ä¥¢à «ì 2010 * |
************************ |
®á«¥¤¨© ५¨§ á¨áâ¥¬ë ¢ë ¬®¦¥â¥ ©â¨ ®ä¨æ¨ «ì®¬ á ©â¥: |
http://kolibrios.org |
᫨ ã ¢ á ¢®§¨ª«¨ ¢®¯à®áë, ®¡à é ©â¥áì § ¯®¤¤¥à¦ª®© è ä®àã¬: |
http://board.kolibrios.org |
*********************************** |
* â® ®¢®£® ¢ í⮬ ¢ë¯ã᪥? * |
*********************************** |
ï¤à¥ ¯à®¨§¢¥¤¥ë á«¥¤ãî騥 ¨§¬¥¥¨ï, ¤®à ¡®âª¨, ¨á¯à ¢«¥¨ï: |
â ¢£¥¨ï à¥ç¨ª®¢ (Diamond) - ®áá¨©áª ï ¥¤¥à æ¨ï |
1) ã«ãçè¥¨ï ¢ ®¯à¥¤¥«¥¨¨ ¤¨áª®¢ ç¥à¥§ BIOS (V86) |
2) ¨á¯à ¢«¥¨¥ ã ®ç¥ì ¬®£¨å ª®á类¢ ¢ ï¤à¥ ¨ ¯à¨«®¦¥¨ïå |
â ¥à£¥ï ¥¬ñ®¢ (Serge) - ®áá¨©áª ï ¥¤¥à æ¨ï |
1) ¡®¢«¥¨¥ ¤à ©¢¥à ¤«ï ¢¨¤¥®ª àâ ATI. |
2) ¨ãªá-¯®¤®¡ë¥ ¬ìî⥪áë ï¤à |
â ¨å ¨« ¥¬¥ïª® (mike.dld) - ¥á¯ã¡«¨ª ¥« àãáì |
1) ¥ä ªâ®à¨£ ®ª®®© ¯®¤á¨á⥬ë. |
â <Lrz> - ®áá¨©áª ï ¥¤¥à æ¨ï |
1) ¥à¥à ¡®âª äãªæ¨© á 楫ìî ¯®«®áâìî ã¡à âì ᤢ¨£-ॣ¨áâà®¢ë© ¢ë§®¢ API |
2) ¥ä ªâ®à¨£ ¥ª®â®àëå ãç á⪮¢ ï¤à , ®¯â¨¬¨§ 樨, ¡ £ä¨ªáë. |
â àâñ¬ ¥à¤¥¢ (art_zh) - |
1) ®áâ㯠¨§ ¯à¨«®¦¥¨ï ª ®â®¡à ¦ñë¬ ¯ ¬ïâì ®¡« áâï¬ ¢¢®¤ -¢ë¢®¤ (MMIO). |
2) ®áâ㯠ª à áè¨à¥®¬ã ª®ä¨£ãà 樮®¬ã ¯à®áâà áâ¢ã PCI Express ( ¢â® áâனª ¤«ï AMD-NPT ç¨ ï á Athlon64). |
â ¤à¥ï ãà¡ ®¢ (turbanoff) - ®áá¨©áª ï ¥¤¥à æ¨ï |
1) ®¤¤¥à¦ª ç⥨ï ä ©«®¢ëå á¨á⥬ ext2/ext3. |
â à â ª¨ï®¢ (Mario79) - ®áá¨©áª ï ¥¤¥à æ¨ï |
1) «ãçè¥¨ï ¢ ®¡à ¡®âª¥ ¦ â¨ï ¬ëè¨. |
â hidnplayr |
1) ¥à¥¯¨áë¢ ¨¥ ¢á¥© ¯®¤á¨á⥬ë à ¡®âë á á¥âìî. |
â Asper |
1) à ©¢¥à ¤«ï §¢ãª®¢ëå ª àâ VT823(X) ¨ EMU10K1X. |
â tsdima |
1) à ©¢¥à ¤«ï §¢ãª®¢®© ª àâë ForteMedia fm801. |
â Maxis |
1) §¬¥¥¨ï ¢ ¯à®¢¥àª¥ ᢮¡®¤®© ¯ ¬ïâ¨. |
* ¯à¨«®¦¥¨ï¬¨ ¯à®¨§¢¥¤¥ë á«¥¤ãî騥 ¨§¬¥¥¨ï, ¤®à ¡®âª¨, ¨á¯à ¢«¥¨ï: |
FTPS - tsdima, ¥ª®â®àë¥ ã«ãç襨ï |
VIEW3DS - macgub, ¢¥àá¨ï 0.054 |
FASM - ¢¥« 묮¢áª¨© (Heavyiron), ®¡®¢«¥¨¥ ¤® ¢¥àᨨ 1.69.11 |
IgorA, ¨á¯®«ì§®¢ ¨¥ ¡¨¡«¨®â¥ª¨ box_lib, àãá¨ä¨ª æ¨ï, |
à â ª¨ï®¢ (Mario79), ¨á¯à ¢«¥¨¥ ¢®§¨ªè¨å £«îª®¢ |
¢£¥¨© à¥ç¨ª®¢ (Diamond), ¨á¯à ¢«¥® ᢥàâë¢ ¨¥ ®ª |
PCIDEV - à⥬ ¥à¤¥¢ (art_zh), ¤ ¬¯ MMIO-®¡« á⥩ PCI-ãáâனá⢠; ᮪à 饨¥ |
ª®¤ § áç¥â 㤠«¥¨ï ¬ «®¨§¢¥áâëå ¢¥¤®à®¢ ¨§ ®á®¢®© ¡ §ë ¤ ëå |
BOARD - ¢£¥¨© à¥ç¨ª®¢ (Diamond), ¥ ®â¡à áë¢ âì ¥¯à®ç¨â ë¥ |
á®®¡é¥¨ï ¯à¨ áâ à⥠¯à®£à ¬¬ë |
UNVWATER - Asper, ¯®àâ ¤¥¬ª¨ ¨§ OctaOS ( ¢â®à Octavio Vega Fernandez) |
HEED - staper, ¢¥àá¨ï 0.15: ¨á¯®«ì§®¢ ¨¥ ¡¨¡«¨®â¥ª¨ box_lib; |
Ctrl+C/X/V, Ctrl+B ¤«ï ¢ë¤¥«¥¨ï ¡«®ª , ª®á¬¥â¨ç¥áª¨¥ ¨§¬¥¥¨ï |
à â ª¨ï®¢ (Mario79), ¨á¯®«ì§®¢ ¨¥ ª®¬¯®¥â OpenDialog, |
¥¡®«ìè ï ®¯â¨¬¨§ æ¨ï ª®¤ |
SHELL - Albom, ¢¥àá¨ï 0.4.2 |
CPU - ¢£¥¨© à¥ç¨ª®¢ (Diamond) ¯® ¯à¥¤«®¦¥¨î |
¨à¨«« ¨¯ ⮢ (Leency), ¯® 㬮«ç ¨î ¥ ¯®ª §ë¢ âì |
á¨áâ¥¬ë¥ ¯à®æ¥ááë |
TINYPAD - mike.dld, à¥è¥ ¯à®¡«¥¬ á ¬¨£ ¨¥¬ ªãàá®à ¢ ¥ª®â®àëå á«ãç ïå |
HTMLV - ¨à¨«« ¨¯ ⮢ (Leency), ¢¥àá¨ï 0.62a |
EOLITE - ¨à¨«« ¨¯ ⮢ (Leency), ¢¥àá¨ï 0.98.7a |
RTFREAD - Sorcerer, ª®á¬¥â¨ç¥áª ï ¯à ¢ª |
dunkaist, ¬¥î ¨ áªà®««¡ à, £®àïç ï ª« ¢¨è 'end' |
E80 - Albom, ¢¥àá¨ï 0.5.1 |
KIV - ¢£¥¨© à¥ç¨ª®¢ (Diamond), ¨¬ï ⥪ã饣® ä ©« ¢ § £®«®¢ª¥ |
®ª , áâà ¨¢ ¥¬ë¥ ª« ¢¨ âãàë¥ á®ªà é¥¨ï ¤«ï ¯¥à¥å®¤ |
ª á«¥¤ãî饬ã/¯à¥¤ë¤ã饬㠨§®¡à ¦¥¨î ¢ ¯ ¯ª¥, ¨á¯à ¢«¥¨ï ®¡à ¡®âª¨ |
¬ «¥ìª¨å ä ©«®¢ ä®à¬ â TGA |
à â ª¨ï®¢ (Mario79) ¨á¯à ¢«¥¨ï ¯à¨ à ¡®â¥ ᮠᯨ᪮¬ ä ©«®¢ |
SUDOKU - staper, ¯®àâ ¨£àë 㤮ªã - íâ® £®«®¢®«®¬ª -¯ §« á ç¨á« ¬¨, £¤¥ 㦮 |
§ ¯®«¨âì ᢮¡®¤ë¥ ª«¥âª¨ æ¨äà ¬¨ ®â 1 ¤® 9 â ª, çâ®¡ë ¢ ª ¦¤®© áâப¥, |
¢ ª ¦¤®¬ á⮫¡æ¥ ¨ ¢ ª ¦¤®¬ ¬ «®¬ ª¢ ¤à ⥠3x3 ª ¦¤ ï æ¨äà ¢áâà¥ç « áì |
¡ë ⮫쪮 ®¤¨ à §. áâì 9 ã஢¥© á«®¦®áâ¨. |
REVERSI - staper, ¯®àâ áâà ⥣¨ç¥áª®© ¨£àë ¥¢¥àᨠ(⥫«®) |
MSQUARE - staper, ¬ ⥬ â¨ç¥áª ï £®«®¢®«®¬ª " £¨ç¥áª¨© ª¢ ¤à â": á㬬ë |
ç¨á¥« ¢ áâப å, á⮫¡æ å (०¥ ¢ ¤¨ £® «ïå) ¤®«¦ë ¡ëâì à ¢ë |
FINDN-S - Artemonische, ¯à®áâ¥ìª ï ¨£àãèª ¢ ª®â®à®© 㦮 ᮡà âì ¢á¥ |
ç¨á« ¯® ¯®à浪㠮â 10 ¤® 90 |
PANEL - ¢£¥¨© à¥ç¨ª®¢ (Diamond), ¥¡®«ì讥 ¨á¯à ¢«¥¨¥ ¢ ç á å ¯ ¥«¨ |
¨ ॠ¨¬ æ¨ï ¯®¤á¢¥âª¨ ¯à¨ ¦ ⨨ Alt+[Shift+]Tab. |
AC97SND - Asper, ¯®¤¤¥à¦ª ¯«¥©«¨á⮢ ¢ ä®à¬ ⥠m3u. |
@NOTIFY - SoUrcerer, ¯à®£à ¬¬ ¯®ª §ë¢ ¥â ¢á¯«ë¢ î騥 á®®¡é¥¨ï |
DOSBOX - ¢£¥¨© à¥ç¨ª®¢ (Diamond), ¢¥àá¨ï 0.74 |
ASCIIVJU - ®áâ ⨠ã⪥¢¨ç (Nazarus), ¯à®£à ¬¬ ®â®¡à ¦ ¥â â ¡«¨æã ASCII |
PIPETKA - Rock_maniak_forever, ¯à®£à ¬¬ ¤«ï ¢§ïâ¨ï 梥⠯¨ªá¥« á íªà |
SNAKE - dunkaist, ¥éñ ®¤ ॠ«¨§ æ¨ï ª« áá¨ç¥áª®© ¨£àë |
* á¨á⥬묨 ¡¨¡«¨®â¥ª ¬¨ ¯à®¨§¢¥¤¥ë á«¥¤ãî騥 |
¨§¬¥¥¨ï, ¤®à ¡®âª¨, ¨á¯à ¢«¥¨ï: |
libini - ¢£¥¨© à¥ç¨ª®¢ (Diamond), ¤®¡ ¢«¥ äãªæ¨ï ¤«ï |
ç⥨ï á®ç¥â ¨© ª« ¢¨è |
box_lib - IgorA, ¤®à ¡®âª¨ ®¢®£® ª®¬¯®¥â tree_list, ®¢ë© ª®¬¯®¥â text_editor, |
¤®ªã¬¥â æ¨ï ¯® ¡¨¡«¨®â¥ª¥ |
à â ª¨ï®¢ (Mario79) ¤®à ¡®âª ª®¬¯®¥â penDialog, ¯¥à¥¢®¤ |
¥ª®â®àëå ¯à¨«®¦¥¨© ¥£® ¨á¯®«ì§®¢ ¨¥, ®¢ë© ª®¬¯®¥â PathShow |
/---------------------------\ |
* âë ¢ë室 ¤¨áâਡã⨢®¢ * |
\---------------------------/ |
RE N1 30.08.2003 |
RE N2 07.10.2003 |
RE N3 26.11.2003 |
RE N4 23.12.2003 |
RE N5 15.02.2004 |
RE N6 27.03.2004 |
KOLIBRI N1 16.05.2004 |
RE N7 11.06.2004 |
KOLIBRI N2 28.08.2004 |
RE N8 01.12.2004 |
KOLIBRI N3 22.02.2005 |
ë¯ã᪠2: 20.03.2005 |
KOLIBRI N4 07.06.2005 |
KOLIBRI 0.5.0.0 04.10.2005 |
0.5.1.0 12.10.2005 |
0.5.2.0 02.12.2005 |
0.5.3.0 18.03.2006 |
0.5.8.0 09.07.2006 |
0.5.8.1 25.07.2006 |
0.6.0.0 04.09.2006 |
0.6.3.0 31.10.2006 |
0.6.5.0 14.02.2007 |
0.7.0.0 07.06.2007 |
0.7.1.0 23.09.2007 |
0.7.5.0 31.01.2009 |
0.7.7.0 13.12.2009 |
/---------------------------\ |
* ®«¨¡à¨ * |
\---------------------------/ |
í⮬ ᯨ᪥ ¯® ¢®§¬®¦®á⨠¯¥à¥ç¨á«¥ë ¢á¥, ªâ® ªâ¨¢® ¯®¬®£ « |
ᮧ¤ ¨î ¨ à §¢¨â¨î ®«¨¡à¨ . |
(ᯨ᮪ ¯¥à¥ç¨á«¥ ¢® ¢à¥¬¥®¬ ¯®à浪¥ ãç áâ¨ï ¢ ¯à®¥ªâ¥, ᢥàåã ¢¨§ - |
¨§ ¯à®è«®£® ¢ ¡ã¤ã饥, ç¥à¥§ áâ®ï饥) |
* Trans \ |
* VaStaNi | |
* ¢ ®¤¤ã¡ë© | |
* à â ª¨ï®¢ (Mario79) | |
* ¨å ¨« ¥¬¥ïª® (mike.dld)| á¨á⥬®¥ ¯à®£à ¬¬¨à®¢ ¨¥ |
* ¥à£¥© ã§ì¬¨ (Wildwest) | |
* «ï¢¨ ¤à¥© (halyavin) | § £àã§ç¨ª¨, |
* ¨å ¨« ¨á®¢¨ (Mihasik) | ãᮢ¥àè¥á⢮¢ ¨ï ï¤à ¨ ¤à. |
* ¤à¥© £ â쥢 | |
(andrew_programmer) | |
* NoName | |
* ¢£¥¨© à¥ç¨ª®¢ | |
(Diamond) | |
* ¨å ©«®¢ «ìï - (Ghost) | |
* ¥à£¥© ¥¬ñ®¢ (Serge) | |
* Johnny_B | |
* kasTIgar | |
* SPraid | |
* Rus | |
* Alver | |
* Maxis | |
* Galkov | |
* CleverMouse | |
* tsdima | |
* turbanoff | |
* Asper | |
* art_zh / |
* ¨å ¨« ¨á®¢¨ (Mihasik) \ |
* ¤à¥© ¢ã誨 (Willow) | |
* ¨å ¨« ¥¬¥ïª® (mike.dld) | |
* ¢«îè¨ ¢£¥¨© (Exis) | |
* ¢ ®¤¤ã¡ë© | ¯à¨ª« ¤®¥ ¯à®£à ¬¬¨à®¢ ¨¥ |
* à â ª¨ï®¢ (Mario79) | |
* ¥à£¥© ã§ì¬¨ (Wildwest) | ᮧ¤ ¨¥ ®¢ëå, |
* «ï¢¨ ¤à¥© (halyavin) | ¯®àâ¨à®¢ ¨¥ áãé¥áâ¢ãîé¨å |
* Hex | ¨«¨ ¤®à ¡®âª áâ àëå |
* ¤à¥© £ â쥢 | ¯à®£à ¬¬ ¤«ï ®«¨¡à¨ |
(andrew_programmer) | |
* ealex | |
* Olaf | |
* ¢£¥¨© à¥ç¨ª®¢ (Diamond)| |
* Navanax | |
* Johnny_B | |
* ¢¥« 묮¢áª¨© (Heavyiron)| |
* ¨â «¨© ¥¤¨ª | |
(mistifi(ator) | |
* ¨å ©«®¢ «ìï - (Ghost) | |
* ¢â¨å®¢ ªá¨¬ (Maxxxx32) | |
* « ¤¨¬¨à ©æ¥¢ | |
(Rabid Rabbit) | |
* vectoroc | |
* «¥ªá¥© ¥¯«®¢ - <Lrz> | |
* ¥à£¥© ¥¬ñ®¢ (Serge) | |
* YELLOW | |
* iadn | |
* Maciej Guba (macgub) | |
* Mario Birkner (cYfleXX) | |
* hidden player (hidnplayr) | |
* trolly | |
* nilgui | |
* kaitz | |
* ¥¤ª | |
* SPraid | |
* Rus | |
* Alver | |
* Dron2004 | |
* Gluk | |
* «¥ªá ¤à ®£®¬ § (Albom) | |
* ¨à¨«« ¨¯ ⮢ (Leency) | |
* ᨫ¨© ®á¥ª® (vkos) | |
* IgorA | |
* barsuk | |
* staper | |
* chaykin | |
* «¥ªá ¤à ¥é¥à类¢ | |
(Self-Perfection) | |
* CleverMouse | |
* tsdima | |
* art_zh | |
* Asper | |
* Pterox | |
* Artemonische | |
* dunkaist / |
* Hex \ ¤®ªã¬¥â æ¨ï |
* Diamond / |
* CodeWorld \ áâ àë© ä®à㬠http://meos.sysbin.com |
* mike.dld / á ©â http://kolibrios.org, svn-á¥à¢¥à ¨ ®¢ë© ä®à㬠|
* «¥ªá¥© ¥¯«®¢ - <Lrz> \ «®£®â¨¯ KolibriOS |
* goglus | ¤¨§ © |
* ¨à¨«« ¨¯ ⮢ (Leency) / |
* ¢¥« 묮¢áª¨© (Heavyiron) \ |
* ¨â «¨© ¥¤¨ª (mistifi(ator)| |
* vectoroc | |
* Veliant | â¥áâ¨à®¢ ¨¥, |
* AqwAS | ¬®à «ì ï ¯®¤¤¥à¦ª |
* Mike | |
* camper | |
* Dmitry the Sorcerer | |
* â ã «ì¯ | |
* Maxis | |
* Galkov | |
* ChE / |
¨ ¤à㣨¥... |
KolibriOS team |
/data/rus/docs/STACK_RU.TXT |
---|
0,0 → 1,378 |
â® ®áãé¥á⢫¥® |
================== |
«¥¤ãî騥 ®á®¡¥®á⨠¯à¨áãâáâ¢ãîâ ¢ ª®¤¥ TCP/IP á⥪ : |
஢¥ì IP. |
ICMP. |
஢¥ì TCP. |
஢¥ì UDP. |
®ª «ìë© ¢®§¢à â 横« . |
Realtek 8029 ¨â¥à䥩ᮢ á¥â¨ áâ ¤ àâ Ethernet PCI. |
Realtek 8139 ¨â¥à䥩ᮢ á¥â¨ áâ ¤ àâ Ethernet PCI. |
Intel i8255x PCI ¨â¥à䥩á á¥â¨ áâ ¤ àâ Ethernet. |
¨ ¬¨ç¥áª ï â ¡«¨æ ¯à®â®ª®« ®¯à¥¤¥«¥¨ï ¤à¥á®¢. |
Point-to-point ¯à®â®ª®«(PPP) |
á«¥¤ãî騥 â¥à¥â ¯à®£à ¬¬ë: |
HTTP á¥à¢¥à |
POP ª«¨¥â |
Telnet |
DNS Name resolver |
Mp3 á¥à¢¥à |
TFTP ª«¨¥â |
IRC ª«¨¥â |
FTP ª«¨¥â |
PPP - §¢®¨«ª |
áâì àï¤ íªá¯¥à¨¬¥â «ìëå ¯à¨«®¦¥¨© ¤«ï ¯à®¨£àë¢ ¨ï ¯®â®ª®¢®© ¬ã§ëª¨ ¨ |
¢ë¯®«¥¨ï ¢§ ¨¬®¤¥©áâ¢¨ï ¯à®æ¥áᮢ ç¥à¥§ ᮪¥âë. ª¦¥ ¥áâì ¯à®áâ¥ìª¨© |
¡à 㧥à, ¯®§¢®«ïî騩 « §¨âì ¯® ¢á¥¬¨à®© ¯ ã⨥(WWW). |
â® ¥ ®áãé¥á⢫¥® |
=================== |
஢¥ì IP ¥ ®¡à ¡ âë¢ ¥â ®¯æ¨¨ § £®«®¢ª . |
஢¥ì IP ¥ ¯®¤¤¥à¦¨¢ ¥â ¬ àèàã⨧ æ¨î. |
à £¬¥â æ¨ï ¯ ª¥â ¥ ¯®¤¤¥à¦¨¢ ¥âáï. |
®ä¨£ãà æ¨ï PPP ¢ ®«¨¡à¨ |
=========================== |
¬®âà¨â¥ ppp.txt(¨«¨ ppp_rus.txt á àãá᪨¬ ¯¥à¥¢®¤®¬) |
ª ᪮䨣ãà¨à®¢ âì ®«¨¡à¨ ¤«ï «®ª «ì®© á¥â¨ |
============================================== |
«ï ç « ã ¢ á ¤®«¦ ¡ëâì á¥â¥¢ ï ª àâ áâ ¤ àâ Ethernet ¨«¨, ¥á«¨ ¥ñ ¥â, |
¢áâ஥ãî ¢ ¢ èã á¨á⥬ãî ¯« âã. ᫨ ¢ë, ¥ § ¥â¥, ¥áâì «¨ ã ¢ á á¥â¥¢ ï |
ª àâ , â® ¯à®¡ã©â¥ ᪮䨣ãà¨à®¢ âì á⥪. ᫨ ® ¥áâì ¨ ¯®¤¤¥à¦¨¢ ¥âáï, â® |
ᬮ¦¥â¥ ¨á¯®«ì§®¢ âì ¥ñ. |
áâ ®¢ª â ¡«¨æë ¯à®â®ª®« ®¯à¥¤¥«¥¨ï ¤à¥á®¢ |
----------------------------------------------- |
¡«¨æ ¯à®â®ª®« ®¯à¥¤¥«¥¨ï ¤à¥á®¢ ¢ ®«¨¡à¨ 㦥 ¤¨ ¬¨ç¥áª¨ ᮧ¤ ¨ |
᪮䨣ãà¨à®¢ . ë ¬®¦¥â¥ ¯®á¬®âà¥âì, á ª ª¨¬¨ ª®¬¯ìîâ¥à ¬¨ ®«¨¡à¨ à ¡®â ¥â, |
¢ë¯®«¨¢ ¯à¨«®¦¥¨¥ ARPSTAT. |
®¤ª«î票¥ ª «®ª «ì®© á¥â¨ |
--------------------------- |
£à㧨⥠®«¨¡à¨, § ⥬ ¢ë¡¥à¨â¥ STACKCFG(ª®ä¨£ãà æ¨ï á⥪ ) ¢ ¬¥î NET(á¥âì). |
¦¬¨â¥ ®¯ªã '⥨ï', § ⥬ ¢ë¡¥à¨â¥ 'à ©¢¥à ª¥â '. |
¦¬¨â¥ "Change"(¢ë¡®à) à冷¬ á ¤à¥á®¬ IP, ¨ ¢¢¥¤¨â¥ ã¦ë© IP, ª®â®àë© ¢ë |
å®â¨â¥ ¨á¯®«ì§®¢ âì. ¤®á⮢¥àìâ¥áì, çâ® ® 室¨âáï ¢ ⮩ ¦¥ á ¬®© ¯®¤á¥â¨, |
çâ® ¨ á ¬ «®ª «ì ï á¥âì, ª ª®â®à®© ¢ë ¯®¤ª«îç¥ë. ¦¬¨â¥ "Apply"(¯à¨¬¥¨âì) |
¤«ï ¯®¤â¢¥à¦¤¥¨ï ¨§¬¥¥¨©. |
ªà®©â¥ ¯à®£à ¬¬ã. |
⥪ ᪮䨣ãà¨à®¢ ¨ § ¯ãé¥. ë ¬®¦¥â¥ ¯à®¢¥à¨âì ¥£® à ¡®âã, ¯à®¯¨£®¢ ¢ |
®«¨¡à¨ á 㤠«¥®£® ª®¬¯ìîâ¥à . |
¬ë© ¯à®á⮩ ᯮᮡ ¯®¤ª«îç¨âì ¤¢ PC ¢¬¥á⥠- íâ® ¨á¯®«ì§®¢ âì ã«¥¢®¥ |
¬®¤¥¬®¥ ᮥ¤¨¥¨¥. â® ®¡ë箥 ᮥ¤¨¥¨¥ ª®¬¯ìîâ¥à®¢ ¯®á।á⢮¬ ª ¡¥«ï. ¨ |
¬®£ãâ ¡ëâì ªã¯«¥ë ¢¬¥áâ¥ á ¯ ¬ïâìî ¨«¨ ¯à®á⮠ᤥ« ë. ®¤à®¡®á⨠¬®¦® ©â¨ |
¢ â¥à¥â¥. é¨â¥ ¯®¨áª®¢¨ª å, ( ¯à¨¬¥à www.gogle.ru) ¢¢¥¤ï ¢ áâபã |
¯®¨áª : '®à£ ¨§ æ¨ï ᮥ¤¨¥¨ï ª®¬¯ìîâ¥à®¢ á ¯®¬®éìî ª ¡¥«ï' ¨«¨ ¯®¤®¡ë¥. |
ª ¨á¯®«ì§®¢ âì TCP/IP ¡¥§ ¯®¤ª«îç¥¨ï ª á¥â¨ |
============================================= |
®«¨¡à¨ ¯®¤¤¥à¦¨¢ ¥â ä®à¬ã «®ª «ì®£® ¢®§¢à â 横« , íâ® § ç¨â, çâ® |
¯à¨«®¦¥¨ï ®¤®¬ ¨ ⮬ ¦¥ á ¬®¬ PC ¬®£ãâ ®¡é âìáï ¤àã£ á ¤à㣮¬ ç¥à¥§ |
᮪¥âë, ª ª ¥á«¨ ¡ë ®¨ 室¨«¨áì 㤠«ñëå ª®¬¯ìîâ¥à å. ⮡ë ᮥ¤¨ïâìáï |
á ¯à¨«®¦¥¨¥¬ «®ª «ì®© ¬ 訥, ®¯à¥¤¥«¨â¥ «®ª «ìë© ¤à¥á IP ª ª ¤à¥á |
§ 票ï. ë ¤ ¦¥ ¥ ¤®«¦ë ª®ä¨£ãà¨à®¢ âì á⥪ ¤«ï á¥â¨ áâ ¤ àâ Ethernet, |
«®ª «ìë© ¢®§¢à â 横« ¡ã¤¥â à ¡®â âì ¡¥§ «î¡ëå á¥â¥¢ëå, ¯¯ à âëå á।áâ¢. |
®à®è® ¯®¤å®¤¨â ¤«ï ¯à®¢¥àª¨ ¨ ®â« ¤ª¨ á¥â¥¢ëå ¯à¨«®¦¥¨©. |
ਪ« ¤®© ¯à®£à ¬¬ë© ¨â¥à䥩á |
================================ |
§à ¡®â稪 ¬®¦¥â ®¡à â¨âìáï ª á⥪ã ç¥à¥§ ¯à¥àë¢ ¨¥ 0x40, äãªæ¨¨ 53. ©« |
TFTPC.ASM - å®à®è¨© ¯à¨¬¥à ⮣®, ª ª ¬®¦® ¨á¯®«ì§®¢ âì ¯à®£à ¬¬ë© ¨â¥à䥩á |
(¯® ªà ©¥© ¬¥à¥, ¤«ï UDP), ® ª ª á¥â¥¢ ï ª®¬¬ã¨ª æ¨ï, ¤®¢®«ì® á«®¦¥. ¤ ¬ |
ªà ⪨© ®¡§®à. |
®ª¥âë |
======= |
ਫ®¦¥¨ï ᮥ¤¨ïîâáï ¤àã£ á ¤à㣮¬ ¨ ¯¥à¥¤ îâ ¨ä®à¬ æ¨î ¬¥¦¤ã ᮡ®© ç¥à¥§ |
¬¥å ¨§¬, §¢ ë© '᮪¥â®¬'. ®ª¥âë - ®ª®¥çë¥ â®çª¨ ¤«ï ª®¬¬ã¨ª 樨. «ï |
ª ¦¤®£® 㦮£® á¥â¥¢®£® ¯à¨«®¦¥¨ï ¤®«¦¥ ¡ëâì ®âªàëâ å®âï ¡ë ®¤¨ ᮪¥â. |
ᯮ«ì§®¢ ¨¥ ᮪¥â®¢ ¥¬®£® ¯®å®¤¨â ¨á¯®«ì§®¢ ¨ï ä ©«®¢ ¢ . ë |
®âªàë¢ ¥â¥, ç¨â ¥â¥ ¨ ¯¨è¥â¥ ¢ ¨å, § ⥬ § ªàë¢ ¥â¥. ¤¨á⢥ ï ¢¥éì, |
ª®â®à ï ¤¥« ¥â ¦¨§ì ¥¬®£® ¡®«¥¥ á«®¦®© - íâ® â®, çâ® ¢ ®â«¨ç¨¥ ®â à ¡®âë á |
ä ©« ¬¨, ã ¢ á ¯®ï¢¨âáï âà㤮á⨠á à ¡®â®© ᮪¥â®¢ ( ¯à¨¬¥à, ¥ § å®ç¥â |
§ ªàë¢ âìáï) |
®§ ª®¬¨¬áï á â¥à¬¨®«®£¨¥© ¯à¥¦¤¥, 祬 ¬ë ¯®©¤ñ¬ ¤ «ìè¥. |
*®ª¥â ¨ª «ìë© ¨¤¥â¨ä¨ª â®à, ¨á¯®«ì§ã¥¬ë© ¯à¨«®¦¥¨¥¬ ¤«ï |
ª®¬¬ã¨ª 樨. |
*®ª «ìë© ¯®à⠨᫮, ª®â®à®¥ ¨¤¥â¨ä¨æ¨àã¥â 㦮¥ ¯à¨«®¦¥¨¥ |
«®ª «ì®¬ ª®¬¯ìîâ¥à¥. ®àâë - ᯮᮡ, ¯®§¢®«ïîé¨å ¬®¦¥á⢠¬ ¯à¨«®¦¥¨© |
®¡é âìáï á ¤à㣨¬¨ ª®¬¯ìîâ¥à ¬¨, ¡« £®¤ àï 祬㠥⠯ãâ ¨æë ¢ ¯¥à¥¤ ¢ ¥¬ëå |
¤ ëå (¥å¨ç¥áª®¥ ®¯à¥¤¥«¥¨¥ '¬ã«ì⨯«¥ªáë¥'). ¨á«® ¯®àâ - 16 ¡¨â. |
*¤ «ñë© ¯®à⠨᫮, ª®â®à®¥ ¨¤¥â¨ä¨æ¨àã¥â ¯à¨«®¦¥¨¥ 㤠«ñ®¬ |
ª®¬¯ìîâ¥à¥, ª ª®â®à®¬ã ¬ë ®¡à é ¥¬áï. 㤠«ñ®¬ ª®¬¯ìîâ¥à¥ - íâ® '«®ª «ìë© |
¯®àâ'. ¨á«® ¯®àâ - 16 ¡¨â. |
*¤à¥á IP â® 32 ¡¨â®¥ ç¨á«®, ª®â®à®¥ ¨¤¥â¨ä¨æ¨àã¥â 㤠«ñë© PC, |
á ª®â®àë¬ ¬ë ®¡é ¥¬áï. |
* áá¨¢ë© à¥¦¨¬ ⮠०¨¬, ¢ ª®â®à®¬ ᮪¥â ®âªàëâ, «®ª «ìë© PC ¦¤ñâ |
ᮥ¤¨¥¨ï. |
*ªâ¨¢ë© ०¨¬ ⮠०¨¬, ¢ ª®â®à®¬ ᮪¥â ®âªàëâ, «®ª «ìë© PC ¯ëâ ¥âáï |
ᮥ¤¨¨âìáï á 㤠«ñë¬ PC. |
®¥¤¨ïïáì á ᮪¥â®¬ 㤠«¥®¬ PC, ¢ë ¤®«¦ë ¥ ⮫쪮 ®¯à¥¤¥«¨âì IP ¤à¥á, |
® ¨ ¯®«®áâìî ª¢ «¨ä¨æ¨à®¢ âì ¥£®, â.¥. ®¯à¥¤¥«¨âì IP ¤à¥á ¨ ç¨á«® ¯®àâ . |
ç¥ á⥪ 㤠«ñ®¬ PC ¥ ¡ã¤¥â § âì, ª ª®¬ã ¯à¨«®¦¥¨î ¯à¥¤ § ç îâáï |
¯®á« ë¥ ¤ ë¥. ®â ¥¡®«ì让 ¯à¨¬¥à: |
192.168.1.10:80 ;ë ¯à¨á®¥¤¨ï¥¬áï ª ª®¬¯ìîâ¥àã á IP ¤à¥á®¬ 192.168.1.10 ª |
80 ¯®àâã. |
¨á« ¯®àâ ïîâáï ¢ ¦ë¬¨. ¥ª®â®àë¥ '¨§¢¥áâë' ¨ ®¡¥á¯¥ç¨¢ îâ ¤®áâ㯠ª |
®¡é¨¬ ¯à¨«®¦¥¨ï¬. ¯à¨¬¥à, ¯®àâ 80 ¨á¯®«ì§ã¥âáï á¥à¢¥à ¬¨ £¨¯¥à⥪á⮢®£® |
âà ᯮà⮣® ¯à®â®ª®« (HTTP). ª¨¬ ¯ãâñ¬ ï ¬®£ã ᮥ¤¨¨âìáï á ¢¥¡á¥à¢¥à®¬ |
㦮¬ ª®¬¯ìîâ¥à¥ ¡¥§ ¥®¡å®¤¨¬®á⨠㧠¢ âì ¯à®á«ã訢 ¥¬ë© ¯à¨«®¦¥¨¥¬ ®¬¥à |
¯®àâ . |
ª ¢ë § ¥â¥, ¥áâì ¤¢ ०¨¬ : áá¨¢ë© ¨ ªâ¨¢ë©. ¥¡á¥à¢¥à ®âªàë« |
¯ áá¨¢ë© á®ª¥â, ¯®áª®«ìªã ® ¦¤¥â ¢å®¤ïé¨å § ¯à®á®¢ ¯®¤ª«î票¥. |
Web-¡à®ã§¥à ®âªàë« ªâ¨¢ë© ᮪¥â, ¯®â®¬ã çâ® ® ¯ëâ ¥âáï ᮥ¤¨¨âìáï á |
㪠§ ë¬ ã¤ «ñë¬ ª®¬¯ìîâ¥à®¬. |
®áâ㯠ª ¯à®£à ¬¬¨à®¢ ¨î ¨â¥à䥩á |
==================================== |
§à ¡®â稪 ®¡à é ¥âáï ª äãªæ¨ï¬ á⥪ ç¥à¥§ ¯à¥àë¢ ¨¥ 0x40, äãªæ¨¨ 53. |
¥ª®â®àë¬ äãªæ¨ï¬ ¬®¦® ®¡à â¨âìáï ç¥à¥§ äãªæ¨î 52, ® ®¨ £« ¢ë¬ ®¡à §®¬ |
¯à¥¤ § ç¥ë ¤«ï ª®ä¨£ãà 樨 á⥪ . |
®â äãªæ¨©, ª®â®àë¥ ¢ë ¬®¦¥â¥ ¨á¯®«ì§®¢ âì: |
®«ãç ¥¬ «®ª «ìë© IP ¤à¥á |
--------------------------- |
eax = 52 |
ebx = 1 |
IP ¤à¥á ¢®§¢à ⨫áï ¢ eax (¢ ¢¨¤¥ ¡ ©â®¢, ¨§ ª®â®àëå á®á⮨â â¥à¥â ¤à¥á) |
¯¨áì ¤«ï à ᯮ«®¦¥¨ï ¢ á⥪¥ ¢å®¤®© ®ç¥à¥¤¨ |
----------------------------------------------- |
eax = 52 |
ebx = 6 |
edx = ç¨á«® ¡ ©â®¢ ¤«ï § ¯¨á¨ |
esi = 㪠§ â¥«ì ¤ ë¥ (¢ ¯à¨ª« ¤®¬ ¯à®áâà á⢥) |
® ¢®§¢à 饨î, ¢ eax ᮤ¥à¦¨âáï 0, ¥á«¨ OK, ¨«¨ 0xFFFFFFFF, ¥á«¨ ®è¨¡ª . |
â®â ¨â¥à䥩á - ⮫쪮 ¤«ï ¬¥¤«¥ëå á¥â¥¢ëå ¤à ©¢¥à®¢ (PPP, SLIP) |
⥨¥ ¤ ëå ¨§ á¥â¥¢®© ®ç¥à¥¤¨ ¢ë¢®¤ |
--------------------------------------- |
eax = 52 |
ebx = 8 |
esi = 㪠§ â¥«ì ¤ ë¥ (¢ ¯à¨ª« ¤®¬ ¯à®áâà á⢥) |
® ¢®§¢à 饨î, eax áç¨â ¥â ç¨á«® ¡ ©â®¢ ¯¥à¥¤ ë¬. |
â®â ¨â¥à䥩á - ⮫쪮 ¤«ï ¬¥¤«¥ëå á¥â¥¢ëå ¤à ©¢¥à®¢ (PPP, SLIP) |
âªàë¢ ¥¬ UDP ᮪¥â |
------------------- |
eax = 53 |
ebx = 0 |
ecx = «®ª «ìë© ¯®àâ |
edx = 㤠«¥ë© ¯®àâ |
esi = 㤠«¥ë© ip ¤à¥á (¢ ¢¨¤¥ ¡ ©â®¢, ¨§ ª®â®àëå á®á⮨â â¥à¥â ¤à¥á) |
®¬¥à ᮪¥â ¢®§¢à éñ ¢ eax. |
®§¢à é ¥¬®¥ § 票¥ 0xFFFFFFFF ®§ ç ¥â, ç⮠᮪¥âë ¥ ®âªà뫨áì. |
âªàë¢ ¥¬ TCP ᮪¥â |
------------------- |
eax = 53 |
ebx = 5 |
ecx = «®ª «ìë© ¯®àâ |
edx = 㤠«¥ë© ¯®àâ |
esi = 㤠«¥ë© ip ¤à¥á (¢ ¢¨¤¥ ¡ ©â®¢, ¨§ ª®â®àëå á®á⮨â â¥à¥â ¤à¥á) |
edi = ०¨¬: SOCKET_PASSIVE ¨«¨ SOCKET_ACTIVE (®¯à¥¤¥«ñ ¢ stack.inc) |
®¬¥à ᮪¥â ¢®§¢à é ¥âáï ¢ eax. |
®§¢à é ¥¬®¥ § 票¥ 0xFFFFFFFF ®§ ç ¥â, ç⮠᮪¥âë ¥ ®âªà뫨áì. |
ªàë⨥ ᮪¥â (®«ìª® UDP) |
---------------------------- |
eax = 53 |
ebx = 1 |
ecx = ®¬¥à ᮪¥â |
® ¢®§¢à 饨î, ¢ eax ᮤ¥à¦¨âáï 0, ¥á«¨ OK, ¨«¨ 0xFFFFFFFF, ¥á«¨ ®è¨¡ª . |
ªàë⨥ ᮪¥â (®«ìª® TCP) |
---------------------------- |
eax = 53 |
ebx = 8 |
ecx = ç¨á«® ᮪¥â |
® ¢®§¢à 饨î, ¢ eax ᮤ¥à¦¨âáï 0, ¥á«¨ OK, ¨«¨ 0xFFFFFFFF, ¥á«¨ ®è¨¡ª . |
¯à®á ᮪¥â |
------------- |
eax = 53 |
ebx = 2 |
ecx = ®¬¥à ᮪¥â |
® ¢®§¢à 饨î, eax á®åà ï¥â ç¨á«® ¡ ©â®¢ ¢ ¢®§¢à éñ®¬ ¡ãä¥à¥. |
⥨¥ ¤ ëå á ᮪¥â |
---------------------- |
eax = 53 |
ebx = 3 |
ecx = ç¨á«® ᮪¥â |
® ¢®§¢à 饨î, eax ᮤ¥à¦¨â ç¨á«® á®åà ñëå ¡ ©â, bl ᮤ¥à¦¨â ¡ ©â ¤ ëå. |
¯¨áì ¢ ᮪¥â (®«ìª® UDP) |
--------------------------- |
eax = 53 |
ebx = 4 |
ecx = ç¨á«® ᮪¥â |
edx = ç¨á«® ¡ ©â®¢ ¤«ï § ¯¨á¨ |
esi = 㪠§ â¥«ì ¤ ë¥ (¢ ¯à¨ª« ¤®¬ ¯à®áâà á⢥) |
® ¢®§¢à 饨î, ¢ eax ᮤ¥à¦¨âáï 0, ¥á«¨ OK, ¨«¨ 0xFFFFFFFF, ¥á«¨ ®è¨¡ª . |
®§¢à 饨¥ á®áâ®ï¨ï ᮪¥â (®«ìª® TCP) |
----------------------------------------- |
eax = 53 |
ebx = 6 |
ecx = ®¬¥à ᮪¥â |
® ¢®§¢à 饨î, ¢ eax ᮤ¥à¦¨âáï á®áâ®ï¨¥ TCP ᮪¥â®¢. |
â äãªæ¨ï ¬®¦¥â ¨á¯®«ì§®¢ âìáï, çâ®¡ë ®¯à¥¤¥«¨âì, ª®£¤ ᮪¥â ä ªâ¨ç¥áª¨ |
ᮥ¤¨¨«áï á ¤à㣨¬ ᮪¥â®¬. ®®¡é¥, ¤ ë¥ ¥ ¬®£ãâ ¡ëâì § ¯¨á ë ¢ ᮪¥â, |
¯®ª ¯®¤ª«î票¥ ¥ ãáâ ®¢«¥® (TCB_ESTABLISHED). ®áâ®ï¨ï ᮪¥â®¢ ®¯à¥¤¥«¥ë |
¢ ä ©«¥ stack.inc, ª ª TCB_ |
¯¨áì ¢ ᮪¥â (®«ìª® TCP) |
--------------------------- |
eax = 53 |
ebx = 7 |
ecx = ®¬¥à ᮪¥â |
edx = ç¨á«® ¡ ©â, ã¦ëå ¤«ï § ¯¨á¨ |
esi = 㪠§ â¥«ì ¤ ë¥ (¢ ¯à¨ª« ¤®¬ ¯à®áâà á⢥) |
® ¢®§¢à 饨î, ¢ eax ᮤ¥à¦¨âáï 0, ¥á«¨ OK, ¨«¨ 0xFFFFFFFF, ¥á«¨ ®è¨¡ª . |
஢¥àª ®¬¥à ¯®àâ |
--------------------- |
eax = 53 |
ebx = 9 |
ecx = ®¬¥à ¯®àâ |
â äãªæ¨ï ¨á¯®«ì§ã¥âáï, çâ®¡ë ®¯à¥¤¥«¨âì, ¨á¯®«ì§ã¥âáï «¨ ®¬¥à ¯®àâ ª ª¨¬¨ |
- «¨¡® ᮪¥â ¬¨. ®ª «ìë© ®¬¥à ¯®àâ ®¡ëç® ã¨ª «¥. |
® ¢®§¢à 饨î, eax = - 1 ¤«ï ®¬¥à ¯®àâ , ª®â®àë© ¨á¯®«ì§ã¥âáï, ¨ ç¥ |
¢®§¢à é ¥âáï 0. |
âªàë⨥ TCP ᮪¥â ¢ ®«¨¡à¨ |
============================= |
áâì ¤¢ ᯮᮡ ®âªàëâ¨ï ᮪¥â - áá¨¢ë© ¨«¨ ªâ¨¢ë©. |
ਠáᨢ®¬ ¯®¤ª«î票¨, ¯à¨«®¦¥¨¥ 'á«ãè ¥â' ¢å®¤ï騥 § ¯à®áë ®â 㤠«¥ëå |
¯à¨«®¦¥¨©. ¡ëç® ¢ë íâ® ¤¥« ¥â¥, ®áãé¥á⢫ïï ®¯¥à æ¨î ª«¨¥â - á¥à¢¥à. |
¯®§¢®«ï¥â «î¡®¬ã ¤à㣮¬ã ¯à¨«®¦¥¨î ᮥ¤¨ïâìáï á ¤ ë¬. «ï í⮣® 㦮 |
®¯à¥¤¥«¨âì '¨§¢¥áâë©' ®¬¥à «®ª «ì®£® ¯®àâ (80 ¤«ï ¥¡-á¥à¢¥à ), ¯®áâ ¢¨âì |
㤠«¥ë© IP ¨ 㤠«¥®¥ ®¬¥à ¯®àâ à ¢ë¬ 0(㪠§ë¢ ¥â, çâ® «î¡®¥ 㤠«¥®¥ |
¯à¨«®¦¥¨¥ ¬®¦¥â ᮥ¤¨¨âìáï). |
ª ⮫쪮 ᮪¥â ¡ã¤¥â ®âªàëâ, ¯à¨¤ñâáï ¦¤ âì ¢å®¤ï饣® ¯®¤ª«îç¥¨ï ¯¥à¥¤ |
¢ë¯®«¥¨¥¬ 祣® - «¨¡®. â® ¬®¦¥â ¡ëâì ¯à®¢¥àª®© á®áâ®ï¨ï à §ê¥¬ ¤«ï |
TCB_ESTABLISHED ¨«¨ ®¦¨¤ ¨¥¬ ¤ ëå ¢ ¯®«ãç î饬áï ¡ãä¥à¥. |
ªâ¨¢®¬ ¯®¤ª«î票¨ ¢ë ᮥ¤¨ï¥â¥áì á 㪠§ ë¬ ã¤ «¥ë¬ ¯®à⮬. ¤ «¥ë© |
IP ¨ 㤠«¥ë¥ ¯ à ¬¥âàë ¯®àâ ¤®«¦ë ¡ëâì ¯¥à¥¢¥¤¥ë ¢ ¥ã«¥¢ë¥ § 票ﬨ |
(¨ ç¥, á 祬 ᮥ¤¨ïâáï?). ª¦¥, ®¯à¥¤¥«¨â¥ 㨪 «ìë© ®¬¥à «®ª «ì®£® |
¯®àâ , â ª ç⮡ë 㤠«¥®¥ ¯à¨«®¦¥¨¥ ¬®£«® ©â¨ ã¦ãî ¯à®£à ¬¬ã ¨ ãáâ ®¢¨âì |
á ¥© ᮥ¤¨¥¨¥. ¥¤ì, ¬®£ãâ ¡ëâì ¥áª®«ìª® ¯à®£à ¬¬ ¢ 襩 ¬ 訥, |
¯®¤ª«îç¥ë¥ ª ®¤®¬ã ¨ ⮬㠦¥ 㤠«ñ®¬ã ª®¬¯ìîâ¥àã. |
¨¦¥ ¯¨á ®, ª ª ©â¨ 㨪 «ìë© ®¬¥à ¯®àâ . |
ª 室¨âì ¥¨á¯®«ì§®¢ ë© ®¬¥à «®ª «ì®£® ¯®àâ |
==================================================== |
®§¤ ¢ ï ªâ¨¢®¥ ¯®¤ª«î票¥ á 㤠«¥ë¬ ᮪¥â®¬, ã ¢ á ¬®¦¥â ¯®ï¢¨âìáï |
¦¥« ¨¥ ¢ë¡à âì 㨪 «ìë© ®¬¥à «®ª «ì®£® ¯®àâ . ¡ëç®, ®¬¥à «®ª «ì®£® |
¯®àâ ç¨ îâáï á 1000. «¥¤ãî騩 ª®¤ ¬®¦¥â ¨á¯®«ì§®¢ âìáï, çâ®¡ë ¯®«ãç¨âì |
¥¨á¯®«ì§®¢ ë© ®¬¥à ¯®àâ ¤® ᮧ¤ ¨ï ᮪¥â . |
mov ecx, 1000 ; ¯à¥¤¥«ï¥¬ «®ª «ìë© ¯®àâ, ç¨ ¥¬ á 1000 |
getlp: |
inc ecx |
push ecx |
mov eax, 53 |
mov ebx, 9 |
int 0x40 |
pop ecx |
cmp eax, 0 ; íâ®â «®ª «ìë© ¯®à⠨ᯮ«ì§ã¥âáï? |
jz getlp ; ¤ - ¯à®¤®«¦ ¥¬ ¯¥à¥¡¨à âì |
; ecx ᮤ¥à¦¨â ®¬¥à ᢮¡®¤®£® «®ª «ì®£® ¯®àâ |
¯¨áì ¤ ëå ¢ ᮪¥â |
===================== |
áâì ¤¢¥ äãªæ¨¨, § ¢¨áï騥 ®â ⮣®, ¡ë« «¨ à §ê¥¬ ®âªàëâ ¤«ï ¯à®â®ª®« TCP ¨«¨ |
UDP. ¯ à ¬¥âàë § ¯à®á - â® ¦¥ á ¬®¥ ª ª ¡ë â® ¨ ¡ë«®. ®£¤ ᮪¥â ®âªàë¢ ¥âáï |
¤«ï TCP, ¨á¯®«ì§ã©â¥ äãªæ¨î á®áâ®ï¨ï, çâ®¡ë ®¯à®á¨âì ¤«ï ¯®¤ª«î票ï - ¤ ë¥ |
¥ ¬®£ãâ ¡ëâì ¯¥à¥¤ ë ᮪¥âã, ¯®ª ¤à㣮© ¥ ᮥ¤¨¨«áï á í⨬. ®áâ®ï¨¥ |
᮪¥â - TCB_ESTABLISHED. |
®£¤ ¢ë ¯®áë« ¥â¥ ¤ ë¥, ¯à®¨á室¨â ᮧ¤ ¨¥ ¨ ®â¯à ¢ª ®¤®£® IP ¯ ª¥â . |
íâ® § ç¨â, çâ® ¯®«ì§®¢ ⥫ì᪮¥ ¯à¨«®¦¥¨¥ ®â¢¥ç ¥â § à §¬¥à ¯¥à¥¤ ¢ ¥¬ëå |
¯ ª¥â®¢. ®åà ï¥âáï ¬¥¥¥ 祬 768 ¡ ©â®¢ à §¬¥à ¯ ª¥â . ᫨ ¢ë ¯¨è¥â¥ |
®ª®ç¥ãî ¯à®£à ¬¬ã (â ªãî, ª ª telnet), â® ¬®¦¥â¥ § å®â¥âì ®â¯à ¢«ïâì ¯ ª¥â |
§ ª ¦¤®¥ (¥íä䥪⨢®¥) ¦ ⨥ ª« ¢¨è¨. ®¦® ¨á¯®«ì§®¢ âì â ©¬¥à, ç⮡ë |
®â¯à ¢«ïâì ¤ ë¥ ¯¥à¨®¤¨ç¥áª¨ (᪠¦¥¬, ª ¦¤ãî ᥪã¤ã). |
⥨¥ ¤ ëå ¨§ ᮪¥â |
======================= |
áâì ®¤ äãªæ¨ï ¤«ï çâ¥¨ï ¤ ëå ¨§ ᮪¥â , ¢®§¢à é îé ï ¤ ë¥ ¢ ¡ãä¥à. â |
äãªæ¨ï ®¤®¢à¥¬¥® ¢®ááâ ¢«¨¢ ¥â ®¤¨ ¡ ©â. ë ¬®¦¥â¥ ¨á¯®«ì§®¢ âì äãªæ¨î |
®¯à®á , çâ®¡ë ¯à®¢¥à¨âì ¯®«ãç î騩áï ¡ãä¥à ¤ ë¥. |
ªàë⨥ ᮪¥â |
================ |
à®áâ® ¢ë§®¢¨â¥ ᮮ⢥âáâ¢ãîéãî äãªæ¨î (¤«ï TCP ¨«¨ UDP, ᮮ⢥âá⢥®). |
ªàë¢ ï TCP ᮪¥â, ¥ § ¡ã¤ìâ¥, çâ® ¤à㣮© ª®æ¥ ᮥ¤¨¥¨ï, ᮪¥â ¬®¦¥â |
¯à®¤®«¦¨âì ®â¯à ¢«ïâì ¤ ë¥, â ª çâ® ® ®áâ ñâáï ªâ¨¢ë¬ ¢ â¥ç¥¨¥ ¥áª®«ìª¨å |
ᥪ㤠¯®á«¥ ¢ 襣® § ¯à®á . |
᫨ ã ¢ á ¥áâì ¢®¯à®áë ¨«¨ ¯à¥¤«®¦¥¨ï ¯® ã«ãç襨î í⮣® ¤®ªã¬¥â , â® |
¯®è«¨â¥ ¬¥ ¯¨á쬮 mikeh@oceanfree.net. |
¥à¥¢ñ« ¤®ªã¬¥â Hex. |
᫨ ¥áâì ¢®¯à®áë ¨«¨ ¯à¥¤«®¦¥¨ï ¯® ᮤ¥à¦ ¨î, â® ¯à®áì¡ ¯¨á âì ¬¥ |
mestack@yandex.ru ¨«¨ è ä®àã¬: http://meos.sysbin.com |
/data/rus/docs/VRR_RUS.TXT |
---|
0,0 → 1,110 |
DOS codepage text: |
_______________________________________________________________________________ |
Vertical Refresh Rater |
¥àá¨ï 2.0 |
Copyright (C) 2003, Trans |
Text Version 1.1 (02.08.03) |
Win text (cp1251). (DOS codepage text - see down.) |
------------------------------------------------------------------------------- |
®¤¥à¦ ¨¥: |
1. 祬 íâ® ¤®? |
2. áâ ®¢ª . |
3. ᯮ«ì§®¢ ¨¥. |
4. ®¯à®áë ¨ ®â¢¥âë. |
5. ®¤¤¥à¦ª . |
1. 祬 íâ® ¤®? |
--------------------- |
஡«¥¬ "60 æ" ®ç¥ì ®áâà® ¢á⠥⠯¥à¥¤ ¯®«ì§®¢ ⥫ﬨ MeOS ¢ ᮢ६¥ëå |
ãá«®¢¨ïå. ª ¯à ¢¨«®, ¡®«ìè¨á⢮ ᮢ६¥ëå ª®¬¯ìâ¥à®¢ ª®¬¯«¥ªâã¥âáï 17 |
¤î©¬®¢ë¬¨ ¬®¨â®à ¬¨ (¢á¥ çâ® ¯¨á ® ¨¦¥ ªà ©¥ ¥ ªâã «ì® ¤«ï ¢« ¤¥«ì楢 |
¬®¨â®à®¢). ᫨ 14 ¨«¨ 15 ¤î©¬®¢®¬ ¬®¨â®à¥ ¥é¥ ¬®¦® ª ª â® á¬à¨âìáï á |
ç áâ®â®© ¢¥à⨪ «ì®© à §¢¥à⪨ 60 æ, ⮠㦥 ¯à¨ 17 ¤î©¬®¢®¬ ¬®¨â®à¥ íâ® |
¯à¥¢à é ¥âáï ¢ ¯ëâªã. ¯à® ¡®«ìè¨å à §¬¥à®¢ ¬®¨â®àë ¢®®¡é¥ £®¢®à¨âì ¥ |
å®ç¥âáï, â.ª. íâ® ¯à¥¢à é ¥âáï ¯®ç⨠¢ á« ©¤-è®ã. ®¥ç® ¦¥ ¢á¥ ¢ëè¥ áª § ®¥ |
®â®á¨âáï ª áâ ¤ à⮬㠨â¥à䥩áã VESA. à §ã å®ç㠯।ã¯à¥¤¨âì ¢®¯à®áë ¯® |
¯®¢®¤ã VESA 3.0 - ¤ , ¨â¥àä¥©á ¡®«¥¥ ¡®£ âë© ¯® ¢®§¬®¦®áâï¬, ® ¨ ¢ ¥¬ ¥â |
ᯮᮡ ¯à¥ª«îç¥¨ï ¢¨¤¥®à¥¦¨¬ ¯à¨ à ¡®â¥ ¯à®æ¥áá®à ¢ § é¨é¥®¬ ०¨¬¥ |
(०¨¬ V86 ¢ MeOS ¥ ॠ«¨§®¢ !!!). |
á¢ï§¨ á ⥬, çâ® MeOS ¥ 㬥¥â (¥é¥ ¥ ã稫¨ :) ) ¤¥â¥ªâ¨à®¢ âì ®¡®à㤮¢ ¨¥ |
ª®¬¯ìîâ¥à ¯à¨ § £à㧪¥, ãáâ ¢«¨¢ ¥¬ë© £à ä¨ç¥áª¨© ¢¨¤¥®à¥¦¨¬ ¨¬¥¥â |
áâ ¤ àâãî ç áâ®âã ¢¥à⨪ «ì®© à §¢¥à⪨ à ¢ãî 60 æ (!!!!!) |
à®£à ¬¬ ï¥âáï ᢮¡®¤® à á¯à®áâà 塞®© (FreeWare) ¨ ¯®áâ ¢«ï¥âáï |
" ª ¥áâì...". ¢â®à ¥ ¥á¥â ®â¢¥âá⢥®á⨠§ ¢®§¬®¦ë© ¯à¨ç¨¥ë© |
ãé¥à¡ ( :) ). |
!!!!!_।ã¯à¥¦¤¥¨¥_!!!!!: |
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
! ⥪ã騩 ¬®¬¥â ¯à®£à ¬¬ ®á¨â (!) å à ªâ¥à, ¯®í⮬ã ! |
! ¢á¥£¤ ®áâ ¥âáï ¢¥à®ïâ®áâì ¯®àç¨ ®¡®à㤮¢ ¨ï (â.¥. ¬®¨â®à ). ᮡ¥® íâ®! |
! ª á ¥âáï ¢á¥å â¥å, 祩 ¬®¨â®à ¥ ¨¬¥¥â § é¨âë ®â ¯¥à¥£à㧮ª ¯® ç áâ®â¥. ! |
! «ï ¢á¥å à¨áªã¢è¨å - ¯à®áì¡ -> ¯®«¨âì ¯à¨« £ îéãîáï ¨ä®à¬ 樮ãî ä®à¬ã! ! |
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
2. áâ ®¢ª . |
--------------- |
§¢«¥çì ä ©« VRR (¨á¯®«ï¥¬ë© ä ©« MeOS) ¨§ à娢 ¨ ¯®¬¥áâ¨âì ¢ ª®à¥¢®© |
ª â «®£ ¤¨áª C:\ (Fat32. ¯à¨æ¨¯¥, ¬®¦¥â ¡ëâì «î¡®© ª ⮫®£) ¨«¨ |
§ £à㧮çãî ¤¨áª¥âã MeOS. |
3. ᯮ«ì§®¢ ¨¥. |
-------------------- |
©« VRR ï¥âáï áâ ¤ àë¬ ¨á¯®«ï¥¬ë¬ ä ©«®¬ ®¯¥à 樮®© á¨á⥬ë MeOS, |
ª®â®àë© ¬®¦® § ¯ãáâ¨âì ¨á¯®«¥¨¥, ¯à¨¬¥à, ç¥à¥§ SYSTREE ¨«¨ MASH. |
®á«¥ ¯®ï¢«¥¨ï ®ª ¯à®£à ¬¬ë, ¡ã¤¥â ®â®¡à ¦¥® ⥪ã饥 à §à¥è¥¨¥ ¨ â ¡«¨æ |
¢®§¬®¦ëå ०¨¬®¢ ¨ ç áâ®â ¢¥à⨪ «ì®© à §¢¥à⪨ ¤«ï ¨å. ᮦ «¥¨î, |
à §¢¥à⮪ ¯®ª ®ç¥ì ¬ «® (¯®å®¦¥ â®, íâ® ®ç¥ì ªàã⮩ ᥪà¥â ¨«¨ ¦¥ í⨬ |
¨ªâ® ¢ á¥à쥧 ¥ § ¨¬ «áï ¢¢¨¤ã ®â¯ã£¨¢ î饩 á«®¦®áâ¨. ® ¢á类¬ á«ãç ¥ ¢ |
á¥â¨ ªà ©¥ ¬ «® ¨ä®à¬ 樨 ¯® í⮬㠯®¢®¤ã ¨ ¯® ¡®«ì襩 ç á⨠¯à¨å®¤¨âáï |
¤®£ ¤ë¢ âìáï ® ¯®«®¦¥¨¨ ¤¥«). |
ë¡®à ¨ ãáâ ®¢ª ¢¨¤®à¥¦¨¬ |
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
¨¤®¥à¥¦¨¬ á ¨â¥à¥áãî饩 ç áâ®â®© ¬®¦® ¢ë¡à âì _⮫쪮_ (!!!!!) á ¯®¬®éìî |
æ¨ä஢ëå ª« ¢¨è: 1, 2, 3, 4, 5. ç «® 㦮 ¢ë¡à âì à §à¥è¥¨¥, § ⥬ |
ç áâ®âã. ¦¤ë© ¢ë¡®à ᮯ஢®¦¤ ¥âáï ¨¤¨ª 樥© íªà ¥. «ï ãáâ ®¢«¥¨ï |
¢ë¡à ®£® ¢¨¤¥®à¥¦¨¬ 㦮 ¦ âì ª« ¢¨èã 'Enter' ¨«¨ ª®¯ªã 'Ok'. ®á«¥ |
¯¥à¥å®¤ ¢ ¢ë¡à ë© ¢¨¤¥®à¥¦¨¬ ã ¢ á ¥áâì 13 ᥪ㤠¢ë¡®à . ®¦® ¨ç¥£® ¥ |
¤¥« âì ¨ ç¥à¥§ íâ® ¢à¥¬ï ¢¥à¥â¥áì ¢ ¨áå®¤ë© ¢¨¤¥®à¥¦¨¬, ¬®¦® ¦ âì ¯ àã |
à § ª ªãî-¨¡ã¤ì ª« ¢¨èã ¨«¨ ª«¨ªãâì ¯ àã à § ¯® "®áâ ⪠¬" ( àâ¥ä ªâ ¬) |
¨á室®£® ®ª ¯à®£à ¬¬ë ¨ § 䨪á¨à®¢ âì ¢ë¡®à. §¬¥àë ®ª ¯® £®à¨§®â «¨ |
¬®¦® ॣ㫨஢ âì ª®¯ª ¬¨ "à ¢®\¥¢®" ¨«¨ ª« ¢¨è ¬¨ "+\-". |
«ï ª®à४â¨à®¢ª¨ ¢ë¡®à ¨á¯®«ì§ã©â¥ ª®¯ªã "Cancel". |
¯à®£à ¬¬¥ ॠ«¨§®¢ ® ¯à¨ã¤¨â¥«ì®¥ ¢®§¢à 饨¥ ¢ ¨áå®¤ë© ¢¨¤¥®à¥¦¨¬ á |
ç áâ®â®© 60 æ á ¯®¬®éìî ª®¯ª¨ "Default". â ª ¦¥ ¬®¦¥â¥ ¢¥àãâìáï ¢ |
¯®á«¥¤¨© à ¡®ç¨© ०¨¬ á ¯®¬®éìî ª®¯ª¨ "Return" ¨«¨ ª« ¢¨è¨ 'r'. |
ਬ¥à: |
áâ ®¢«¥ ०¨¬ 1024å768 ¯à¨ 60 æ. 㦮 800å600 ¯à¨ 95 æ. |
¥©á⢨ï: ¦ âì '3', § ⥬ '1' ¨ ¤ «¥¥ ª« ¢¨èã "Enter" ¨«¨ ª®¯ªã "Ok". |
®á«¥ ¯¥à¥å®¤ ¢ ¢ë¡à ë© ¢¨¤¥®à¥¦¨¬ ª«¨ª ¥¬ ¯ àã à § "®áâ ⪠" (¨«¨ ⮬ |
¬¥á⥠£¤¥ ¡ë«®) ®ª . «¥¥ ¯à¨ ¥®¡å®¤¨¬®á⨠ª®à४â¨à㥬 à §¬¥à íªà ¯® |
£®à¨§®â «¨ á ¯®¬®éìî ª®¯®ª "à ¢®\¥¢®" |
4. ®¯à®áë ¨ ®â¢¥âë. |
------------------------ |
5. ®¤¤¥à¦ª . |
---------------- |
ᥠ¢®¯à®áë, § ¬¥ç ¨ï ¨ ¯®¦¥« ¨ï ë ¬®¦¥â¥ ¯à ¢¨âì ¢â®àã ¯® á«¥¤ãî騬 ¤à¥á ¬: |
transafe@rambler.ru |
transafe@chat.ru |
trans397@yahoo.com |
®«ì§ã©â¥áì §¤®à®¢ì¥! |
Trans. |
/data/rus/drivers/atikms.dll |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/rus/e80 |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/rus/fonts/bold.chr |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/rus/fonts/char.mt |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/rus/fonts/char2.mt |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/rus/games/FindNumbers |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/rus/games/appdata.dat |
---|
0,0 → 1,0 |
⮠ï¥âáï à §à ¡®â稪®¬ QT?IBMMicrosoftTrolltechApple⮠ï¥âáï ®â殬-®á®¢ ⥫¥¬ Menuet ¨ Menuet64?¦. «¨ª. ®à¢ «ì¤á. ãàìï¬ ª®¢ ¥¤®â®¢â® ï¥âáï ®â殬-®á®¢ ⥫¥¬ ¯à®¥ªâ Kolibri OS?⥯ ⥯ ®¢¢ ¥â஢ à â ª¨ï®¢¥à£¥© ¢¥à¥¢ ªãî ¢¥àá¨î ï¤à ¨¬¥¥â Windows Vista?5.05.16.07.0 ªãî ¢¥àᨨ ¨¬¥« ¯®á«¥¤¨© ¢ë¯ãé¥ë© Visual Basic ¤® VB.NET?3.04.05.06.0 §¢ ¨¥ ®¯¥à 樮®© á¨á⥬ë Linux ¨§ ç «ì® à áè¨äà®¢ë¢ «®áì ª ª...Linear Universal ExecutiveLinux with XLinus and UXLinus UNIX⮠ï¥âáï à §à ¡®â稪®¬ QuickTime?AppleMicrosoftIBMSun⮠ï¥âáï à §à ¡®â稪®¬ Solaris?MicrosoftSun microsystemsAppleIBMâ® § ¨¬ ¥âáï ª®®à¤¨ 樥© ¨ à §à ¡®âª®© Ubuntu Linux?Sun microsystemsAppleTrolltechCanonical¨â ©áª ï ¢¥àá¨ï Windows 3.1 ¨¬¥ã¥âáï ¨¬¥® â ªWindows 3.11Windows 3.1 Chinese EditionWindows for ChinaWindows 3.2à®£à ¬¬ Connectix Virtual Game Station ï¥âáï í¬ã«ïâ®à®¬ ¨¬¥¥® í⮩ ¨£à®¢®© ¯à¨áâ ¢ª¨NESSega GenesisSony PlayStationXBox¥àá¨ï VmWare ¤«ï Intel-¬ ª®¢ §ë¢ ¥âáï...VmWare XVmWare FusionVmWare Mac EditionVmMac¬¥® ® ï¥âáï ®á®¢ ⥫¥¬ ¤¨áâਡã⨢ Debian¦¥ää ® ઠââ«¢®à⪮⠪¨««¨ ¥à¤®ª«®£ FreeBSD - The power to serveYour server works wellFree and coolServe best ª®© ¨§ ¯¥à¥ç¨á«¥ëå ¤¨áâਡã⨢®¢ Linux ï¥âáï à®áᨩ᪨¬ ¤¨áâਡã⨢®¬?SuSeDebianFedoraLinuxXP ª §ë¢ ¥âáï ¯à®¯à¨¥â àë© ¤à ©¢¥à ATI ¤«ï Linux?firedrvfglrxagdfxati ª §ë¢ ¥âáï , à §à ¡ âë¢ ¥¬ ï ª ª ᢮¡®¤ë© «®£-ª«® Windows?MacOS XKolibri OSLinuxReactOS ª ï ¨§ ¯¥à¥ç¨á«¥ëå ¢¥àᨩ Windows Vista ï¥âáï ¨¡®«¥¥ ¯®«®© ¨ äãªæ¨® «ì®©?Vista Home BasicVista Home PremiumVista BusinessVista Ultimate |
/data/rus/games/ataka |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/rus/games/basekurs.kla |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/rus/games/bnc |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/rus/games/c4 |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/rus/games/checkers |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/rus/games/clicks |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/rus/games/gomoku |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/rus/games/klavisha |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/rus/games/kosilka |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/rus/games/kosskin.gfx |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/rus/games/kox |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/rus/games/lights |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/rus/games/megamaze |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/rus/games/mine |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/rus/games/msquare |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/rus/games/padenie |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/rus/games/reversi |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/rus/games/rforces |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/rus/games/snake.ini |
---|
0,0 → 1,175 |
;;===Common_preferences================================================= |
[Preferences] |
Speed=80 |
; SLOW == 0 <= Speed <= 100 == FAST |
Theme=Theme_standard |
; Theme name to use |
; See [Theme_*] sections below for available themes |
; Name of any theme must be shorter than 30 chars |
;;---Common_preferences------------------------------------------------- |
;;===Visual_themes====================================================== |
[Theme_standard] |
; all these keys are optional |
Decorations = 2 |
; 0 = nothing |
; 1 = grid_lines |
; 2 = grid_lines_with_ends |
; 3 = grid_lines_with_corners |
; 4 = grid_dots |
; 5 = borders_lines |
; 6 = borders_lines_with_corners |
; 7 = borders_dots |
; 8 = corners_dots |
; 9 = corners_inner |
; 10 = corners_outer |
; 11 = corners_crosses |
Background_color = 0,0,0 |
Decorations_color = 170,170,0 |
Snake_color = 17,17,255 |
Snake_head_color = 107,107,255 |
; by default Snake_head_color is equal to Snake_color, so the snake has no head |
Snake_picture_color = 68,136,255 |
; color of big 'SNAKE' label at start menu |
Version_picture_color = 85,255,85 |
Pause_picture_color = 17,255,17 |
Game_over_picture_color = 255,17,17 |
; ... if you end game without new record |
You_win_picture_color = 255,255,17 |
; ... if you end game with new record |
Navigation_string_color = 255,119,119 |
; color of 'PRESS * to *' and like this strings |
Game_over_string_color = 255,153,0 |
; color of strings on game_over screen |
Game_over_hiscore_color = 255,221,68 |
; color of new hiscore and champion name on game_over screen |
Eat_color = 255,255,17 |
Score_number_color = 255,255,255 |
; color of "SCORE : " string at the left bottom screen part |
Score_string_color = 255,255,255 |
; color of digits after "SCORE : " |
Level_string_color = 255,255,255 |
; color of "LEVEL : " string at the left bottom screen part |
Level_number_color = 255,255,255 |
; color of digits after "LEVEL : " |
Hiscore_number_color = 255,255,255 |
Hiscore_string_color = 255,255,255 |
Champion_string_color = 255,255,255 |
Champion_name_color = 255,255,255 |
Edit_box_selection_color= 0,176,0 |
Button_color = 221,221,221 |
; color of buttons 'play', 'exit' etc at start menu |
Button_text_color = 0,0,0 |
; color of the text on these buttons |
Stone_color = 95,135,0 |
Splash_background_color = 170,170,0 |
; background color for "LEVEL ??" label between levels |
Splash_level_string_color= 0,0,0 |
; color of "LEVEL" label |
Splash_level_number_color= 0,0,0 |
; color of two level number digits on splash between levels |
[Theme_light] |
Decorations = 2 |
Background_color = 245,245,245 |
Decorations_color = 55,55,55 |
Snake_color = 225,125,225 |
Snake_head_color = 255,125,55 |
Snake_picture_color = 105,155,205 |
Version_picture_color = 155,255,0 |
Pause_picture_color = 75,255,75 |
Game_over_picture_color = 225,125,105 |
You_win_picture_color = 55,255,155 |
Navigation_string_color = 205,105,105 |
Game_over_string_color = 205,105,105 |
Game_over_hiscore_color = 205,75,75 |
Eat_color = 225,225,25 |
Score_number_color = 100,100,255 |
Score_string_color = 100,100,255 |
Level_string_color = 100,100,255 |
Level_number_color = 100,100,255 |
Hiscore_number_color = 100,100,255 |
Hiscore_string_color = 100,100,255 |
Champion_string_color = 100,100,255 |
Champion_name_color = 100,100,255 |
Edit_box_selection_color= 0,176,0 |
Button_color = 221,221,221 |
Button_text_color = 0,0,0 |
Stone_color = 105,185,255 |
Splash_background_color = 185,255,185 |
Splash_level_string_color= 165,165,255 |
Splash_level_number_color= 255,165,165 |
[Theme_ultra_white] |
Decorations = 10 |
Background_color = 255,255,255 |
Decorations_color = 0,0,0 |
Snake_color = 30,30,30 |
Snake_head_color = 30,30,30 |
Snake_picture_color = 30,30,30 |
Version_picture_color = 70,70,70 |
Pause_picture_color = 30,30,30 |
Game_over_picture_color = 30,30,30 |
You_win_picture_color = 105,105,105 |
Navigation_string_color = 255,255,255 |
Game_over_string_color = 30,30,30 |
Game_over_hiscore_color = 0,0,0 |
Eat_color = 0,255,0 |
Score_number_color = 0,0,0 |
Score_string_color = 255,255,255 |
Level_string_color = 255,255,255 |
Level_number_color = 255,255,255 |
Hiscore_number_color = 0,0,0 |
Hiscore_string_color = 255,255,255 |
Champion_string_color = 255,255,255 |
Champion_name_color = 255,255,255 |
Edit_box_selection_color= 176,176,176 |
Button_color = 221,221,221 |
Button_text_color = 0,0,0 |
Stone_color = 145,145,145 |
Splash_background_color = 205,205,205 |
Splash_level_string_color= 255,255,255 |
Splash_level_number_color= 255,255,255 |
[Theme_ultra_black] |
Decorations = 6 |
Background_color = 0,0,0 |
Decorations_color = 255,255,255 |
Snake_color = 255,255,255 |
Snake_head_color = 255,255,255 |
Snake_picture_color = 255,255,255 |
Version_picture_color = 225,225,225 |
Pause_picture_color = 225,225,225 |
Game_over_picture_color = 225,225,225 |
You_win_picture_color = 255,255,255 |
Navigation_string_color = 0,0,0 |
Game_over_string_color = 225,225,225 |
Game_over_hiscore_color = 225,225,225 |
Eat_color = 255,0,0 |
Score_number_color = 255,255,255 |
Score_string_color = 255,255,255 |
Level_string_color = 0,0,0 |
Level_number_color = 0,0,0 |
Hiscore_number_color = 255,255,255 |
Hiscore_string_color = 255,255,255 |
Champion_string_color = 0,0,0 |
Champion_name_color = 0,0,0 |
Edit_box_selection_color= 100,100,100 |
Button_color = 221,221,221 |
Button_text_color = 0,0,0 |
Stone_color = 145,145,145 |
Splash_background_color = 30,30,30 |
Splash_level_string_color= 255,255,255 |
Splash_level_number_color= 255,255,255 |
[Theme_your_theme_name] |
;;---Visual_themes------------------------------------------------------ |
;;===Reserved_Section=================================================== |
[Reserved] |
Square_side_length=19 |
Champion_name_classic= |
Hiscore_classic=777 |
Champion_name_levels= |
Hiscore_levels=222 |
/data/rus/games/sq_game |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/rus/games/sudoku |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/rus/games/sw |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/rus/games/whowtbam |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/rus/games/xonix |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/rus/graph |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/rus/hdread |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/rus/htmlv |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/rus/icons.dat |
---|
0,0 → 1,27 |
AA-FASM -010-/SYS/DEVELOP/FASM - * |
AB-TINYPAD -009-/SYS/TINYPAD - * |
BA-EOLITE -002-/SYS/File Managers/EOLITE - * |
CA-SHELL -020-/SYS/SHELL - * |
BB-KFAR -024-/SYS/File Managers/KFAR - * |
AC-RDSAVE -017-/SYS/RDSAVE - * |
BC-CALC -004-/SYS/CALC - * |
CB-KFM -005-/SYS/File Managers/KFM - * |
JA-VRR -007-/SYS/VRR - * |
II-C4 -003-/SYS/GAMES/C4 - * |
JI-MINE -014-/SYS/GAMES/MINE - * |
IH-TETRIS -018-/SYS/GAMES/TETRIS - * |
JH-MBLOCKS -011-/SYS/GAMES/MBLOCKS - * |
HI-PONG -012-/SYS/GAMES/PONG3 - * |
GI-15 -000-/SYS/GAMES/15 - * |
HH-LIFE2 -013-/SYS/DEMOS/LIFE2 - * |
JB-ANIMAGE -015-/SYS/MEDIA/ANIMAGE - * |
IA-BOARD -019-/SYS/DEVELOP/BOARD - * |
JC-DOCPACK -008-/SYS/DOCPAK - * |
HA-MTDBG -025-/SYS/DEVELOP/MTDBG - * |
AH-PIPES -026-/SYS/GAMES/PIPES - * |
AI-SUDOKU -030-/SYS/GAMES/SUDOKU - * |
BI-ARC-II -012-/SYS/GAMES/ARCANII - * |
BH-XONIX -021-/SYS/GAMES/XONIX - * |
GH-CHECKERS-001-/SYS/GAMES/CHECKERS - * |
CI-KOSILKA -023-/SYS/GAMES/KOSILKA - * |
CH-GOMOKU -029-/SYS/GAMES/GOMOKU - * |
/data/rus/iconstrp.gif |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/rus/index_htm |
---|
0,0 → 1,30 |
<?xml version="1.0" encoding="utf-8"?> |
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" |
"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd"> |
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" > |
<head> |
<title>KolibriOS web server - default message</title> |
</head> |
<body> |
<h1>Welcome to KolibriOS server</h1> |
<p> |
If you can read this with an external html-browser then Kolibri |
networking is correctly set up. |
<br /><br />This file: /rd/1/index.htm |
</p> |
<ul> |
<li><a href="/TinyStat">TinyStat</a></li> |
<li><a href="/TinyBoard">TinyBoard</a></li> |
</ul> |
</body> |
</html> |
/data/rus/kerpack |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/rus/keymap.key |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/rus/kpack |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/rus/kuzkina.mid |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/rus/lang.inc |
---|
0,0 → 1,0 |
lang fix ru |
/data/rus/lang.ini |
---|
0,0 → 1,28 |
[start] |
startlng = 1 |
[comkey] |
ccomkey1 = 1 |
ccomkey2 = 4 |
ccomkey3 = 7 |
[altkey] |
altkey1 = 1 |
altkey2 = 4 |
altkey3 = 7 |
altkey4 = 3 |
altkey5 = 5 |
altkey6 = 6 |
altkey7 = 2 |
altkey8 = 0 |
altkey9 = 0 |
altkey0 = 0 |
[langs] |
1 = En |
2 = Fi |
3 = Ge |
4 = Ru |
5 = Fr |
6 = Et |
7 = Ua |
/data/rus/lib/cnv_png.obj |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/rus/lib/msgbox.obj |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/rus/lib/pixlib.obj |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/rus/lib/sort.obj |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/rus/media/ac97snd |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/rus/media/kiv.ini |
---|
0,0 → 1,3 |
[Shortcuts] |
Next=PgDn |
Prev=PgUp |
/data/rus/media/listplay |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/rus/media/startmus |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/rus/menu.dat |
---|
0,0 → 1,183 |
#0 **** MAIN **** |
£àë > /@1 |
¥¬ª¨ > /@4 |
à 䨪 > /@6 |
¢ãª ¨ ¬ã§ëª > /@7 |
§à ¡®âª > /@8 |
¨á⥬ > /@10 |
¡à ¡®âª ¤ ëå > /@14 |
¥âì > /@15 |
§®¥ > /@18 |
®¬®éì /rd/1/docpak |
¯ã᪠¯à®£à ¬¬ë /rd/1/run |
¢¥à襨¥ à ¡®âë /rd/1/end |
#1 **** GAMES **** |
®£¨ç¥áª¨¥ > /@2 |
ઠ¤ë > /@3 |
¬ã«ïâ®à Spectrum /rd/1/e80 |
Memory Blocks /rd/1/games/mblocks |
FreeCell /rd/1/games/freecell |
àã¡®¯à®¢®¤ /rd/1/games/pipes |
®á¨«ª /rd/1/games/kosilka |
RockeT ForceS /rd/1/games/rforces |
â ª /rd/1/games/ataka |
Find Numbers /rd/1/games/FindNumbers |
#2 **** **** |
C4 /rd/1/games/c4 |
15 /rd/1/games/15 |
¯ñà /rd/1/games/mine |
Just Clicks /rd/1/games/clicks |
誨 /rd/1/games/checkers |
SQ_Game /rd/1/games/sq_game |
Color Lines /rd/1/games/lines |
Lights /rd/1/games/lights |
à¥á⨪¨-®«¨ª¨ /rd/1/games/kox |
모 ¨ ®à®¢ë /rd/1/games/bnc |
¨««¨®¥à /rd/1/games/whowtbam |
¡¨à¨â /rd/1/games/megamaze |
®à᪮© ¡®© /rd/1/games/sw |
㤮ªã /rd/1/games/sudoku |
®-¬®ªã /rd/1/games/gomoku |
¥¢¥àᨠ/rd/1/games/reversi |
#3 **** **** |
¥âà¨á /rd/1/games/tetris |
®£ /rd/1/games/pong |
®¢ë© ®£ /rd/1/games/pong3 |
Red Square /rd/1/games/rsquare |
XONIX /rd/1/games/xonix |
ArcanII /rd/1/games/arcanii |
PheniX /rd/1/games/phenix |
¤¥¨¥ /rd/1/games/padenie |
¬¥©ª /rd/1/games/snake |
#4 **** DEMOS **** |
àñ嬥àë¥ > /@5 |
£®ì /rd/1/demos/fire |
à㦮ª /rd/1/demos/circle |
à ªâ « ¤¥«ì¡à®â /rd/1/demos/tinyfrac |
¢¥â /rd/1/demos/colorref |
« § /rd/1/demos/eyes |
àã¡ /rd/1/demos/tube |
Plasma /rd/1/demos/plasma |
Moveback /rd/1/demos/movback |
Life /rd/1/demos/life2 |
TranTest /rd/1/demos/trantest |
ã⨪ /rd/1/demos/web |
¥©¥à¢¥àª /rd/1/demos/firework |
UnvWater /rd/1/demos/unvwater |
#5 **** 3D demos **** |
ªà¨á¥©¢¥à /rd/1/3d/crownscr |
3D-ã¡ /rd/1/3d/3dcube2 |
3D- ¡¨à¨â /rd/1/3d/free3d04 |
3D-Textured Cube /rd/1/3d/3dtcub10 |
3DSHeart /rd/1/3d/3dsheart |
View3DS /rd/1/3d/view3ds |
CubeLine /rd/1/3d/cubeline |
3D-ã¡ á ⥪áâãன /rd/1/3d/cubetext |
¥áâ¥àñª¨ /rd/1/3d/gears |
FlatWave /rd/1/3d/flatwav |
3D-¯¨à «ì /rd/1/3d/3dspiral |
#6 **** GRAPHICS **** |
à®á¬®âà ¨§®¡à ¦¥¨© /rd/1/media/kiv |
¥¤ ªâ®à Animage /rd/1/media/animage |
#7 **** AUDIO **** |
MidAMP /rd/1/media/midamp |
CD-¯«¥©¥à /rd/1/media/cdp |
#8 **** PROGRAMMING **** |
ਬ¥àë > /@9 |
áâà㬥âë > /@20 |
#9 **** EXAMPLES **** |
®â®ª¨ (¤¥¬®) /rd/1/develop/thread |
IPC /rd/1/develop/ipc |
Color Slider /rd/1/demos/cslide |
®á®«ìë© ¯à¨¬¥à 1 /rd/1/develop/testcon2 |
®á®«ìë© ¯à¨¬¥à 2 /rd/1/develop/test_gets |
ª á®®¡é¥¨© /rd/1/demos/use_mb |
#10 **** SYSTEM **** |
áâனª > /@11 |
¨áâ¥¬ë¥ á¥á®àë > /@12 |
¡®â á ä ©« ¬¨ > /@13 |
¥áâ¨à®¢ ¨¥ > /@19 |
¯¥æ. ¢®§¬®¦®á⨠> /@21 |
®áª ®â« ¤ª¨ /rd/1/develop/board |
#11 **** SETUP **** |
áâனá⢠/rd/1/setup |
¥¥à â®à ä® /rd/1/pic4 |
â¨«ì ®ª® /rd/1/desktop |
¥«ì § ¤ ç /rd/1/spanel |
¥¥¤¦¥à ¨ª®®ª /rd/1/icon |
VRR /rd/1/vrr |
MyKey /rd/1/mykey |
¨¤¥®à¥¦¨¬ ¤«ï ATI /rd/1/vmode |
#12 **** SENSORS **** |
¨á¯¥âç¥à ¯à®æ¥áᮢ /rd/1/cpu |
PCI-ãáâனá⢠/rd/1/pcidev |
¥áâ ᪮à®á⨠£à ä. /rd/1/mgb |
CPUID /rd/1/cpuid |
GHOST Monitor /rd/1/gmon |
K. Bus disconnected /rd/1/kbd |
HDD ¨ä®à¬¥à /rd/1/hdd_info |
⥨¥ HDD /rd/1/hdread |
#13 **** FM **** |
KFAR /rd/1/File Managers/kfar |
KFM /rd/1/File Managers/kfm |
Eolite /rd/1/File Managers/Eolite |
®á®«ì SHELL /rd/1/shell |
SysXTree /rd/1/sysxtree |
®åà ¥¨¥ ®¡à § /rd/1/rdsave |
#14 **** **** |
«ìªã«ïâ®à /rd/1/calc |
¥ªáâ®¢ë© à¥¤ ªâ®à /rd/1/tinypad |
¡«¨çë© ¯à®æ¥áá®à /rd/1/table |
®áâ஥¨¥ £à 䨪®¢ /rd/1/graph |
HEX-। ªâ®à /rd/1/demos/heed |
#15 **** NET **** |
¥à¢¥àë > /@16 |
«¨¥âë > /@17 |
®ä¨£ãà æ¨ï /rd/1/network/stackcfg |
Zero-Config /rd/1/network/zeroconf |
â âãá á¥â¨ /rd/1/network/ethstat |
â âãá ARP /rd/1/network/arpstat |
#16 **** SERVERS **** |
SMTPS /rd/1/network/smtps |
HTTPS /rd/1/network/https |
FTPS /rd/1/network/ftps |
#17 **** CLIENTS **** |
TFTP-ª«¨¥â /rd/1/network/tftpc |
â¥à¥â-è å¬ âë /rd/1/network/chess |
à®á⮩ HTTP-ª«¨¥â /rd/1/network/httpc |
à®á¬®âà HTML+HTTP /rd/1/htmlv |
NNTP-£àã¯¯ë ®¢®á⥩ /rd/1/network/nntpc |
TELNET /rd/1/network/telnet |
POP-¯®çâ /rd/1/network/popc |
IRC-ª«¨¥â /rd/1/network/airc |
YAHOO IM (¤¥¬®) /rd/1/network/ym |
JMail /rd/1/network/jmail |
VNC-ª«¨¥â /rd/1/network/vncclient |
DNS resolver /rd/1/network/nslookup |
#18 **** OTHER **** |
«®£®¢ë¥ ç áë /rd/1/demos/aclock |
¨ àë¥ ç áë /rd/1/demos/bcdclk |
©¬¥à /rd/1/demos/timer |
®§¤ ¨¥ áªà¨è®â®¢ /rd/1/scrshoot |
«¥¤ àì /rd/1/calendar |
BGI-èà¨äâë (¤¥¬®) /rd/1/fonts/bgitest |
à®á¬®âà RTF /rd/1/rtfread |
¡«¨æ ¥¤¥«¥¥¢ /rd/1/period |
¨¯¥âª /rd/1/pipetka |
ॠ¦ñà KJ|ABuIIIA /rd/1/games/klavisha |
#19 **** SYSTEM TESTS **** |
¥áâ § é¨âë /rd/1/test |
¥áâ ¬®¨â®à /rd/1/disptest |
#20 **** DEVELOP TOOLS **** |
¯ ª®¢é¨ª KPack /rd/1/kpack |
Flat Assembler /rd/1/develop/fasm |
ASCII-ª®¤ë /rd/1/develop/keyascii |
SCAN-ª®¤ë /rd/1/develop/scancode |
Hex2Dec2Bin /rd/1/develop/h2d2b |
®áª ®â« ¤ª¨ /rd/1/develop/board |
â« ¤ç¨ª /rd/1/develop/mtdbg |
#21 **** SYSTEM SPECIAL **** |
ªà ï «ã¯ /rd/1/magnify |
ªà ï ª« ¢¨ âãà /rd/1/zkey |
¡«¨æ ᨬ¢®«®¢ /rd/1/ASCIIVju |
## |
/data/rus/mykey |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/rus/network/jmail |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/rus/network/zeroconf.ini |
---|
0,0 → 1,19 |
[ipconfig] |
; type should be static or zeroconf |
; zeroconf means the service first tries to contact a DHCP server |
; If dhcp is not available, it switches to link-local |
type = zeroconf |
ip = 10.0.2.15 |
gateway = 10.0.2.2 |
dns = 10.0.2.2 |
subnet = 255.255.255.0 |
[proxy] |
; If Internet connection requires HTTP proxy, set it here |
; and uncomment following lines: |
;proxy = <set your proxy IP-addr or domain name here> |
;port = <set your proxy port here> |
; If proxy requires authentification, uncomment following lines too |
; (otherwise, leave them commented): |
;user = <set username here> |
;password= <set password here> |
/data/rus/panel.dat |
---|
0,0 → 1,0 |
0000;0000;0001;0001;0001;0001;0100;0001;0001;0001;0001;0001;x |
/data/rus/pipetka |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/rus/setup.dat |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/rus/shell |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/rus/spanel |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/rus/table |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/rus/test |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/data/rus/vmode |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |