Subversion Repositories Kolibri OS

Compare Revisions

No changes between revisions

Regard whitespace Rev 1736 → Rev 1737

/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
ƒŽˆ–€ ”€€Ž€
 
‘¬ëá« ¨£àë á®á⮨⠢ ⮬, ç⮡ë, ¯¥à¥¬¥é ï ¨¥à®£«¨äë ­  ¢å®¤¥ ¢ ®ç¥à¥¤­ãî
ª®¬­ â㠣஡­¨æë ä à ®­  (8•8), ®âªàëâì ¯à®å®¤. ‚ë ¬®¦¥â¥ ¬¥­ïâì ¬¥áâ ¬¨ ¤¢ 
¨¥à®£«¨ä  à á¯®«®¦¥­­ëå à冷¬ ¯® ¢¥à⨪ «¨ ¨«¨ £®à¨§®­â «¨ ¢ á«ãç ¥, ¥á«¨ ¯à¨
â ª®© ¯¥à¥áâ ­®¢ª¥ ®¡à §ã¥âáï ª®¬¡¨­ æ¨ï ¨§ âà¥å ¨«¨ ¡®«¥¥ ®¤¨­ ª®¢ëå ª à⨭®ª
¢ àï¤. ’ ª¨¥ àï¤ë âãâ ¦¥ ¨á祧 îâ,   ᢮¡®¤­®¥ ¬¥áâ® § ¯®«­ï¥âáï ¨¥à®£«¨ä ¬¨
"®á믠¢è¨¬¨áï" ᢥàåã. ¥¤®áâ î騥 ¨¥à®£«¨äë £¥­¥à¨àãîâáï á«ãç ©­ë¬ ®¡à §®¬.
‡  ¨á祧 î騥 ¨¥à®£«¨äë ­ ç¨á«ïîâáï ®çª¨. ‡  ª®¬¡¨­ æ¨î ¨§ ¨¥à®£«¨ä®¢ ¤ îâáï
®çª¨ ¯® ä®à¬ã«¥ 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