.COM tretij fajl
.COM 22	oktqbrq	1989
.CPT sistemy programmirowaniq
.LIN
|tot razdel sprawo~nika	sodervit informaci` po qzykowym	processoram 
(translqtoram), whodq}im w RT11, i
kratkie	opisaniq operatorow i komand qzykow programmirowaniq:
.SWT
	- makroassembler;
	- fortran sm;
	- bejsik;
	- paskalx.
.LIN
krome |togo dano opisanie standartnyh funkcij i	podprogramm bibliotek,
a takve	svatoe
opisanie nekotoryh grupp soob}enij,
kotorye	da`tsq qzykowymi
processorami pri obnaruvenii o{ibok w programmah.
.LIN
dlq obleg~eniq otladki programm
daetsq kratkoe opisanie	komand otlad~ikow dlq qzykow
programmirowaniq makroassembler, fortran sm i paskalx. wse opisywaemye
otlad~aki pozwolq`t rabotatx w terminah	sootwetstwu`}ego qzyka
programmirowaniq.
.HLV 1
qzyk programmirowaniq makroassembler
.LIN
translqtor s qzyka makroassembler movet	wyzywatxsq komandami
monitora COMPILE, EXECUTE, MACRO,
R i imeet (w poslednem slu~ae) sledu`}ij format
komandnoj stroki:
.SWT
	.R MACRO
	*PROG.OBJ,PROG.LST,PROG.CRF=INP1.MAC,INP2.MAC...
.BLN
gde:
.DFN PROG.OBJ
fajl ob'ektnogo	modulq programmy;
.DFN PROG.LST
fajl listinga translqcii ishodnogo teksta;
.DFN PROG.CRF
fajl, w	kotoryj	wywoditsq tablica perekrestnyh ssylok w
programme;
.DFN INP1.MAC,INP2.MAC i t.d.
fajly ishodnogo	teksta programmy.
.HLV 2
kl`~i kompilqtora
.LIN
kompilqtor s qzyka makroassembler imeet	sledu`}ie
kl`~i uprawleniq listingom:
.DFN /L
wywoditx polnyj	listing	programmy;
.DFN /N
osu}estwlqtx tolxko raspe~atku strok programmy,	soderva}ih o{ibki;
.DFN /L:ARG
razre{aet wypolnenie raspe~atki	~asti listinga,	opredelqemoj argumentom;
argumenty ime`t	te ve zna~eniq,	~to i dlq kl`~a	/N;
.DFN /N:ARG
zapre}aet wypolnenie raspe~atki	~asti listinga,	opredelqemoj argumentom;
dopustimymi argumentami	dlq kl`~ej /L i	/N qwlq`tsq:
.DF2 BEX
w listing wywodqtsq dwoi~nye kody, wme}a`}iesq w odnu
stroku translqcii;
.DF2 BIN
generiruemyj dwoi~nyj kod;
.DF2 CND
ne transliruemye po uslowi` ~asti teksta programmy i wse
direktiwy uslownoj translqcii;
.DF2 COM
kommentarii w tekste programmy;
.DF2 LD
derektiwy uprawleniq raspe~atkoj (.LIST/.NLIST)	bez argumentow;
.DF2 LOC
zna~enie s~et~ika q~eek	(adresow q~eek,	w kotorye zapisywaetsq generiruemyj
translqtorom kod);
.DF2 MC
wyzowy makrokomand i ras{ireniq	blokow powtorenij;
.DF2 MD
makroopredeleniq i teksty blokow powtorenij;
.DF2 ME
teksty makroras{irenij i ras{irenij blokow powtorenij;
.DF2 MEB
dwoi~nyj kod, generiruemyj w rezulxtate	makroras{irenij;
.DF2 SEQ
nomera operatorow programmy (strok teksta whodnogo fajla);
.DF2 SRC
tekst operatorow;
.DF2 SYM
tablica	simwolow, opredelennyh w programme, i ih zna~enij,
a takve	imena programmnyh sekcij;
.DF2 TOC
oglawlenie (swodka tekstow iz direktiw .SBTTL);
.DF2 TTM
formatirowanie listinga	dlq wywoda na terminal operatora.
.DFN /M
fajl, za specifikaciej kotorogo	w komandnoj stroke CSI sleduet |tot kl`~,
qwlqetsq makrobibliotekoj;
.DFN /P:N
fajl, za specifikaciej kotorogo	w komandnoj stroke CSI sleduet |tot kl`~,
dolven translirowatxsq tolxko
na perwom (N=1)	ili wtorom (N=2) prohode;
.DFN /D:ARG
zapretitx wypolnenie translqtorom funkcij po generacii koda, opisywaemyh
argumentom; argumenty ime`t te ve zna~eniq, ~to	i dlq kl`~a /E;
.DFN /E:ARG
razre{itx wypolnenie translqtorom funkcii po generacii koda, opisywaemyh
argumentom;
dopustimymi argumentami	kl`~ej /D i /E qwlq`tsq:
.DF2 ABS
translqciq w absol`tnyj	dwoi~nyj format;
.DF2 AMA
translirowatx wse otnositelxnye	adresa kak absol`tnye;
zamenqet revimy	adresacii 67 na	37; ispolxzuetsq w celqh otladki;
.DF2 CDR
ignorirowatx informaci`, soderva}u`sq w	stroke,	na~inaq	s 73-j kolonki;
.DF2 FPT
use~enie ~isel s plawa`}ej zapqtoj, wmesto ih okrugleniq, pri nehwatke
razrqdnosti dlq	to~noj zapisi zna~eniq;
.DF2 LC
ne preobrazowywatx pri translqcii znaki	kirillicy w latinskie;
.DF2 LSB
na~alo (.ENABL)	i konec	(.DSABL) bloka lokalxnyh simwolow; kl`~	wypolnqet
tu ve funkci`, ~to i stoq}aq w na~ale transliruemogo teksta sootwetstwu`}aq
emu direktiwa;
.DF2 PNC
wywod generiruemogo dwoi~nogo koda w fajl rezulxtata translqcii;
.DF2 REG
s~itatx	zaranee	zadanym	standartnoe opredelenie	simwolow registrow
(R0=%0,	... R5=%5, SP=%6, PC=%7);
.DFN /C[:ARG]
generirowatx i raspe~atywatx tablicu perekrestnyh ssylok w programme;
ukazanie kl`~a bez argumenta
|kwiwalentno /C:S:M:E; argumentom movet	bytx:
.DF2 C
imena i	mesta ispolxzowaniq (to~ki na~ala i prodolveniq) programmnyh sekcij;
.DF2 E
tipy i mesta poqwleniq o{ibok;
.DF2 M
imena, to~ki opredeleniq i ispolxzowaniq makrokomand;
.DF2 P
imena i	to~ki ispolxzowaniq postoqnnyh (wkl`~ennyh w postoqnnye	tablicy
simwolow translqtora) simwolow w programme;
.DF2 R
imena i	mesta ispolxzowaniq simwolow registrow;
.DF2 S
imena, to~ki opredeleniq i ispolxzowaniq simwolow, opredelennyh	w programme.
.HLV 2
direktiwy
.LIN
qzyk makroassembler imeet sledu`}ie direktiwy:
.DFN ' (apostrof)
wmeste so sledu`}im za nim simwolom generiruet slowo,
soderva}ee w mlad{em bajte kod dannogo simwola;
star{ij	bajt obnulqetsq;
.AND 0
qwlqetsq indikatorom konkatenacii pri podstanowke
argumenta makrokomandy;
.DFN " (kawy~ki)
wmeste so sledu`}imi za	nimi dwumq simwolami generiru`t
slowo, soderva}ee w mlad{em bajte kod perwogo simwola,
a w star{em bajte - wtorogo;
.DFN ^w
wremennoe uprawlenie osnowaniem	sistemy	s~isleniq; sledu`}ee za	nim ~islo
traktuetsq kak dwoi~noe;
.DFN ^s
operaciq perioda translqcii; sledu`}ee za
nim wyravenie wy~islqetsq i dlq	polu~ennogo slowa
stroitsq porazrqdnoe dopolnenie	do edinicy;
.DFN ^D
wremennoe uprawlenie osnowaniem	sistemy	s~isleniq; sledu`}ee za	nim ~islo
traktuetsq kak desqti~noe;
.DFN ^F
ukazywaet, ~to sledu`}ee za nim	~islo dolvno traktowatxsq
kak {estnadcatirazrqdnoe s plawa`}ej zapqtoj;
.DFN ^o
wremennoe uprawlenie osnowaniem	sistemy	s~isleniq; sledu`}ee za	nim ~islo
traktuetsq kak wosxmeri~noe;
.DFN ^R
preobrazuet sledu`}ie tri simwola w sootwetstwu`}ij kod
RaD50;
.DFN .ASCII /STRING/
generiruet blok	dannyh,	soderva}ij kody	koi-7
simwolow stroki, iskl`~aq ograni~iteli,	po odnomu
simwolu	w bajte;
.DFN .ASCIZ /STRING/
generiruet blok	dannyh,	soderva}ij kody	koi-7
simwolow stroki	(iskl`~aq ograni~iteli), po odnomu
simwolu	w bajte; sgenerirowannyj blok zawer{aetsq
dopolnitelxnym bajtom, soderva}im zna~enie nolx;
.DFN .ASECT
na~inaet absol`tnu` programmnu`	sekci`;
.DFN .BLKB EHPR
rezerwiruet blok posledowatelxnyh q~eek	pamqti dlq razme}eniq dannyh, dlina
kotorogo w bajtah opredelqetsq zna~eniem wyraveniq ehrR;
.DFN .BLKW EHPR
rezerwiruet blok posledowatelxnyh q~eek	pamqti dlq razme}eniq dannyh, dlina
kotorogo w slowah opredelqetsq zna~eniem wyraveniq ehrR;
.DFN .BYTE EHPR1,...
generiruet posledowatelxnostx bajtow dannyh; bajty
sodervat zna~eniq, opredelennye	sootwetstwu`}im
wyraveniem;
.DFN .CSECT [NAME]
na~inaet imenowannu` (Name) ili	neimenowannu` (pri
otsutstwii argumenta) pereme}aemu` programmnu` sekci`;
.DFN .DSABL ARG
zapre}aet wypolnenie funkcii translqtora, ukazannoj
argumentom ARG w direktiwe .ENABL;
.DFN .ENABL ARG
trebuet	wypolneniq funkcii translqtora,	ukazannoj argumentom ARG.
.LIN
funkcii	translqtora, wypolnqemye po umol~ani`, pome~eny	znakom
(*). ob'qsneniq	priwodqtsq dlq direktiwy .eNawL.
esli w komandnoj stroke	ispolxzowany kl`~i /D, /E,
to direktiwy .ENABL i .DSABL s takimi ve argumentami, ~to i u kl`~ej,
w tekste programmy ignoriru`tsq.
.LIN
argumenty direktiw .ENABL/.DSABL:
.DF2 ABS
absol`tnyj dwoi~nyj wywod rezulxtata translqcii;
.DF2 AMA
translqciq wseh	otnositelxnyh adresacij	(revim 67) kak
absol`tnyh (revim 37);
.DF2 CDR
rassmatriwatx pozicii s	nomerom	73 i wy{e whodnoj stroki programmy
kak kommentarii;
.DF2 CRF (*)
generirowatx tablicy perekrestnyh
ssylok,	esli w komandnoj stroke	ukazan kl`~ /C;
.DF2 FPT
razre{aet use~enie ~isel s plawa`}ej zapqtoj pri
preobrazowanii w dwoi~nu` formu; w protiwnom slu~ae
pri nedostatke razrqdnosti dlq to~noj zapisi zna~eniq
proizwoditsq ego okruglenie;
.DF2 LC
razre{aet wywod	znakow kirillicy w raspe~atku listinga
programmy; w protiwnom slu~ae proizwoditsq
preobrazowanie w latinskij alfawit;
.DF2 LSB
opredelqet na~alo bloka	lokalxnyh simwolow; direktiwa
 .DSABL	LSB movet zawer{itx blok lokalxnyh simwolow;
.DF2 rNs (*)
razre{aet wywod	rezulxtata translqcii (sgenerirowannogo	koda) w	ob'ektnyj
fajl;
.DF2 REG (*)
razre{aet ispolxzowatx sogla{eniq po umol~ani` o
naimenowanii registrow;
.DF2 GBL
razre{aet s~itatx wse ispolxzuemye, no neopredelennye
w programme simwoly, globalxnymi.
.DFN .END [EXPR]
opredelqet logi~eskij konec ishodnoj programmy;
argument ehrR opredelqet startowyj adres programmy;
po umol~ani` startowym adresom qwlqetsq	1;
.DFN .ENDC
opredelqet konec teksta	bloka uslownoj translqcii;
.DFN .ENDM [NAME]
opredelqet konec teksta	teku}ego bloka powtorenij, bloka
neopredelennyh powtorenij ili makroopredeleniq;	esli
imq Name ukazano, to ono dolvno	sowpadatx s imenem,
zadannym w sootwetstwu`}ej direktiwe .masRo;
.DFN .ENDR
opredelqet konec teku}ego bloka	powtorenij;
.DFN .EOT
ignoriruetsq; indikator	logi~eskogo konca perfolenty; fizi~eskij konec
perfolenty awtomati~eski
opredelqetsq apparaturoj;
ostawleno w tablicah translqtora dlq sowmestimosti s assemblerami
rannih wersij;
.DFN .ERROR EXRR ; TEXT
direktiwa diagnostiki o{ibok;
porovdaet soob}enie ob o{ibke s	kodom P;
oby~no ispolxzuetsq w makrokomandah;
.DFN .EVEN
ignoriruetsq, esli teku}ij s~et~ik q~eek translqtora
~etnyj;	esli s~et~ik ne~etnyj -	k ego sodervimomu
dobawlqetsq edinica;
.DFN .FLT2 ARG1,...
generiruet posledowatelxnostx q~eek, soderva}u`
~isla w	formate	s plawa`}ej zapqtoj (dwa slowa na ~islo), zadannye
argumentami ARG;
.DFN .FLT4 ARG1,...
generiruet posledowatelxnostx q~eek, soderva}u`
~isla w	formate	s plawa`}ej zapqtoj (~etyre slowa na ~islo - dwojnaq
to~nostx), zadannye
argumentami ARG;
.DFN .GLOBL SYM1,...
opredelqet pere~islennye simwoly SYm kak globalxnye;
.DFN .IDENT /STRING/
ispolxzuetsq dlq zadaniq nomera	wersii w ob'ektnom module
programmy; argument STRING mevdu
razdelitelqmi opredelqet tekst-identifikator w kode RaD50;
.DFN .IF COND,ARG
na~inaet tekst bloka uslownoj translqcii, kotoryj wkl`~aetsq w
translqci` ishodnogo teksta programmy, tolxko esli
uslowie	COND wypolneno dlq dannogo argumenta ARG;
uslowiq	direktiwy .IF:
.DF2 EQ
wyravenie ARG rawno nul`;
.DF2 NE
wyravenie ARG ne rawno nul`;
.DF2 GT
wyravenie ARG bolx{e nulq;
.DF2 LE
wyravenie ARG menx{e ili rawno nul`;
.DF2 LT
wyravenie ARG menx{e nulq;
.DF2 GE
wyravenie ARG bolx{e ili rawno nul`;
.DF2 DF
simwol ARG opredelen;
.DF2 NDF
simwol ARG ne opredelen;
.DF2 B
w makrokomande ne zadan	argument ARG;
.DF2 NB
w makrokomande zadan argument ARG;
.DF2 IDN
w makrokomande argumenty ARG1 i	ARG2 identi~ny;
.DF2 DIF
w makrokomande argumenty ARG1 i	ARG2 razli~ny;
.DF2 Z
wyravenie ARG rawno nul`;
.DF2 NZ
wyravenie ARG ne rawno nul`;
.DF2 G
wyravenie ARG bolx{e nulq;
.DF2 L
wyravenie ARG menx{e nulq.
.DFN .IFF
ispolxzuetsq tolxko wnutri bloka uslownoj translqcii;
ukazywaet na na~alo sekcii koda, transliruemogo	pri
lovnosti zadannogo w na~alxnoj direktiwe .IF uslowiq;
.DFN .IFT
ispolxzuetsq tolxko wnutri bloka uslownoj translqcii;
ukazywaet na na~alo sekcii koda, transliruemogo	pri
istinnosti zadannogo w na~alxnoj direktiwe .IF uslowiq;
.DFN .IFTF
ispolxzuetsq tolxko wnutri bloka uslownoj translqcii;
ukazywaet na na~alo sekcii koda, transliruemogo
nezawisimo ot istinnosti ili lovnosti zadannogo	uslowiq;
.DFN .IIF COND,ARG STATEMENT
dejstwuet kak odnostro~nyj blok	uslownoj translqcii;
operator StatemeNt transliruetsq tolxko	pri istinnosti
uslowiq	COND dlq zadannogo argumenta ARG;
dopustimyj nabor uslowij COND sowpadaet	s naborom direktiwy .IF;
.DFN .IRP SYM,<ARG1,...>
ob'qwlqet na~alo bloka neopredelennyh powtorenij;
zadannyj simwol	SYM w tele bloka zame}aetsq |lementom
spiska,	sootwetstwu`}ego dannomu powtoreni`; koli~estwo
powtorenij opredelqetsq	dlinoj spiska; spisok pome}aetsq
w uglowye skobki; |lementy spiska razdelq`tsq odnim iz dopustimyh
razdelitelej;
.DFN .IRPC SYM,<STRING>
ob'qwlqet na~alo bloka neopredelennyh powtorenij;
zadannyj simwol	SYm w tele bloka zame}aetsq o~erednym znakom
stroki STRING, sootwetstwu`}im dannomu powtoreni`;
koli~estwo powtorenij opredelqetsq dlinoj stroki; stroka
STRING zadaetsq	w uglowyh skobkah;
.DFN .LIMIT
rezerwiruet dwa	slowa, w kotorye komponow}ik (LINK) zanosit
mlad{ij	i star{ij adresa pamqti, zanimaemoj skomponowannoj programmoj;
.DFN .LIST [ARG]
bez argumenta uweli~iwaet na 1 zna~enie	flaga-s~et~ika
raspe~atki, s argumentom - na flag ne wliqet, no wkl`~aet
w listing raspe~atku, opredelqemu` ARG;
.LIN
funkcii	translqtora, wypolnqemye po umol~ani`, pome~eny	znakom
(*). ob'qsneniq	priwodqtsq dlq direktiwy .LIST.
esli w komandnoj stroke	ispolxzowany kl`~i /L, /N,
to direktiwy .LIST i .NLIST s takimi ve	argumentami, ~to i u kl`~ej,
w tekste programmy ignoriru`tsq.
.LIN
argumenty direktiw .LIST/.NLIST:
.DF2 SEQ (*)
raspe~atywatx w	listinge posledowatelxnye nomera strok operatorow ishodnoj
programmy;
.DF2 LOC (*)
raspe~atywatx w	listinge teku}ie zna~eniq s~et~ika q~eek
perioda	translqcii;
.DF2 BIN (*)
raspe~atywatx generiruemyj dwoi~nyj kod	w listinge
programmy;
.DF2 BEX (*)
raspe~atywatx dwoi~noe ras{irenie generiruemogo	koda
bolee ~em na odnoj stroke (esli	nedostato~no odnoj
stroki); podmnovestwo BIN;
.DF2 SRC (*)
raspe~atywatx ishodnyj tekst programmy;
.DF2 COM (*)
raspe~atywatx kommentarii; podmnovestwo	SRC;
.DF2 MD	 (*)
raspe~atywatx makroopredeleniq;
.DF2 MC	 (*)
raspe~atywatx makrowyzowy;
.DF2 ME
raspe~atywatx makroras{ireniq;
.DF2 MEB
raspe~atywatx generiruemyj pri makroras{irenii dwoi~nyj
kod; podmnovestwo me;
.DF2 CND (*)
raspe~atywatx ne transliruemye po uslowi` ~asti	teksta blokow uslownoj
translqcii i sootwetstwu`}ie im	direktiwy .IF i	.ENDC;
.DF2 LD
raspe~atywatx wse direktiwy .LIST/.NLIST bez argumentow;
.DF2 TOC (*)
raspe~atywatx oglawlenie pered na~alom listinga
programmy;
.DF2 SYM  (*)
raspe~atywatx nakoplennu` translqtorom tablicu simwolow;
.DF2 TTM
formirowatx raspe~atku listinga	dlq terminala operatora;
w protiwnom slu~ae ispolxzuetsq	"{irokij" format acpu;
.DFN .MACRO NAME,ARG1,...
ob'qwlqet na~alo teksta	makroopredeleniq s ukazannym
imenem NAME i formalxnymi parametrami ARG w pozicionnom	ili kl`~ewom formate;
parametr w kl`~ewom formate imeet wid ARG=VALUE, gde VALUE - zna~enie
po umol~ani`, ispolxzuemoe translqtorom, esli sootwetstwu`}ij argument
pri wyzowe makrokomandy	NAME ne	ukazan;
.DFN .MCALL ARG1,...
ukazywaet simwoli~eskie	imena aRG polxzowatelxskih
ili sistemnyh makrokomand, neobhodimyh pri translqcii,
no ne opredelqemyh w tekste programmy;
opredeleniq ukazannyh makrokomand ~ita`tsq sootwetstwenno iz polxzowatelxskih
ili sistemnoj makrobibliotek;
.DFN .MEXIT
priwodit k wyhodu iz teku}ego makroras{ireniq, bloka powtoreniq	ili
bloka neopredelennyh powtorenij;
.DFN .NARG SYM
ispolxzuetsq tolxko w makrokomandah; priswaiwaet simwolu
SYm zna~enie, rawnoe ~islu argumentow w	wyzowe teku}ej ras{irqemoj
makrokomandy;
.DFN .NCHR SYM,<STRING>
priswaiwaet simwolu SYM	zna~enie, rawnoe dline stroki
"STRING" w znakah;
.DFN .NLISt [ARG]
bez argumenta umenx{aet	na 1 zna~enie flaga-s~et~ika
raspe~atki (pri	flage-s~et~ike menx{em nulq listing ne wywoditsq),
s argumentom - na zna~enie flaga ne wliqet, no iskl`~aet
iz listinga raspe~atku,	opredelqemu` argumentom	ARG.
.ATT
esli w komandnoj stroke	ispolxzowany kl`~i /L ili /N bez argumentow,
to wse direktiwy .LIST i .NLIST	bez argumentow,	su}estwu`}ie w tekste
programmy, ignoriru`tsq.
.DFN .NTYPE SYM,AEXP
ispolxzuetsq tolxko w makrokomandah; prirawniwaet zna~enie simwola
SYM {estirazrqdnomu revimu adresacii adresnogo wyraveniq AEXP;
wozmovnye w qzyke makroassembler revimy	adresacii pere~isleny nive (w uglowyh
skobkah	ukazany	kody revimow):
.DF2 R		  <0N>
registr	N sodervit operand;
.DF2 @R	ili (ER)  <1N>
registr	N sodervit adres operanda;
.DF2 (ER)+	  <2N>
sodervimoe registra uweli~iwaetsq na 2 (dlq slownoj instrukcii
i pri operacii na steke) ili
na 1 (dlq bajtnoj) posle ispolxzowaniq
ego kak	adresa operanda;
.DF2 @(ER)+	  <3N>
registr	N sodervit ukazatelx adresa operanda; posle
ispolxzowaniq sodervimoe adresa	uweli~iwaetsq na 2;
.DF2 -(ER)	  <4N>
sodervimoe registra N umenx{aetsq na 2 (dlq slownoj instrukcii
i pri operacii na steke) ili
na 1 (dlq bajtnoj) pered ispolxzowaniem
ego kak	adresa operanda;
.DF2 @-(ER)	  <5N>
registr	N posle	umenx{eniq zna~eniq sodervimogo	na 2
ispolxzuetsq kak ukazatelx adresa operanda;
.DF2 e(ER)	  <6N>
zna~enie wyraveniq e pl`s sodervimoe registra N	ispolxzuetsq
kak adres operanda;
.DF2 @e(ER)	  <7N>
zna~enie wyraveniq e pl`s sodervimoe registra N	ispolxzuetsq
kak ukazatelx adresa operanda;
.DF2 #E		  <27>
zna~enie wyraveniq e qwlqetsq operandom;
.DF2 @#E	  <37>
zna~enie wyraveniq e qwlqetsq adresom operanda;
.DF2 E		  <67>
adres operanda zadaetsq	sme}eniem ot teku}ej instrukcii	do q~ejki,
soderva}ej operand, i sledu`}ej	za instrukciej;
.DF2 @E		  <77>
ukazatelx adresa operanda zadaetsq sme}eniem ot	teku}ej	instrukcii
do q~ejki, soderva}ej |tot adres;
sme}enie zapisywaetsq w	q~ejku,	sledu`}u` za instrukciej;
.DFN .ODD
delaet zna~enie	s~et~ika instrukcij
wo wremq translqcii ne~etnym;
.DFN .rAGE
perewodit na nowu` stranicu
raspe~atki listinga i uweli~iwaet na 1 s~et~ik stranic;
.DFN .PRINT EXPR ; TEXT
wywodit	w listing diagnosti~eskoe soob}enie TEXT i zna~enie wyraveniq
EXPR, opredelqemye programmistom;
soob}enie ob o{ibke ne generiruetsq;
oby~no ispolxzuetsq w makrokomandah ili	pri uslownoj translqcii
kak sredstwo kontrolq;
.DFN .PSECT NAME,ATR1,...
na~inaet ili prodolvaet	imenowannu` ili	neimenowannu` programmnu`
sekci`,	ime`}u`	ukazannye atributy ATR;
atributy direktiwy .PSECT:
.ATT
alxternatiwnye warianty	atributow razdelq`tsq drobnoj ~ertoj. perwym
ukazywaetsq atribut, ispolxzuemyj po umol~ani`.	atributy opisywa`tsq w
porqdke	ih zadaniq w direktiwe.
.DF2 NAME
opredelqet imq programmnoj sekcii (w kode RAD50); po umol~ani`
sozdaetsq neimenowannaq	programmnaq sekciq;
.DF2 RW/RO
opredelqet razre{ennyj wid dostupa w q~ejki programmnoj	sekcii:	RW - dlq
~teniq i zapisi; RO - tolxko dlq ~teniq;
.DF2 I/D
programmnaq sekciq sodervit instrukcii ili dannye;
.DF2 LCL/GBL
ispolxzuetsq pri postroenii perekrytij;	dlq lokalxnyh
sekcij pamqtx wydelqetsq w oblastqh teh	modulej, w
kotoryh	sekciq opredelqetsq; dlq globalxnyh - w	oblasti
pErekrytiq, blivaj{ego k kornewomu segmentu,
iz kotorogo wyzywa`tsq perekrytiq, soderva}ie |tu sekci`;
.DF2 REL/ABS
opredelqet pereme}aemu`	(REL) ili
absol`tnu` (ABS) programmnu` sekci`;
.DF2 CON/OVR
pri perekrywa`}ihsq (OVR) programmnyh sekciqh nastrojka
odnoimennyh sekcij iz raznyh ob'ektnyh modulej
wedetsq	s odnogo adresa	operatiwnoj pamqti, i kone~nyj
ob'em sekcii ustanawliwaetsq rawnym maksimalxnomu iz su}estwu`}ih
w |tih modulqh;
neperekrywa`}iesq sekcii (CON) komponu`tsq posledowatelxno odna	za
drugoj,	i kone~nyj ob}ij ob'em sekcii rawen summe ob'emow odnoimennyh
sekcij,	ob'qwlennyh w raznyh ob'ektnyh modulqh.
.DFN .RADIX N
izmenqet osnowanie teku}ej sistemy s~isleniq na	N (N = 2,8,10);
.DFN .RAD50 /STRING/
generiruet blok	dannyh iz slow,	soderva}ih |kwiwalent stroki
StRING w kode RAD50, iskl`~aq ograni~iteli;
.DFN .REPT EXPR
na~inaet tekst bloka powtorenij; ~islo powtorenij opredelqetsq
zna~eniem wyraveniq EXPR;
.DFN .SwTTL STRING
priwodit k raspe~atke ukazannoj	stroki STRING kak
~asti zagolowka	stranicy (podzagolowok); stroki,
opredelqemye |toj direktiwoj, raspe~atywa`tsq takve w
na~ale listinga	w ego oglawlenii;
.DFN .TITLe STRING
opredelqet perwye {estx	simwolow stroki	(dopustimye w
kode RaD50) kak	imq ob'ektnogo modulq; StRING takve
raspe~atywaetsq	kak ~astx zagolowka w perwoj stroke kavdoj stranicy
listinga;
.DFN .WORD EXPR,...
generiruet posledowatelxnye slowa; kavdoe slowo
sodervit zna~enie sootwetstwu`}ego wyraveniq ehrR;
po umol~ani` zna~enie wyraveniq	rawno nul`;
.DFN .	(to~ka)
simwolxnoe obozna~enie teku}ego	zna~eniq s~et~ika
q~eek perioda translqcii; dopuskaet operaci` priswoeniq	zna~eniq
i ispolxzuetsq w wyraveniqh, kak imq s~et~ika q~eek;
.AND 0
opredelqet pred{estwu`}ij nabor	cifr kak celoe desqti~noe ~islo.
.HLV 2
diagnostika translqcii
.DFN A
o{ibka translqcii; wozmovny sledu`}ie kategorii	|toj
o{ibki:
.AN2 0
neprawilxnaq specifikaciq argumenta;
.AN2 0
otsutstwie argumenta;
.AN2 0
neprawilxnaq konstrukciq argumenta;
.AN2 0
ob}aq o{ibka adresacii;
.AN2 0
neprawilxnaq ssylka wpered;
.DFN B
o{ibka ~etnosti; instrukciq ili	slowo transliruetsq po
ne~etnomu adresu;
.DFN D
ssylka na mnogokratno opredelennu` metku;
.DFN E
otsutstwuet direktiwa .eND;
.DFN I
obnaruven zapre}ennyj znak, kotoryj ignoriruetsq;
nepe~atnyj znak	zamenqetsq w listinge znakom woprosa (?);
.DFN L
whodnaq	stroka dlinoj bolee 132	(desqti~noe) znakow; o{ibka takogo roda
woznikaet tolxko w makroras{ireniqh;
.DFN M
mnogokratnoe opredelenie metki;
.DFN N
zapisx ~isla sodervit cifru, nedopustimu` w teku}ej
sisteme	s~isleniq;
.DFN O
o{ibka koda operacii; nedopustimaq direktiwa;
popytka	obra}eniq k makrokomande, ne najdennoj
po direktiwe .msaLL i dr.;
.DFN P
o{ibka fazy translqcii;	adres metki razli~en na	perwom i na wtorom
prohodah translqcii; generiruetsq takve	direktiwoj .eRRoR;
.DFN Q
sintaksi~eskaq o{ibka; o{ibkA zadaniq argumentow ili sli{kom
bolx{oe	~islo argumentow;
.DFN R
o{ibka ispolxzowaniq ili ukazaniq registra; neprawilxnaq ssylka	na registr
ili popytka pereopredelitx mnemoniku bez predwaritelxnogo zadaniq
direktiwy .DSABL REG;
.DFN T
o{ibka use~eniq; generiruemoe ~islo sli{kom weliko dlq
zadannoj razrqdnosti; star{ie razrqdy useka`tsq	(otbrasywa`tsq);
.DFN U
w stroke ispolxzowan neopredelennyj simwol; |tot simwol	pri translqcii
porovdaet zna~enie nolx;
.DFN Z
wozmovnaq o{ibka instrukcii; takim flagom pome~aetsq instrukciq, kotoraq
movet po-raznomu wypolnqtxsq na	processorah raznyh tipow.
.HLV 2
otlad~iki programm na assemblere (ODT, TODT, VDT, TSODT)
.LIN
otlad~iki pozwolq`t osu}estwitx: prosmotr sodervimogo l`boj q~ejki pamqti i
wnesenie neobhodimyh izmenenij;	wypolnenie wsej	(ili ~asti) programmy;
ostanowku raboty w zadannyh to~kah s pereda~ej uprawleniq otlad~iku; poisk
slow po	maske sodervimogo; wy~islenie otnositelxnyh adresow i t.d.
.LIN
otlad~ik ODT prednazna~en dlq raboty w RT11SJ i RT11FB (w RT11XM 
movet ispolxzowatxsq dlq otladki
priwilegirowannyh zadanij). VDT	prednazna~en dlq raboty	w RT11FB(XM)
(dlq nepriwilegirowannyh zadanij i pri nali~ii mnogoterminalxnoj poddervkki)
i po funkciqm sowpadaet	s ODT. TODT dopolnqet funkcii ODT sredstwami
trassirowki wypolnqemyh	processorom komand na terminal ili na ustrojstwo
pe~ati.	w raspe~atku whodit mnemonika wypolnqemoj instrukcii
processora, sodervimoe operandow i slowa sostoqniq processora do i posle
wypolneniq |toj	instrukcii.
.LIN
pri opisanii komand prinqty sledu`}ie sogla{eniq:
.AND
termin "otkrytx	q~ejku"	ozna~aet raspe~atatx sodervimoe	q~ejki w wosxmeri~nom
wide (krome komand "X" i "A") i	razre{itx ego izmenenie; izmenenie
proizwoditsq wwodom nowogo zna~eniq, za	kotorym	sleduet	komanda	zakrytiq
q~ejki ili perehoda k drugoj q~ejke; esli nowoe	zna~enie ne wwoditsq, to
izmenenie ne proishodit;
.AND
"adres"	ispolxzuetsq dlq ukazaniq q~ejki i zadaetsq w wide wosxmeri~nogo ~isla
ili w forme "N,KR", gde	N - sme}enie ot	adresa,	zapisannogo w registre
sme}enij s nomerom k; wmesto ~isla movet ispolxzowatxsq	litera "C",
ukazywa`}aq sodervimoe registra	konstant otlad~ika.
.LIN
otlad~iki dlq programm na assemblere ime`t sledu`}ij nabor komand:
.DFN <CR>
zakrytx	teku}u`	otkrytu` q~ejku	i podgotowitxsq	k priemu sledu`}ej komandy;
.DFN <LF>
zakrytx	teku}u`	otkrytu` q~ejku	i otkrytx q~ejku so sledu`}im adresom;
.DFN ^
otkrytx	predydu}u` q~ejku;
.DFN _ (znak pod~erkiwaniq)
interpretirowatx sodervimoe otkrytoj q~ejki kak	otnositelxnyj adres
dlq revimow adresacii 66 ili 77	i otkrytx q~ejku po wy~islennomu adresu;
.DFN >
ispolxzowatx sodervimoe	otkrytoj q~ejki, kak komandu uslownogo perehoda,
i otkrytx q~ejku, na kotoru` ukazywaet |ta komanda;
.DFN <
wernutxsq k posledowatelxnosti q~eek, prerwannoj po komandam @,	> ili _,
i otkrytx sledu`}u` q~ejku |toj	posledowatelxnosti;
.DFN @
ispolxzowatx sodervimoe	otkrytoj q~ejki	kak absol`tnyj adres i otkrytx
q~ejku po |tomu	adresu;	adres teku}ej q~ejki zapominaetsq dlq ispolxzowaniq
w komande "<";
.DFN adres/
otkrytx	slowo s	ukazannym adresom; adres dolven	bytx ~etnym;
.DFN /
powtorno otkrytx posledn`` otkrytu` q~ejku (slowo);
.DFN adres\
otkrytx	bajt po	ukazannomu adresu;
.DFN \
powtorno otkrytx posledn`` otkrytu` q~ejku kak bajt;
.DFN !
raspe~atatx adres otkrytoj q~ejki otnositelxno registra	sme}eniq,
weli~ina sodervimogo kotorogo blivaj{aq	(sredi sodervimogo registrow sme}eniq)
snizu k	adresu |toj q~ejki;
.DFN N!
raspe~atatx adres otkrytoj q~ejki otnositelxno sodervimogo registra
sme}eniq s nomerom "N";	pri |tom "N" dolvno bytx w diapazone ot	0 do 7;
.DFN $N/
otkrytx	uniwersalxnyj registr processora s nomerom "N";
.DFN $B/
otkrytx	perwoe slowo tablicy to~ek ostanowa;
sodervimoe |togo slowa qwlqetsq	adresom	to~ki ostanowa s nomerom 0; dostup k
adresam	sledu`}ih to~ek	ostanowa proizwoditsq po komande <LF>; to~ka ostanowa
s nomerom 8 sootwetstwuet po{agowomu revimu; sledu`}ie 9 slow tablicy
sootwetstwu`t s~et~ikam	prohodow komandy "P" dlq |tih to~ek ostanowa;
.DFN $C/
otkrytx	registr	konstanty; w dalxnej{em	litera "C" movet ispolxzowatxsq	dlq
predstawleniq ~isla, zanesennogo w |tot	registr;
.DFN $F/
otkrytx	registr	formata;
.DFN $M/
otkrytx	perwyj registr maski;
dlq dostupa k sledu`}im	slowam |togo registra ispolxzuetsq komanda <LF>;
.DFN $P/
otkrytx	registr	prioriteta otlad~ika;
.DFN $R/
otkrytx	perwyj registr sme}eniq;
dlq dostupa k sledu`}im	slowam |togo registra ispolxzuetsq komanda <LF>;
.DFN $S/
otkrytx	slowo (registr)	sostoqniq processora;
.DFN $V/
otkrytx	slowo sostoqniq	zada~i JSW (tolxko dlq VDT);
.DFN adres;NA
raspe~atatx "N"	bajtow w simwolxnom wide, na~inaq s ukazannoj
q~ejki;	wwedennye zatem	"N" znakow zamenqt raspe~atannye;
.DFN ;B
 dalitx	wse to~ki ostanowa;
.DFN adres;NB
ustanowitx to~ku ostanowa nomer	"N" po ukazannomu adresu;
.DFN ;NB
udalitx	to~ku ostanowa nomer "N";
nomer to~ki ostanowa - ~islo w diapazone ot 0 do 7;
.DFN adres;C
zanesti	"adres"	w registr konstant;
.DFN adres;E
poisk instrukcij, ssyla`}ihsq na "adres";
poisk proizwoditsq ot q~ejki s adresom,	zapisannym w $M+2 (mlad{ij),
do q~ejki s adresom w $M+4 (star{ij);
.DFN ;F
zapolnitx slowa	oblasti	operatiwnoj pamqti sodervimym registra konstant;
zapolnenie proizwoditsq	ot q~ejki s adresom, zapisannym	w $M+2 (mlad{ij),
do q~ejki s adresom w $M+4 (star{ij);
.DFN adres;G
na~atx wypolnenie programmy po ukazannomu adresu;
.DFN ;I
zapolnitx bajty	oblasti	operatiwnoj pamqti sodervimym mlad{ego
bajta registra konstant;
zapolnenie proizwoditsq	ot q~ejki s adresom, zapisannym	w $M+2 (mlad{ij),
do q~ejki s adresom w $M+4 (star{ij);
.DFN adres;O
wy~islitx sme}enie ot teku}ej otkrytoj q~ejki do ukazannogo adresa;
.DFN ;P
prodolvitx wypolnenie programmy	posle to~ki ostanowa;
.DFN K;P
prodolvitx wypolnenie programmy	posle to~ki ostanowa;
ignorirowatx teku}u` to~ku ostanowa "K"	raz;
.DFN K;P
wypolnitx "K" sledu`}ih	instrukcij (tolxko dlq
pokomandnogo revima);
.DFN ;R
zanesti	wo wse registry	sme}eniq -1, t.e. perewesti ih w na~alxnoe sostoqnie;
.DFN ;NR
zanesti	w registr sme}eniq "N" zna~enie	-1,
t.e. perewesti ego w na~alxnoe sostoqnie;
.DFN adres;NR
zanesti	ukazannoe zna~enie (adres) w registr sme}eniq "N";
po umol~ani` N = 0;
.DFN R
wy~estx	sodervimoe registra sme}eniq, zna~enie kotorogo	blive wseh,
no menx{e ili rawno sodervimogo	teku}ej	q~ejki,	iz sodervimogo teku}ej
otkrytoj q~ejki	i raspe~atatx rezulxtat;
.DFN NR
wy~estx	sodervimoe registra sme}eniq s nomerom "N" iz sodervimogo teku}ego
otkrytogo slowa	i raspe~atatx rezulxtat;
.DFN ;S
otmenitx po{agowyj revim;
.DFN ;1S
wojti w	po{agowyj revim; wremenno (do wyhoda iz	|togo revima) otmenitx wse
to~ki ostanowa;
.DFN N;T
wypolnitx trassirowku sledu`}ih	"N" instrukcij processora
(tolxko	dlq TODT);
.DFN M;W
poisk slow, udowletworq`}ih maske "M";
poisk proizwoditsq ot q~ejki s adresom,	zapisannym w $M+2 (mlad{ij),
do q~ejki s adresom w $M+4 (star{ij);
.DFN X
raspe~atywaet sodervimoe teku}ej otkrytoj q~ejki w kode	RADIX-50;
posledu`}ie tri, wwedennye s terminala,	znaka mogut izmenitx
sodervimoe q~ejki.
.HLV 1
qzyk programmirowaniq fortran sm
.LIN
translqtor s qzyka fortran sozdaet ob'ektnyj kod programmy,
kotoryj	w dalxnej{em dolvna bytx obrabotan komponow}ikom (LINK)	dlq
polu~eniq zagruzo~nogo modulq programmy. translqtor
movet bytx wyzwan po komandam monitora COMPILE,	EXECUTE, FORTRAN i R i
imeet (w poslednem slu~ae) sledu`}ij format komandnoj stroki:
.SWT
	.R FORTRA
	*PROG.OBJ,PROG.LST=INP.FOR

 gde
.DFN PROG.OBJ
fajl ob'ektnogo	modulq programmy;
.DFN PROG.LST
fajl listinga translqcii;
.DFN INP.FOR
fajl ishodnogo teksta programmy.
.HLV 2
kl`~i kompilqtora
.LIN
kompilqtor s qzyka fortran imeet sledu`}ie kl`~i komandnoj stroki:
.DFN /A
wkl`~itx w listing statistiku raboty kompilqtora;
.DFN /B
wkl`~itx w listing ras{irennu` diagnostiku kompilqtora;
.DFN /D
translirowatx operatory, ime`}ie simwol	D w perwoj kolonke (pe~atnoj pozicii)
stroki (otlado~nye operatory);
.DFN /E
dlina whodnoj stroki do	80
znakow wkl`~itelxno, a ne do 72, kak w standarte; po umol~ani` ispolxzu`tsq
trebowaniq standarta;
.DFN /H
raspe~atatx na terminale spisok	kl`~ej kompilqtora (sprawo~naq informaciq);
.DFN /I:COD
wybor trebuemogo tipa koda, generiruemogo kompilqtorom;
pri |tom COD movet bytx:
.DF2 THR
modulxnyj kod; ispolxzuetsq nabor instrukcij processora	sm-3;
.DF2 EAE
linejnyj kod; w	processore predpolagaetsq nali~ie apparatury ras{iritelq
arifmetiki;
.DF2 EIS
linejnyj kod; w	processore predpolagaetsq nali~ie ras{irennogo nabora
instrukcij;
.DF2 FIS
linejnyj kod; predpolagaetsq nali~ie instrukcij	raboty s ~islami w formate s
plawa`}ej zapqtoj i ras{irennogo nabora	instrukcij (EIS);
.SWT
 /L:N
 /L:XXX
.AND 0
opredelqet sodervimoe listinga;	N = summa sledu`}ih parametrow:
.SWT
		0 - diagnostika;
		1 - tekst ishodnoj programmy;
		2 - tablica peremennyh,	massiwow;
		4 - generiruemyj kod;
.AND
wozmovno ukazanie zna~eniq kl`~a w forme XXX; pri |tom:
.SWT
		NUL - |kwiwalentno N = 0;
		SRC - |kwiwalentno N = 1;
		MAP - |kwiwalentno N = 2;
		COD - |kwiwalentno N = 4;
		ALL - |kwiwalentno N = 7;
.DFN /N:M
ukazywaet maksimalxnoe koli~estwo logi~eskih nomerow,
kotoroe	movet bytx otkryto w programme odnowremenno (M - wosxmeri~naq
konstanta w diapazone ot 1 do 17);
w |to ~islo ne whodqt logi~eskie nomera, swqzannye s terminalom;
.DFN /O
wkl`~itx w listing programmy spisok ispolxzuemyh sredstw kompilqtora;
.DFN /Q
zapre}aet raspe~atku imen transliruemyh	modulej	na sistemnom terminale
(protokol translqcii);
.DFN /R:M
opredelqet maksimalxnyj	razmer formatnoj zapisi	w bajtah,
dopustimyj w operaciqh wwoda/wywoda pri
wypolnenii programmy (M	- wosxmeri~naq konstanta w diapazone
ot 4 do	7777);
.DFN /S
podawlqet wkl`~enie kodow obrabotki nomerow operatorow w transliruemu`
programmu (|konomit pamqtx i umenx{aet wremq wypolneniq	programmy);
.DFN /T
otwodit	~etyre bajta dlq celyh peremennyh po umol~ani` (specifikaciq
INTEGER);
.DFN /U
zapre}aet swoping USR wo wremq wypolneniq programmy;
.DFN /V
zapre}aet optimizaci` raboty s mnogomernymi massiwami -	wektorizaci`
(|konomit pamqtx, no uweli~iwaet wremq wypolneniq programmy);
.DFN /W
razre{aet wkl`~enie w listing preduprevda`}ej diagnostiki kompilqtora.
.HLV 2
operatory qzyka
.LIN
pri opisanii operatorow	wwoda/wywoda spisok LIST qwlqetsq pere~isleniem
~erez zapqtu` |lementow	spiska.	|lementami spiska mogut	bytx: konstanty
(~islowye i tekstowye),	peremennye, |lementy massiwow, cikly wwoda/wywoda,
wyraveniq, imena massiwow. cikly wwoda/wywoda zapisywa`tsq w forme:
.SWT
	       (LIST, IVAR=E1, E2 [,E3])
.BLN
pri |tom LIST qwlqetsq spiskom w opredelennom wy{e smysle, a IVAR, E1, E2, E3
- peremennoj cikla, ee na~alxnym, kone~nym zna~eniem i {agom izmeneniq,
sootwetstwenno.	sogla{eniq o peremennoj	cikla i	wyraveniqh "E" sowpada`t s
prinqtymi w operatore "DO". esli w spiske ukazano imq massiwa, |to
wosprinimaetsq kak neqwnoe zadanie cikla po indeksam |lementow.
.DFN a = w
operator
arifmeti~eskogo	i logi~eskogo priswaiwaniq;
peremennoj a
priswaiwaetsq zna~enie wyraveniq w;
.DFN NAME(a1,...) = h
operator-funkciq; sozdaet funkci` s imenem NAME, opredelennu` programmistom
i ime`}u`
peremennye a w ka~estwe	formalxnyh parametrow;
.DFN ACCEPT F,LIST
wwesti dannye s	ustrojstwa s logi~eskim	nomerom	5
(po umol~ani` -	TT:); F	- metka
operatora FORMAT; LIST - wozmovnyj spisok peremennyh;
.DFN ACCEPT *,LIST
wwesti dannye s	ustrojstwa s logi~eskim	nomerom	5 (po umol~ani`	- TT:);
LIST - wozmovnyj spisok	peremennyh;
wwod, uprawlqemyj spiskom;
.DFN ASSIGN N to IVAR
swqzywaet celo~islennu`	peremennu` IVAR	s metkoj operatora N;
.DFN BACKSPACE N
wernutxsq na odnu zapisx nazad w fajle posledowatelxnogo dostupa, otkrytom w
dannyj moment na ustrojstwe s logi~eskim nomerom N;
.DFN BLOCKDATA [NAME]
opredelqet podprogrammu	bloka dannyh, ne soderva}u` wypolnqemyh	operatorow;
NAME - simwoli~eskoe imq; imq po umol~ani` - .DATA;
.DFN CALL NAME [(ARG1,...)]
wyzow podprogrammy SUBROUTINE s	ukazannym imenem NAME; peredawaemye
fakti~eskie argumenty ARG zamenqt pozicionno sootwetstwu`}ie formalxnye
parametry iz opredeleniq; pereda~a zna~enij argumentow proizwoditsq po ssylke;
zna~eniq wyravenij, ispolxzowannyh kak argumenty, wy~islq`tsq do wyzowa;
.DFN CLOSE (UNIT=N[,DISPOSE=P][,ERR=M])
razrywaet swqzx	mevdu logi~eskim nomerom N i fajlom; zakrywaet fajl;
w zawisimosti ot ukazannogo DISPOSE |tot fajl budet sohranen ili stert
(zna~eniq P - 'SAVE' i 'DELETE', sootwetstwenno; zna~enie 'KEEP' qwlqetsq
sinonimom 'SAVE');
w slu~ae o{ibki	pri wypolnenii operatora CLOSE uprawlenie peredaetsq operatoru
s metkoj M;
.DFN COMMON /NAME1/VAR,...,/NAME2/VAR2,...
rezerwiruet odin ili bolee "ob}ih" blokow pamqti w oblasti zagruzki programmy
pod ukazannymi
imenami	NAME dlq hraneniq peremennyh VAR, swqzannyh s |timi blokami;
dopustimo ukazanie neimenowannogo ob}ego bloka;
.DFN CONTINUE
"pustoj" operator; ne izmenqet sostoqniq programmy;
.DFN DATA VAR1,... /VAL1,.../
ukazywaet, ~to |lementy	spiska zna~enij	VAL dolvny
bytx zapisany pri inicializacii
w sootwetstwu`}ie |lementy spiska imen peremennyh VAR; pri |tom	w spiske
zna~enij wosxmeri~nye zna~eniq pome~a`tsq literoj "o" (ili kawy~koj ")
pered ~islom, {estnadcatiri~nye	- literoj Z pered ~islom, tekstowye konstanty
zada`tsq w apostrofah (ili w holeritowskom wide); konstanty koda RADIX-50
pome~a`tsq literoj R, za kotoroj sleduet tekst konstanty i pered kotoroj
ukazana	dlina |togo teksta;
.DFN DECODE (C,F,V[,ERR=S]) [LIST]
preobrazuet |lementy spiska peremennyh LIST iz simwolxnogo predstawleniq w
trebuemyj wnutrennij format; s estx ~islo simwolow, F
- metka	operatora FORMAT,
V ukazywaet ishodnyj tekst (stroku) dlq
preobrazowaniq;	S opredelqet metku
operatora dlq pereda~i uprawleniq w slu~ae o{ibki preobrazowaniq;
.DFN DEFINE FILE N(M,K,U,IVAR),...
opredelqet strukturu zapisej w fajle prqmogo dostupa, swqzannogo s
logi~eskim nomerom N; M	opredelqet ~islo zapisej, a K -	razmer zapisi w
slowah;	IVAR zadaet swqzannu` peremennu` fajla;
.DFN DIMENSION S1,...
rezerwiruet pamqtx dlq opredelqemyh massiwow;
.DFN Do	N IVAR=	E1,E2[,E3]
trebuet	iteratiwnogo wypolneniq	operatorow tela	cikla (ot sledu`}ego
za DO do pome~ennogo metkoj N wkl`~itelxno); peremennaq	cikla IVAR prinimaet
na kavdom {age cikla zna~eniq, opisywaemye celymi wyraveniqmi E
(na~alxnoe zna~enie, kone~noe zna~enie,	{ag izmeneniq);	operatory tela
cikla wypolnq`tsq ne menee odnogo raza;	cikl DO	|kwiwalenten sledu`}emu
algoritmu:
.DF2 {ag 1
priswaiwaet celoj peremennoj IVaR zna~enie wyraveniq e1;
.DF2 {ag 2
wypolnqet sledu`}ie operatory do operatora s metkoj N wkl`~itelxno;
.DF2 {ag 3
uweli~iwaet zna~enie peremennoj	cikla IVaR=IVaR+e3;
.DF2 {ag 4
esli E3>0 i IVAR<=E2, ili E3<0 i IVAR=>E2,
proishodit wozwrat k {agu 2;
ina~e uprawlenie peredaetsq operatoru, sledu`}emu
za operatorom s	metkoj N;
.DFN ENCODE (C,F,V[,ERR=S]) LIST
preobrazowatx |lementy spiska  peremennyh LIST w
simwolxnyj format; s - ~islo
simwolow, F - ukazanie formata preobrazowaniq,
V - oblastx razme}eniq
preobrazowannyh	dannyh;	S - metka operatora,
na kotoryj peredaetsq uprawlenie
w slu~ae wozniknoweniq o{ibok;
.DFN END
zawer{aet programmnyj modulx;
.DFN ENDFILE N
wywesti	zapisx EOF (konec fajla)
w fajl,	otkrytyj w dannoe wremq	na logi~eskom nomere N;
.DFN EQUIVALENCE (VAR1,VAR2,...),...
wydelqet odnu i	tu ve oblastx pamqti wsem peremennym VaR, nahodq}imsq w
odnom spiske, zakl`~ennom w kruglye skobki;
.DFN EXTERNAL NAME,...
informiruet sistemu, ~to imena Name qwlq`tsq imenami SUwRoUtINe	i FUNstIoN;
.DFN FIND (N'R)
pozicioniruet fajl prqmogo dostupa na logi~eskom nomere	N na zapisx R i
priswaiwaet swqzannoj peremennoj zna~enie R;
.DFN FORMAT (FIELD-SPECIFICATION,...)
opredelqet format, po kotoromu budut preobrazowywatxsq
odna ili bolee zapisej pri formatnom wwode/wywode ili w	operatorah
ENCODE/DECODE; dopustimymi qwlq`tsq sledu`}ie specifikacii polej:
.SWT
	 I - desqti~noe	celoe;
	 O - wosxmeri~noe celoe;
	 F - dejstwitelxnoe ~islo s fiksirowannoj zapqtoj;
	 E - dejstwitelxnoe ~islo s plawa`}ej zapqtoj;
	 D - dejstwitelxnoe ~islo dwojnoj to~nosti;
	 G - dejstwitelxnoe  ~islo  s  plawa`}ej  zapqtoj;
	     kombinaciq	specifikacij F i E;
	 L - logi~eskoe	zna~enie;
	 A - tekstowye dannye;
	 H - holeritowskie konstanty;
	 X - probely na	wywode,	propusk	na wwode;
	 T - pozicionirowanie wnutri zapisi;
	 Q - dlina wwodimoj zapisi  ot	teku}ej	 to~ki	do
	     konca zapisi (w bajtah);
	 $ - uprawlenie	karetkoj;
	 : - ukoro~ennyj format;
	 P - mas{tabnyj	ko|fficient.
.ATT
dlq uprawleniq karetkoj	w perwoj pozicii wywodimoj stroki razme}a`tsq
sledu`}ie znaki:
.SWT
	 probel	- perehod na sledu`}u` stroku;
	 0	- perehod na dwe stroki	wniz;
	 1	- perehod na sledu`}u` stranicu;
	 +	- pe~atx na teku}ej stroke;
	 $	- posle	wywoda ostatxsq	na teku}ej stroke;
.DFN [TYP] FUNCTION NAME[*LEN] [(VAR,...)]
na~inaet programmnyj modulx  FUNstIoN, ukazywaet imq Name funkcii i imena
 VAR fiktiwnyh parametrow; dopustimaq specifikaciq tipa	tYr movet wkl`~atx
ukazanie dliny tipa dannyh w bajtah - *LEN;
.DFN GOTO L
bezuslownyj perehod; peredaet uprawlenie operatoru s metkoj L;
.DFN GOTO (L1,...),e
wy~islqemyj perehod; peredaet  uprawlenie operatoru s metkoj L,
nomer pozicii kotoroj w	spiske rawen
zna~eni` wyraveniq e; esli e<1 ili e
bolx{e ~isla metok w spiske, uprawlenie
peredaetsq sledu`}emu za GOTO operatoru;
.DFN GOTO IVAR [,(L1,...)]
priswaiwaemyj perehod; peredaet	uprawlenie
na operator, metka kotorogo (odna iz
pere~islennyh w	spiske L) byla predwaritelxno swqzana s	peremennoj IVaR
operatorom ASSIGN;
.DFN IF	(EXPR) L1,L2,L3
arifmeti~eskij IF; peredaet uprawlenie na operatory
s metkami L w sootwetstwii
so znakom zna~eniq wyraveniq EXPR - menx{e nulq, rawno nul`, bolx{e nulq
sootwetstwenno;
.DFN IF	(EXPR) STATEMENT
logi~eskij IF; operator	StatEMENT wypolnqetsq, esli
prowerka logi~eskogo wyraveniq
ehrR dala otwet	"istina";
.DFN IMPLICIT TYPE(A1,A2,A3,...),...
|lementy a spiska predstawlq`t odnu ili	rqd bukw,
kotorye, qwlqqsx na~alxnymi
bukwami	imen peremennyh, ukazywa`t tip TYP peremennyh
po umol~ani`, esli |tim	peremennym tip ne byl zadan qwno;
otrezok	rqda zadaetsq ego granicami, mevdu kotorymi postawlen znak minus;
.DFN OPEN (r[,r]...)
swqzywaet su}estwu`}ij fajl s logi~eskim nomerom ili
sozdaet	nowyj fajl i zatem ustanawliwaet swqzx;
parametry P zada`tsq w formate kl`~ewogo slowa i mogut bytx:
.DF2 ACCESS='MODE'
metod dostupa k	dannym w fajle:	posledowatelxnyj ili proizwolxnyj;
'MODE' movet bytx: 'DIRECT' (prqmoj dostup) i 'SEQUENTIAL' (posledowatelxnyj);
.DF2 ASSOCIATIVEVARIABLE=IVAR
celo~islennaq "swqzannaq" peremennaq dlq fajla prqmogo dostupa;
.DF2 BLOCKSIZE=IEXPR
razmer zapisi pri wywode na MT:	opredelqetsq zna~eniem celogo wyraveniq	IEXPR;
.DF2 BUFFERCOUNT=IEXPR
dwojnaq	ili odinarnaq buferizaciq operacij obmena opredelqetsq
wyraveniem IEXPR;
.DF2 CARRIAGECONTROL='MODE'
metod uprawleniq karetkoj (formatirowanie wywoda) pri formatnom
posledowatelxnom wywode; pri |tom 'MODE' movet bytx 'NONE' (dlq
neformatnogo wywoda), 'FORTRAN'	(formatnyj wywod, sootwetstwie standartu)
i 'LIST' (formatnyj wywod, otmena standartnyh sogla{enij);
.DF2 DISPOSE='MODE'
operaciq 'MODE', wypolnqemaq ispolnq`}ej sistemoj fortrana pri zakrytii	|togo
logi~eskogo nomera: sohranitx fajl ('SAVE') ili	udalitx	('DELETE') ego
s nositelq (dlq	wremennyh fajlow, hranq}ih promevuto~nye dannye	programmy);
zna~enie 'KEER'	qwlqetsq sinonimom 'SAVE';
.DF2 ERR=N
gde N -	metka operatora, na kotoryj peredaetsq uprawlenie pri o{ibke
operacii otkrytiq logi~eskogo nomera (fajla);
.DF2 FORM='MODE'
formatirowanie 'MODE' pri obmene: tekstowoj ('FORMATTED') ili dwoi~nyj
('UNFORMATTED')	fajl;
.DF2 INITIALSIZE=IEXPR
razmer sozdawaemogo fajla w blokah rawen zna~eni` celogo wyraveniq IEXPR;
.DF2 MAXREC=IEXPR
maksimalxnoe ~islo zapisej w fajle (na logi~eskom ustrojstwe) pri prqmom
dostupe	rawno zna~eni` celogo wyraveniq	IEXPR;
.DF2 NAME=FILSPC
specifikaciq fajla; tekstowaq konstanta	ili massiw, soderva}ij tekstowu`
informaci`;
.DF2 NOSPANBLOCK
metod razme}eniq na wne{nem zapomina`}em ustrojstwe; zapisx
ne movet peresekatx
granicu	bloka;
.DF2 READONLY
za}ita zapisi (zapre}enie operacij zapisi - fajl otkrywaetsq
tolxko dlq ~teniq);
.DF2 RECORDSIZE=IEXPR
razmer zapisi pri prqmom dostupe; ukazywaetsq w	dwuhslownikah (t.k.
dejstwitelxnoe ~islo zanimaet dwa slowa);
.DF2 TYPE='MODE'
ukazanie wida fajla: nowyj ('NEW'), su}estwu`}ij ('OLD'), wremennyj
('SCRATCH'); ili neizwestnyj ('UNKNOWN'); w poslednem slu~ae opredelqetsq po
perwoj operacii	obmena:	zapisx - 'NEW',	a ~tenie 'OLD';
.DF2 UNIT=N
logi~eskij nomer ustrojstwa rawen N;
.DFN raUSe [DISr]
priostanawliwaet wypolnenie programmy i	pe~ataet DISr (wosxmeri~nu` ili
desqti~nu` konstantu ili  posledowatelxnostx simwolow),	esli |to ukazano
w operatore;
programma prodolvaet rabotu pri	wwode s	terminala operatorom znaka <sR>;
.DFN rRINt F [,LISt]
wywod na ustrojstwo s logi~eskim nomerom {estx (po umol~ani` Lr:); F -
metka operatora	FoRmat,	LISt - spisok wywodimyh	dannyh;
.DFN PRINT *,LIST
wywod na ustrojstwo s logi~eskim nomerom {estx (po umol~ani` LP:); LIST	-
spisok wywodimyh dannyh; pe~atx, uprawlqemaq spiskom;
.DFN rRoGRam Name
opredelqet imq ob'ektnogo modulq golownoj programmy;
.SWT
 ReaD (N,F[,eND=S1][,eRR=S2]) [LISt]
 ReaD F,LISt
.AND 0
formatnoe ~tenie; s~itatx hotq by
odnu logi~esku`	zapisx s ustrojstwa s
logi~eskim nomerom N (po umol~ani` N=1), w sootwetstwii	s ukazaniem formata
F i priswoitx zna~eniq peremennym spiska LISt;
.SWT
 ReaD (N,*[,eND=S1][,eRR=S2]) [LISt]
 ReaD *,LISt
.AND 0
s~itatx	hotq by	odnu logi~esku`	zapisx s
ustrojstwa N (po umol~ani` N=1)
i priswoitx zna~eniq peremennym	spiska LISt; ~tenie, uprawlqemoe spiskom;
.DFN ReaD (N[,eND=S1][,eRR=S2])	[LISt]
neformatnoe ~tenie; s~itatx odnu logi~esku` zapisx s ustrojstwa	N i
priswoitx zna~eniq peremennym spiska LISt;
.DFN ReaD (N'R[,eND=S1][,eRR=S2]) [LISt]
~tenie s prqmym	dostupom; pro~itatx s ustrojstwa s logi~eskim nomerom
N zapisx nomer R i
priswoitx zna~eniq peremennym spiska LISt;
.SWT
	eND=S1
	eRR=S2
	eND=S1,eRR=S2
.AN2 0
pereda~a uprawleniq po o{ibke ili po koncu fajla (EOF);	|ti specifikacii
qwlq`tsq dopustimymi |lementami	operatorow
ReaD (i	WRIte),	pozwolq`t peredawatx kontrolx po uslowi` eoF i/ili
pri wozniknowenii o{ibki; S opredelqet metku, na kotoru` peredaetsq uprawlenie
pri obnaruvenii	sootwetstwu`}ego uslowiq;
.DFN RETURN
wozwrat	uprawleniq w wyzywa`}u`	programmu iz teku}ej podprogrammy ili
funkcii;
.DFN ReWIND N
ustanawliwaet ukazatelx	fajla posledowatelxnogo	dostupa, swqzannogo s
logi~eskim
nomerom	N, na na~alo, t.e. posle wypolneniq dannogo operatora fajl budet
obrabatywatxsq,	na~inaq	s perwoj zapisi;
.DFN Stor [DISr]
prekra}aet wypolnenie programmy	i wywodit DISr
(~islo ili simwolxnaq stroka), esli |to	opredeleno, na terminal	operatora;
.DFN SUwRoUtINe	Name [(VaR,...)]
na~alo programmnogo modulq SUwRoUtINe, ukazywaet  imq podprogrammy i imena
VAR formalxnyh parametrow;
.DFN tYre F[,LISt]
wywod na ustrojstwo s logi~eskim nomerom semx (po umol~ani` tt:); F
estx metka operatora FoRmat;
LISt - spisok wywodimyh	dannyh;
.DFN TYPE *,LIST
wywod na ustrojstwo s logi~eskim nomerom semx (po umol~ani` TT:);
LIST - spisok wywodimyh	dannyh;	wywod, uprawlqemyj spiskom;
.DFN TYP VAR1[,VAR2...]
peremennym s imenami VaR, ukazannym w spiske, priswaiwaetsq zadannyj tip
TYP w dannom programmnom module;
dopustimo posle	imeni tipa ukazywatx dlinu oblasti pamqti, otwodimu` dlq
peremennyh |togo tipa, w bajtah, naprimer, INteGeR*2;
TYr movet bytx:
.DF2 ReaL, REAL*4
~isla w	formate	s plawa`}ej zapqtoj, odinarnoj to~nosti;
zanima`t 4 bajta operatiwnoj pamqti;
.DF2 INteGeR
celye ~isla; w zawisimosti ot kl`~a w komande na translqci`: INTEGER*2 ili
INTEGER*4;
.DF2 INTEGER*2
celye {estnadcatirazrqdnye ~isla; zanima`t 2 bajta operatiwnoj pamqti;
.DF2 INTEGER*4
celye {estnadcatirazrqdnye ~isla; zanima`t 4 bajta operatiwnoj pamqti; pri
|tom ispolxzuetsq tolxko dwa mlad{ih bajta zanimaemoj oblasti;
.DF2 DoUwLe rResISIoN, REAL*8
~isla w	formate	s plawa`}ej zapqtoj; dwojnaq to~nostx;
zanima`t 8 bajtow operatiwnoj pamqti;
.DF2 LoGIsaL
logi~eskie zna~eniq; pamqtx pod	peremennye |togo tipa wydelqetsq tak ve,
kak pod	peremennye tipa	INTEGER;
.DF2 LOGICAL*1,	BYTE
logi~eskie zna~eniq; zanima`t 1	bajt operatiwnoj pamqti;
mogut ispolxzowatxsq dlq hraneniq simwolxnoj informacii	(odin simwol
koda koi-7 - odin bajt);
.DF2 LOGICAL*4
logi~eskie zna~eniq; zanima`t 4	bajta operatiwnoj pamqti;
.DF2 somrLeh, COMPLEX*8
kompleksnye ~isla; zanima`t 8 bajtow operatiwnoj pamqti; hranqtsq kak dwa
raspolovennyh posledowatelxno zna~eniq tipa REAL*4;
.DFN VIRTUAL ARR,...
razmestitx wydelqemoe dlq massiwow aRR rabo~ee prostranstwo w ras{irennoj
pamqti (t.e. za	predelami mlad{ih 56 kbajt fizi~eskoj pamqti kompleksa);
.DFN WRIte (N,F[,eND=S1][,eRR=S2]) [LISt]
wywesti	odnu ili bolee logi~eskih zapisej,
soderva}ih zna~eniq peremennyh spiska
LISt, na logi~eskij nomer N w sootwetstwii s formatom, ukazannym F;
formatnyj wywod;
.DFN WRIte (N,*[,eND=S1][,eRR=S2]) [LISt]
wywod, uprawlqemyj spiskom; wywesti odnu ili bolee
logi~eskih zapisej, soderva}ih
zna~eniq peremennyh spiska LISt, na ustrojstwo s logi~eskim nomerom N;
.DFN WRIte (N[,eND=S1][,eRR=S2]) [LISt]
neformatnyj wywod; wywesti odnu	ili bolee logi~eskih zapisej, soderva}ih
zna~eniq peremennyh spiska LISt, na ustrojstwo s logi~eskim nomerom N;
.DFN WRIte (N'R[,eND=S1][,eRR=S2]) [LISt]
wywod prqmogo dostupa; wywesti odnu logi~esku` zapisx, soderva}u` zna~eniq
peremennyh spiska LISt,	w zapisx R na ustrojstwo s
logi~eskim nomerom N;
.SWT
	eND=S1
	eRR=S2
	eND=S1,eRR=S2
.AN2 0
pereda~a uprawleniq po o{ibke ili po obnaruveni` konca fajla (EOF);
dopustimye |lementy operatorow WRIte (i
ReaD), opisywa`}ie pereda~u uprawleniq w uslowiqh dostiveniq eoF ili
obnaruveniq o{ibki; S opredelqet metku,	na kotoru` peredaetsq uprawlenie
pri obnaruvenii	sootwetstwu`}ego uslowiq.
.HLV 2
bibliote~nye funkcii
.LIN
posle imeni funkcii i argumentow obra}eniq w kwadratnyh	skobkah	"[]"
ukazywaetsq tip	argumenta i tip	rezulxtata, sootwetstwenno.
.LIN
dalee predstawlena gruppa funkcij, preobrazu`}aq ~isla w razli~nye
formaty:
.DFN awS (h)	    [ReaL --> ReaL]
dejstwitelxnoe absol`tnoe zna~enie;
.DFN IawS (I)	    [INteGeR --> INteGeR]
celoe absol`tnoe zna~enie;
.DFN DawS (h)	    [DoUwLe -->	DoUwLe]
absol`tnoe zna~enie dwojnoj to~nosti;
.DFN sawS (Z)	    [somrLeh --> ReaL]
preobrazowanie
kompleksnogo ~isla w dejstwitelxnoe absol`tnoe zna~enie;
.SWT
		Z=(h,Y),
		sawS(Z)=(h**2+Y**2)**.5;
.DFN FLoat (I)	    [INteGeR --> ReaL]
preobrazowanie celogo w	dejstwitelxnoe;
.DFN IFIh (h)	    [ReaL --> INteGeR]
preobrazowanie dejstwitelxnogo w celoe;	|kwiwalentno INt(h);
.DFN SNGL (h)	    [DoUwLe -->	ReaL]
preobrazowanie dwojnoj to~nosti	w odinarnu`;
.DFN DwLe (h)	    [ReaL --> DoUwLe]
preobrazowanie dejstwitelxnogo ~isla w ~islo dwojnoj to~nosti;
.DFN ReaL (Z)	    [somrLeh --> ReaL]
preobrazowanie kompleksnogo w dejstwitelxnoe;
polu~enie dejstwitelxnoj ~asti kompleksnogo ~isla;
.DFN aImaG (Z)	    [somrLeh --> ReaL]
preobrazowanie kompleksnogo w dejstwitelxnoe; polu~enie	mnimoj ~asti;
.DFN smrLh (h,Y)    [ReaL --> somrLeh]
preobrazowanie dejstwitelxnogo w kompleksnoe;
.SWT
		smrLh(h,Y)=h+I*Y; I=(-1)**.5
.LIN
funkcii	use~eniq wozwra}a`t znak argumenta (-1,0,+1), umnovennyj na naibolx{ee
celoe, ne prewoshodq{ee	absol`tnoe zna~enie argumenta:
.DFN aINt (h)	    [ReaL --> ReaL]
use~enie dejstwitelxnogo ~isla do celogo ~isla w formate s plawa`}ej zapqtoj;
.DFN INt (h)	    [ReaL --> INteGeR]
use~enie dejstwitelxnogo do celogo;
.DFN IDINt (h)	    [DoUwLe -->	INteGeR]
use~enie ~isla dwojnoj to~nosti	do celogo.
.LIN
funkcii	ostatka	wozwra}a`t ostatok ot deleniq perwogo argumenta	na wtoroj:
.DFN amoD (h,Y)	    [ReaL --> ReaL]
dejstwitelxnyj ostatok;
.DFN moD (I,J)	    [INteGeR --> INteGeR]
celyj ostatok;
.DFN DmoD (h,Y)	    [DoUwLe -->	DoUwLe]
ostatok	dwojnoj	to~nosti.
.LIN
funkcii	maksimuma wozwra}a`t naibolx{ee	zna~enie sredi zadannyh	w spiske. pri
obra}enii dolvno zadawatxsq ne menee dwuh argumentow:
.DFN amah0 (I,J,...)	    [INteGeR --> ReaL]
~islo, maksimalxnoe w celo~islennom spiske, predstawlennoe w forme s
plawa`}ej zapqtoj;
.DFN amah1 (h,Y,...)	    [ReaL --> ReaL]
dejstwitelxnoe maksimalxnoe ~islo w spiske;
.DFN mah0 (I,J,...)	    [INteGeR --> INteGeR]
celoe maksimalxnoe ~islo w spiske;
.DFN mah1 (h,Y,...)	    [ReaL --> INteGeR]
~islo, maksimalxnoe w spiske dejstwitelxnyh ~isel, predstawlennoe w
celo~islennom formate;
.DFN Dmah1 (h,Y,...)	    [DoUwLe -->	DoUwLe]
maksimalxnoe ~islo dwojnoj to~nosti iz takogo ve spiska.
.LIN
funkcii	minimuma wozwra}a`t naimenx{ee zna~enie	sredi zadannyh w spiske; pri
obra}enii dolvno zadawatxsq ne menee dwuh argumentow:
.DFN amIN0 (I,J,...)	    [INteGeR --> ReaL]
~islo, minimalxnoe w celo~islennom spiske, predstawlennoe w forme s
plawa`}ej zapqtoj;
.DFN amIN1 (h,Y,...)	    [ReaL --> ReaL]
dejstwitelxnoe minimalxnoe ~islo w spiske;
.DFN mIN0 (I,J,...)	    [INteGeR --> INteGeR]
celoe minimalxnoe ~islo	w spiske;
.DFN mIN1 (h,Y,...)	    [ReaL --> INteGeR]
~islo, minimalxnoe w spiske dejstwitelxnyh ~isel, predstawlennoe w
celo~islennoj forme;
.DFN DmIN1 (h,Y,...)	    [DoUwLe -->	DoUwLe]
minimalxnoe ~islo dwojnoj to~nosti iz takogo ve	spiska.
.LIN
funkcii	pereda~i znaka wozwra}a`t znak wtorogo argumenta (-1,0,+1), umnovennyj
na absol`tnoe zna~enie perwogo argumenta:
.DFN SIGN (h,Y)	    [ReaL --> ReaL]
pereda~a znaka dejstwitelxnogo ~isla dejstwitelxnomu ~islu;
.DFN ISIGN (I,J)    [INteGeR --> INteGeR]
pereda~a znaka celogo ~isla celomu ~islu;
.DFN DSIGN (h,Y)    [DoUwLe -->	DoUwLe]
pereda~a znaka ~isla dwojnoj to~nosti ~islu dwojnoj to~nosti.
.LIN
funkcii	polovitelxnoj raznosti wozwra}a`t raznostx perwogo argumenta i
minimAlxnogo iz	dwuh argumentow	funkcii:
.DFN DIm (h,Y)	    [ReaL --> ReaL]
polovitelxnaq raznostx dejstwitelxnyh ~isel;
.DFN IDIm (I,J)	    [INteGeR --> INteGeR]
polovitelxnaq raznostx celyh ~isel.
.LIN
matemati~eskie funkcii:
.DFN ehr (h)	    [ReaL --> ReaL]
e w stepeni, rawnoj dejstwitelxnomu ~islu;
e - osnowanie naturalxnogo logarifma;
.DFN Dehr (h)	    [DoUwLe -->	DoUwLe]
e w stepeni, rawnoj ~islu dwojnoj to~nosti;
e - osnowanie naturalxnogo logarifma;
.DFN sehr (h)	    [somrLeh --> sOmrLeh]
e w stepeni, rawnoj kompleksnomu ~islu;
e - osnowanie naturalxnogo logarifma;
.DFN aLoG (h)	    [ReaL --> ReaL]
naturalxnyj logarifm (po osnowani` e)
dejstwitelxnogo	~isla;
.DFN aLoG10 (h)	    [ReaL --> ReaL]
desqti~nyj logarifm (po	osnowani` 10.) dejstwitelxnogo ~isla;
.DFN DLoG (h)	    [DoUwLe -->	DoUwLe]
naturalxnyj logarifm  ~isla dwojnoj to~nosti;
.DFN DLoG10 (h)	    [DoUwLe -->	DoUwLe]
desqti~nyj logarifm  ~isla dwojnoj to~nosti;
.DFN sLoG (Z)	    [somrLeh --> somrLeh]
naturalxnyj logarifm kompleksnogo ~isla;
.DFN SQRt (h)	    [ReaL --> ReaL]
kwadratnyj korenx dejstwitelxnogo ~isla;
.DFN DSQRt (h)	    [DoUwLe -->	DoUwLe]
kwadratnyj korenx  ~isla dwojnoj to~nosti;
.DFN sSQRt (Z)	    [somrLeh --> somrLeh]
kwadratnyj korenx  kompleksnogo	~isla;
.DFN SIN (h)	    [ReaL --> ReaL]
dejstwitelxnyj sinus;
.DFN DSIN (h)	    [DoUwLe -->	DoUwLe]
sinus dwojnoj to~nosti;
.DFN sSIN (Z)	    [somrLeh --> somrLeh]
kompleksnyj sinus;
.DFN soS (h)	    [ReaL --> ReaL]
kosinus	dejstwitelxnogo	~isla;
.DFN DsoS (h)	    [DoUwLe -->	DoUwLe]
kosinus	dwojnoj	to~nosti;
.DFN ssoS (Z)	    [somrLeh --> somrLeh]
kompleksnyj kosinus;
.DFN taNn (h)	    [ReaL --> ReaL]
giperboli~eskij	tangens;
.DFN ataN (h)	    [ReaL --> ReaL]
arktangens dejstwitelxnogo ~isla;
.DFN DataN (h)	    [DoUwLe -->	DoUwLe]
arktangens dwojnoj to~nosti;
.DFN ataN2 (h,Y)    [ReaL --> ReaL]
arktangens ~astnogo h i	Y;
.DFN DataN2 (h,Y)   [DoUwLe -->	DoUwLe]
arktangens dwojnoj to~nosti ~astnogo h/Y;
.DFN soNJG (Z)	    [somrLeh --> somrLeh]
polu~enie kompleksno-soprqvennogo; esli	Z=h+I*Y, to:
.SWT
		soNJG(Z) = h-I*Y;  I*I=-1;
.DFN RaN (I,J)	    [INteGeR --> ReaL]
wozwra}aet psewdoslu~ajnoe dejstwitelxnoe ~islo, ime`}ee rawnomernoe
raspredelenie na otrezke ot 0. do 1.; I	i J dolvny bytx	celymi peremennymi i
perwona~alxno dolvny bytx ustanowleny w
0; wosstanowlenie I i J	w 0 priwedet k powtoreni` posledowatelxnosti
slu~ajnyh ~isel; razli~nye na~alxnye zna~eniq dlq I
i J budut porovdatx
razli~nye posledowatelxnosti slu~ajnyh ~isel.
.HLV 2
sistemnye podprogrammy
.LIN
pere~islqemye podprogrammy whodqt w sostaw ispolnq`}ej sistemy fortrana.
oni qwlq`tsq operacionno zawisimymi i mogut otsutstwowatx w realizaciqh
qzyka fortran, predostawlqemyh drugimi os.
.DFN saLL aSSIGN (LUN,Name,IsNt,moDe,soNtRoL,NUmwUF)
pozwolqet swqzywatx informaci` ob ustrojstwe i/ili imeni fajla (parametr NAME)
s logi~eskim nomerom LUN; pri |tom ICNT	ukazywaet w bajtah dlinu specifikacii
NAME, MODE - metod otkrytiq fajla
('NEW' - nowyj,	'OLD' -	staryj,	'SCR' -	wremennyj, 'RDO' - tolxko dlq
~teniq); parametr CONTROL opredelqet uprawlenie	karetkoj ('CC' - estx, 'NC' -
net), a	zna~enie NUMBUF	- dwojnu` (2) ili odinarnu` (1)	buferizaci`
wwoda/wywoda;
esli ICNT menx{e nulq, to zna~enie NAME	budet wwedeno s
terminala operatora;
.DFN saLL sLoSe	(LUN)
zakrywaet fajl,	otkrytyj w |tot	moment na logi~eskom nomere
LUN, i oswobovdaet
logi~eskij nomer dlq posledu`}ego ispolxzowaniq	s drugim fajlom;
.DFN saLL Date (aRRaY)
wozwra}aet teku}u` datu	w simwolxnom wide w 9-|lementnom bajtowom massiwe;
.DFN saLL eRRtSt (IeRR,IReS)
.AND 0
pozwolqet programme polxzowatelq opredelqtx nali~ie o{ibok,
obnaruvennyh ispolnq`}ej
sistemoj fortran wo wremq raboty programmy;
pri |tom IERR ukazywaet	prowerqemu` o{ibku ee nomerom,
  IRES - nali~ie o{ibki;
.DFN saLL eRRSNS (IReS,IUNIt)
pozwolqet programme polxzowatelq polu~atx informaci` o poslednej o{ibke
wwoda/wywoda, proizo{ed{ej pri rabote programmy; wozwra}aemoe w	IRES zna~enie
opredelqet kod o{ibki, a zna~enie IUNIT	- logi~eskij nomer, pri	rabote s
kotorym	|ta o{ibka proizo{la;
.DFN saLL ehIt
|kwiwalentno operatoru Stor bez	pe~ati soob}enij; pereda~a uprawleniq
monitoru mikro os pri zawer{enii programmy;
.DFN saLL IDate	(moN,IDaY,IYeaR)
wozwra}aet tri celyh ~isla, opredelq`}ih teku}ij mesqc
moN, denx IDaY i god IYeaR;
.DFN saLL RANDU	(I1,I2,h)
podprogramma, wyzywa`}aq dat~ik	slu~ajnyh ~isel;
|kwiwalentna operatoru:
.SWT
		X = RAN	(I1,I2)
.DFN saLL SeteRR (NUm,NsoUNt)
pozwolqet programmistu zadatx dejstwie dlq ispolnq`}ej sistemy
fortran, esli wo wremq wypolneniq programmy proizo{la o{ibka;
NCOUNT opredelqet dejstwie ispolnq`}ej sistemy fortran na
o{ibku tipa, zadannogo NUM;
.DFN saLL USeReh (Name)
opredelqet pereda~u uprawleniq na podprogrammu s ukazannym imenem Name,	kak
~astx raboty programmy zawer{eniq ispolnq`}ej sistemy.
.HLV 2
logi~eskie nomera ustrojstw
.LIN
na kavdom logi~eskom nomere imenem fajla po umol~ani` qwlqetsq FtNk.Dat
(k - logi~eskij	nomer ustrojstwa). sootwetstwie	po umol~ani`
nomerow	logi~eskih ustrojstw dlq
fortrana i fizi~eskih ustrojstw	kompleksa pokazano w tabl. 2.
.TAB 0,3
       -------------------------
	nomer !	  ustrojstwo
       -------------------------
	  1   !	  SY:
	  2   !	  Dk:
	  3   !	  Dk:
	  4   !	  Dk:
	  5   !	  tt: (wwod)
	  6   !	  Lr: (wywod)
	  7   !	  tt: (wywod)
	  8   !	  rs: (wwod)
	  9   !	  rs: (wywod)
.BLN
dlq ostalxnyh logi~eskih nomerow ustrojstwom po	umol~ani` qwlqetsq DK:.
.HLV 2
diagnostika o{ibok pri translqcii
.LIN
soob}eniq o pere~islennyh nive o{ibkah kompilqtor wywodit w listing programmy.
na
stroke,	sledu`}ej za operatorom, soderva}im o{ibku, pe~ataetsq "*****",	zatem
sleduet	kod o{ibki:
.DFN w
pozicii	1-5 stroki prodolveniq ne pusty; znaki,	stoq}ie	w |tih poziciqh
ignoriru`tsq, kompilqciq prodolvaetsq;
.DFN s
neprawilxnoe prodolvenie operatora; stroka prodolveniq
ignoriruetsq, kompilqciq
prodolvaetsq;
.DFN e
nedostaet operatora eND; operator eND predpolagaetsq;
.DFN n
holeritowskaq stroka ili stroka	w apostrofah sli{kom dlinna; operator
ignoriruetsq;
.DFN I
ispolxzuetsq simwol, ne	prinadleva}ij alfawitu qzyka; simwol ignoriruetsq,
kompilqciq prodolvaetsq;
.DFN k
neprawilxnoe opredelenie metki operatora; nekorrektnaq metka operatora
ignoriruetsq, translqciq prodolvaetsq;
.DFN L
stroka sli{kom dlinna; stroka usekaetsq	do 80 simwolow i kompilqciq
prodolvaetsq;
.DFN m
powtornoe opredelenie metki; nowoe opredelenie metki ignoriruetsq;
.DFN r
operator sodervit nesbalansirowannye skobki; operator ignoriruetsq;
.DFN S
sintaksi~eskaq o{ibka; operator	ignoriruetsq;
.DFN U
operator ne dopustim w qzyke; operator ignoriruetsq.
.LIN
krome |togo, pri nali~ii o{ibok, w listinge programmy sozdaetsq
specialxnyj razdel diagnosti~eskih soob}enij, kotoryj dlq kavdoj o{ibki
sodervit ee opisanie i nomer operatora,	w kotorom |ta o{ibka obnaruvena.
.HLV 2
otlad~ik programm na fortrane FDT
.LIN
otlad~ik programm na fortrane predostawlqet programmistu sredstwa
prosmotra i izmeneniq sodervimogo w modulqh programmy, razme}enie to~ek
ostanowa (pauz)	pered zadannymi	wypolnqemymi operatorami i na to~kah whoda
w procedury i funkcii, sleveniq	za izmeneniem zna~eniq wybrannoj peremennoj.
|ti dejstwiq wypolnq`tsq po komandam otlad~ika w terminah, blizkih k whodnomu
qzyku translqtora.
.LIN
otlaviwaemaq programma dolvna bytx ottranslirowana bez podawleniq
wnutrennih nomerow operatorow (ISN) w kod THR i	skomponowana s otlad~ikom.
.LIN
pri dostupe k peremennym teku}ego modulq sme}eniq ukazywa`tsq w	sootwetstwii
s kartoj raspredeleniq pamqti, sozdannoj translqtorom. iz togo ve listinga
berutsq	nomera operatorow pri razme}enii to~ek ostanowa.
.LIN
tip dannyh w zadannoj q~ejke LOC opredelqetsq revimom adresacii, kotoryj
ukazywaetsq ~erez drobnu` ~ertu: q~ejka/revim.
.LIN
CpiCOK KOMAHd otlad~ika:
.DFN ACCEPT LOC=VALUE
priswaiwaet nowoe zna~enie "VALUE" peremennoj, kotoraq zadana q~ejkoj "LOC";
.DFN ACCEPT 'TEXT'
wywodit	tekst "TEXT" na	terminal; dlq "TEXT" ispolxzu`tsq wse sogla{eniq
o tekstowyh konstantah fortrana;
.DFN ACCEPT LOC
wywodit	znak "?", ovidaet zna~enie s terminala i priswaiwaet ego "LOC";
dopustima tolxko w  makrokomandah;
.DFN CONTINUE [N]
pPOdOlviTx BypOlHEHiE fortranowskoj programmy
do sledu`}ej to~ki pauzy, teku}u` pauzu	propustitx
"N" raz; po umol~ani` N	= 1;
.DFN DIMENSION NAME(I,J,...),LOC
swqzywaet specifikaci` q~ejki dannyh "LOC" s imenem "NAME" i spiskom
razmernostej "(I,J,...)";
.DFN DIMENSION NAME
stiraet	imq "NAME" iz tablic FDT;
.DFN ERASE NAM,...
CTiraet	imena "NAM" iz tablicy FDT;
.DFN GOTO LABEL
peredaet uprawlenie na komandu otlad~ika s cifrowoj metkoj
"LABEL"	w makrokomande;	dopustima tolxko w makrokomandah;
.DFN IF	LOC<REL>VALUE;FDT-COMMAND
wypolnqet komandu otlad~ika "FDT-COMMAND" w slu~ae, esli dlq ukazannyh
q~ejki "LOC" i zna~eniq	"VALUE"	 zadannoe otno{enie "<REL>" qwlqetsq
istinnym; w protiwnom slu~ae "FDT-COMMAND" propuskaetsq	i wypolnqetsq
sledu`}aq za nej komanda;
.DFN MACRO m
wypolnqet makrokomandu "M";
.TES 3
.DFN MACRO M(...)
COzdaet	ili pereopredelqet makrokomandu	"M";
.DFN MACRO m()
stiraet	makrokomandu "M";
.DFN NAME NAME,LOC
CBqzywaet q~EjKu dannyh	"LOC" C	iMEHEM "NAME"; w dalxnej{em dopustima
ssylka na |to imq w l`boj to~ke	programmy;
.DFN NAME NAM
stiraet	imq "NAM" iz tablic FDT;
.DFN PAUSE PPPPPP [AFTER N][ MACRO M]
ustanawliwaet whodnu` pauzu na proceduru "PPPPPP";
ustanowlennaq pauza propuskaetsq "N" raz;
pri obrabotke pauzy wypolnqetsq	makrokomanda "M";
po umol~ani` M=0, N=1;
.DFN PAUSE PPPPPP,X [ AFTER N][	MACRO M]
ustanawliwaet operatornu` pAuzu	FDT HA OpEPATOPE "X" pPOcEduPy "PPPPPP";
ustanowlennu` pauzu propustitx N raz;
pri obrabotke pauzy wypolnitx makrokomandu "m";
po umol~ani` M=0 i N=1;
.DFN RESET PPPPPP,X
CTiraet	zapisx o pauze iz tablic FDT;
.DFN START
HA~inaet BypOlHEHiE s gOlOBHOgO	MOdulq programmy;
.DFN STEP [N]
pPOdOlvaet wypolnenie programmy	w po{agowom revime;
BypOlHiTx N OpEPATOPOB;	po umol~ani` N = 1;
.DFN STOP
BOzBPA}aeT uprawlenie OpEPAciOHHoj CiCTEMe;
.DFN TYPE LOC
pe~ataet zHA~EHiE ukazannoj q~ejki HA TEPMiHAle
w zadannom formate;
.DFN TYPE 'TEXT'
raspe~atywaet ukazannyj	"TEXT" na terminale;
.DFN WATCH LOC
opredelqet storovewu` peremennu`; pri izmenenii	zna~eniq, nahodq}egosq w
q~ejke "LOC", wypolnqetsq storovewaq pauza otlad~ika;
.DFN WHAT
raspe~atywaet na terminale operatora dannye o teku}em COCTOqHii
OTlAd~iKA - aktiwnye pauzy i opredelennye makrokomandy.
.LIN 2
kody revimow adresacii LOC priwedeny w tabl. 3.
.TAB 0,3
 ----------------------------------------------------------
 PEviM!	 Tip	!  OpiCAHiE
 ----------------------------------------------------------
   I  !INTEGER*2! 16 biTow B dECqTi~HOj	fOPMate
   J  !INTEGER*4! 32 biTA, pEPByE 16 B dECqTi~HOm fOPMate
   L  !LOGICAL*4! 32 biTA, ByBOdqTCq KAK T ili F
   M  !LOGICAL*1!  8 biTOB, ByBOdqTCq KAK T ili	F
   E  !REAL*4	! 32 biTA, |KCpOHEHciAlxHAq fOPMA
   D  !REAL*8	! 64 biTA, |KCpOHEHciAlxHAq fOPMA
   C  !COMPLEX	! 64 biTA, dEjCTBiTElxHAq i MHiMAq ~ACTi
   B  !BYTE	!  8 bitow, wywoditsq w	desqti~nom formate
   R  !	 ----	! 16 biTOB, ByBOdiTCq KAK TPi zHAKA RAD50
   O  !	 ----	! 16 biTOB, ByBOdiTCq B	BOCxMePi~HOm
      !		! formate
   AN !	 ----	! N zHAKOB CiMBOlxHOgO KOdA (1<=N<=255)
   Z  !	 ----	! CiMBOlxHAq CTPOKA (iCpOlxzuETCq, kak B
      !		! podprogrammah	PAbOTy CO CTPOKAMi)
.LIN
l`bOmu kodu PEviMa, pPEdCTABlEHHomu By{e, MOvET	pred{estwowatx buKBa "P"
dlq uKAzAHiq, ~TO opredelqemaq q~EjKA pPEdCTABlqET pAPAMETPi~ECKu`
pEPEMEHHu` fOPTPAHA.
.LIN
 formaty adresacii  LOC:
.SWT
 XXX		sme}enie q~ejki	w wosxmeri~nyh bajtah
 NAME		imenowannaq q~ejka
 NAME+XXX	otnositelxnaq adresaciq
 NAME(I,J,...)	indeksirowannoe	imq
.LIN
fiksirowannye imena:
.SWT
 .MAIN.	  bazowyj adres	golownogo  modulq  programmy
	  na fortrane (esli golownomu modul` ne	bylo
	  priswoeno imq	operatorom PROGRAM)
 .BCOM.	  bazowyj adres	neimenowannogo bloka  COMMON
 .ABS.	  absol`tnyj nulewoj adres
.HLV
qzyk programmirowaniq bejsik
.LIN
interpretator qzyka bejsik wyzywaetsq komandoj monitora	BASIC
ili R. w ka~estwe signala gotownosti k priemu komandy
operatora interpretator	wywodit	na terminal stroku iz odnogo slowa - READY.
pered wywodom signala gotownosti interpretatora	zadaetsq wopros	o
trebuemyh ras{ireniqh sredstw standartnoj biblioteki:
.SWT
	OPTIONAL FUNCTIONS (ALL, NONE OR INDIVIDUAL):
.LIN
warianty otwetow:
.DFN A
trebuet	prisutstwiq wseh ras{irenij.
.DFN N
otkaz ot ras{irenij.
.DFN I
na terminale budut pere~isleny
imena funkcij
i, esli	funkciq	s ukazannym imenem nuvna, dlq wkl`~eniq	ee w zagruvaemu` ~astx
biblioteki neobhodimo wwesti Y.
.LIN
w processe |togo dialoga movno wybratx
neobhodimoe podmnovestwo arifmeti~eskih, strokowyh i sistemnyh funkcij.
.LIN
nive opisywa`tsq operatory qzyka bejsik, komandy operatora,
ispolxzuemye pri rabote	s interpretatorom
bejsik,	i uprawlq`}ie
simwoly. dano takve opisanie arifmeti~eskih
funkcij, funkcij raboty	so stro~nymi
dannymi	i sistemnyh funkcij.
.HLV 2
operatory qzyka
.DFN saLL ["]NAME["] [(ARGUMENTS)]
wyzywaet podprogrammu NAME, napisannu` na qzyke	assembler,
i peredaet ej ukazannye	argumenty;
.DFN snaIN FILSPC [LINe	EXPR]
prekra}aet wypolnenie programmy, zagruvaet programmu, ukazannu`	FILSPC,	i
na~inaet ee wypolnenie s operatora s naimenx{im	nomerom	ili
nomerom, zadannym wyraveniem EXPR; pered wypolneniem CHAIN wse otkrytye	fajly
zakrywa`tsq, peremennye	i massiwy (krome pere~islennyh w operatore COMMON)
stira`tsq;
.DFN sLoSe [[#]EXPR1,[#]EXPR2,...]
zakrywaet fajly, swqzannye s kanalami i	wirtualxnymi massiwami,	~xi nomera
byli ukazany wyraveniqmi EXPR; esli ne ukazan ni odin nomer kanala,
budut zakryty wse fajly, otkrytye w nastoq}ij moment;
.DFN sommoN VAR[(EXPR1[,EXPR2])][,...]
sohranqet zna~eniq i imena pere~islennyh w spiske peremennyh
i massiwow pri wypolnenii operatora snaIN;
.DFN DATA LIST
ispolxzuetsq sowmestno s operatorom
READ dlq wwoda pere~islennyh w spiske LIST zna~enij
dannyh w wypolnqemu` programmu;	operator pome}aetsq w konce programmy;
.DFN DeF FN<LITERA>[<SIGN>] (LIST) = EXPR
opredelqet funkci`, zadannu` wyraveniem	EXPR, ot ukazannogo nepustogo spiska
LIST (do pqti
|lementow) formalxnyh parametrow; wozmovno opredelenie do 26 (po ~islu bukw
<LITERA> latinskogo alfawita) funkcij; <SIGN> movet bytx % ili $, opredelqq,
qwlqetsq dannaq	funkciq	celo~islennoj ili strokowoj, sootwetstwenno;
pri osutstwii <SIGN> funkciq s~itaetsq dejstwitelxnoj;
.DFN DIm VAR(EXPR1[,EXPR2])[,...]
rezerwiruet pamqtx pod massiwy w sootwetstwii so specifikaciqmi, zadawaemymi
imenami	peremennyh VAR i wyraveniqmi EXPR, opredelq`}imi razmernosti;
.DFN DIm #INT1,VAR(INT2[,INT3])[=INT4]
opredelqet wirtualxnyj massiw VAR razmernosti (INT2[,INT3]), swqzannyj
s kanalom, nomer kotorogo ukazywaet INT1;
INT4 ukazywaet dlinu strok dlq stro~nogo wirtualxnogo massiwa;
.DFN END
operator razme}aetsq w logi~eskom konce	programmy; zawer{aet ee
wypolnenie;
.DFN FoR VAR=EXPR1 to EXPR2 [Ster EXPR3]
wypolnqet cikl ukazannoe ~islo raz; peremennoj cikla qwlqetsq VAR, kotoraq
posledowatelxno	izmenqet swoe zna~enie ot weli~iny EXPR1 do EXPR2 s {agom
EXPR3 (po umol~ani` EXPR3 = 1);	w telo cikla whodqt wse	operatory, sledu`}ie
za dannym FOR do operatora "NEXT VAR" wkl`~itelxno;
.DFN GoSUw LINENUM
pereda~a uprawleniq na ukazannu` LINENUM stroku	podprogrammy; wozwrat
uprawleniq
osu}estwlqetsq po operatoru RETURN na operator,	sledu`}ij za dannym GOSUB;
.DFN Goto LINENUM
pereda~a uprawleniq na ukazannu` LINENUM stroku;
.SWT
 IF RELEXPR tneN STATEMENT
 IF RELEXPR tneN LINENUM
 IF RELEXPR Goto LINENUM
.AND 0
uslownoe wypolnenie ukazannogo operatora ili pereda~a uprawleniq na zadannu`
stroku;	uslowiem qwlqetsq istinnostx logi~eskogo wyraveniq RELEXPR;
.SWT
 IF END	[#]EXPR	THEN STATEMENT
 IF END	[#]EXPR	THEN LINENUM
 IF END	[#]EXPR	GOTO LINENUM
.AND 0
dlq whodnogo fajla posledowatelxnogo dostupa, swqzannogo s kanalom, nomer
kotorogo ukazan	wyraveniem EXPR, prowerqetsq uslowie dostiveniq	konca
fajla; pri wypolnenii |togo uslowiq wypolnqetsq	ukazannyj operator ili
peredaetsq uprawlenie na ukazannu` LINENUM stroku programmy;
.DFN INPUT [#EXPR,]VAR1[,VAR2...]
wwesti dannye s	terminala ili iz fajla posledowatelxnogo dostupa, swqzannogo s
kanalom, ukazannym wyraveniem EXPR i pomestitx ih w peremennye VAR;
.DFN KILL FILSPC
steretx	fajl, specifikaciq kotorogo opredelena dannoj strokoj FILSPC;
.DFN [LET] VAR=EXPR
priswoitx zna~enie wyraveniq EXPR ukazannoj peremennoj VAR;
.DFN LINPUT [#EXPR,] LIST
wwesti strokowye dannye	s terminala ili	iz fajla, swqzannogo s kanalom,	nomer
kotorogo zadan wyraveniem EXPR,	w strokowye peremennye spiska LIST;
.DFN NAME FILSPC1 TO FILSPC2
fajlu s	imenem,	ukazannym FILSPC1, zamenitx imq	na ukazannoe FILSPC2;
specifikacii ustrojstw w starom	i nowom	imeni dolvny sowpadatx;
.DFN NEXT VAR
razme}aetsq w konce cikla FoR i	wozwra}aet uprawlenie na operator,
neposredstwenno	sledu`}ij za operatorom	FoR;
.DFN ON	EXPR GoSUw LINENUM[,...]
uslownaq pereda~a uprawleniq w podprogrammu na odnu iz strok,
ukazannyh w spiske; zna~enie wyraveniq EXPR opredelqet nomer |lementa
spiska LINENUM,	wybiraemogo pri	wypolnenii operatora;
wozwrat	uprawleniq proishodit po operatoru RETURN na operator, neposredstwenno
sledu`}ij za dannym;
.SWT
 oN EXPR GOTO LINENUM[,...]
 oN EXPR THEN LINENUM[,...]
.AND 0
uslownaq pereda~a uprawleniq na	odnu iz	strok, ukazannyh w spiske;
zna~enie wyraveniq EXPR, opredelqet nomer |lementa
spiska LINENUM,	wybiraemogo pri	wypolnenii operatora;
.SWT
 OPEN FILSPC [FOR INPUT] AS FILE [#]EXPR1 [DOUwLE wUF] -
     [,ResoRDSIZe EXPR2] [,MODE	EXPR3]
 OPEN FILSPC FOR OUTPUT	AS FILe	[#]EXPR1 [DOUwLE BUF] -
     [,RECORDSIZE EXPR2] [,MODE	EXPR3] [,FILESIZE EXPR4]
.AND 0
otkrytx	zadannyj FILSPC	fajl dlq wwoda (FOR INPUT) ili wywoda (FOR
OUTPUT)	 i swqzatx |tot	fajl s zadannym	wyraveniem EXPR1 nomerom kanala;
po umol~ani` fajl otkrywaetsq dlq wwoda;
parametr DOUBLE	BUF opredelqet dwojnu` buferizaci` wwoda/wywoda;
wyravenie EXPR2	- razmer zapisi	pri prqmom dostupe;
wyravenie EXPR4	- razmer wyhodnogo fajla;
.DFN OVERLAY FILSPC [LINE EXPR]
dopolnitx programmu, nahodq}u`sq w pamqti w teku}ij moment,
operatorami iz fajla, ukazannogo strokoj FILSPC; kogda perekrytie zagruzitsq,
peredatx
uprawlenie na stroku so	sledu`}im posledowatelxnym nomerom
(otnositelxno nomera
teku}ej	stroki programmy) ili na stroku	s nomerom, zadannym wyraveniem EXPR;
.DFN PRINT [#EXPR,][LIST]
wywesti	informaci`, ukazannu` w	spiske LIST, na	terminal
ili w fajl, swqzannyj s	kanalom, nomer kotorogo	zadan
wyraveniem EXPR;
.DFN PRINT [#EXPR] USING STRING, LIST
wywesti	informaci`, ukazannu` w	spiske LIST,
na terminal ili	w fajl,	swqzannyj s kanalom, s zadannym
wyraveniem EXPR	nomerom; preobrazowanie	wywoda osu}estwitx po formatu,
opredelqemomu strokoj STRING, kotoraq movet sodervatx sledu`}ie	specifikacii:
.DF2 #
cifrowoe pole;
.DF2 . (to~ka)
ukazatelx pozicii desqti~noj to~ki;
.DF2 **
zapolnenie zwezdo~kami swobodnyh pozicij zapisi	pri pe~ati ~isla;
.DF2 ^
pole ukazatelq stepeni w |ksponencialxnom formate zapisi;
.DF2 - (minus)
znak ~isla wywoditsq posle ~isla;
.DF2 $
wywesti	pered ~islom znak $;
.DF2 , (zapqtaq)
razmetka ~islowyh polej	~erez tri znaka;
.DF2 ' (apostrof)
priznak	tekstowogo polq; rezerwiruet odnu pozici` dlq pe~ati litery;
.DF2 L
wyrawniwanie wlewo; liternoe pole;
.DF2 R
wyrawniwanie wprawo; liternoe pole;
.DF2 C
pe~atx po centru; liternoe pole;
.DF2 E
razre{aet ras{irenie stroki; liternoe pole;
.DFN RANDomIZe
zastawlqet dat~ik slu~ajnyh ~isel (funkciq RND)	generirowatx raznye
posledowatelxnosti slu~ajnyh
~isel pri o~erednom wypolnenii programmy;
.DFN ReaD VAR[,...]
priswaiwaet zna~eniq, pere~islennye w operatore	Data,
ukazannym peremennym VAR spiska;
.SWT
 RESET [#EXPR]
 RESTORE [#EXPR]
.AND 0
ustanawliwaet w	na~alxnoe sostoqnie ukazateli dannyh wseh fajlow; esli w
operatore prisutstwuet wyravenie EXPR, to |ta ustanowka	proizwoditsq
tolxko dlq ukazannogo whodnogo fajla,
swqzannogo s kanalom, nomer kotorogo zadan wyraveniem EXPR;
.DFN RETURN
zawer{aet podprogrammu i peredaet uprawlenie na	operator, sledu`}ij za
poslednim wypolnennym operatorom GoSUw;
.DFN STOP
zawer{aet wypolnenie programmy.
.HLV 2
komandy	operatora
.DFN APPEND [FILSPC]
ob'edinitx programmu, nahodq}u`sq w operatiwnoj	pamqti,	s programmoj iz
ukazannogo fajla; rezulxtat ob'edineniq	razme}aetsq w operatiwnoj pamqti;
.TBL BYE
zawer{enie seansa raboty s interpretatorom; wozwra}aet uprawlenie monitoru
mikro os;
.DFN CLEAR
inicializirowatx wse peremennye	zna~eniem nolx,	strokowye peremennye -
strokami dliny nolx; steretx massiwy;
.DFN COMPILE [FILSPC]
sohranitx skompilirowannyj wariant programmy w ukazannom fajle;
po umol~ani` w ka~estwe	imeni fajla ispolxzuetsq teku}ee imq programmy;
esli imq programmy ne zadano, budet sozdan fajl	s imenem NONAME;
.DFN DEL LINENUM[,...]
steretx	ukazannye stroki iz teksta programmy, nahodq}ejsq w pamqti;
.DFN LENGTH
raspe~atatx na terminale ob'em programmy w operatiwnoj pamqti i	ob'em
ostaw{egosq swobodnogo mesta;
.DFN LISM[NH] [STRINGNUM,...]
wywesti	na terminal ukazannye stroki nahodq}ejsq w pamqti programmy; Nn
podawlqet wywod	stroki zagolowka;
.DFN NEW [NAME]
komanda	o~i}aet	pamqtx i priswaiwaet imq NAME sozdawaemoj programme;
esli imq w komande ne ukazano, programme budet dano imq, wwedennoe
w otwet	na wopros "NEW FILE NAME -- "; esli w otwet na wopros budet
wwedena	pustaq stroka (tolxko <CR>), programme,	wwodimoj s terminala, budet
priswoeno imq NONAME;
.DFN OLD [FILSPC]
polnostx` o~istitx pamqtx i pro~itatx programmu, sohranennu` po	komande	SAVE,
iz ukazannogo FILSPC fajla; esli specifikaciq fajla ne dana, zadaetsq wopros
"OLD FILE NAME -- ", w otwet na	kotoryj
neobhodimo wwesti imq programmy	ili pustu`
(tolxko	<CR>) stroku; w	poslednem slu~ae budet s~itana programma s imenem
NONAME;
.DFN RENAME [NAME]
izmenitx teku}ee imq programmy na ukazannoe NAME;
imenem programmy po umol~ani` qwlqetsq NONAME;
.DFN REPLACE [FILSPC]
komanda	zamenqet fajl s	programmoj, ranee sozdannyj komandoj SAVE, na
ustrojstwe s fajlowoj strukturoj, fajlom s nowym tekstom programmy;
po umol~ani` w ka~estwe	imeni fajla ispolxzuetsq teku}ee imq programmy;
esli imq programmy otsutstwuet,	budet sozdan fajl DK:NONAME.BAS;
.DFN RESEQ [[NEWNUM],[OLDNUM1],[OLDNUM2],[STEP]]
perenumerowatx stroki programmy	ot nomera OLDNUM1 do nomera OLDNUM2;
nowu` numeraci`	na~atx s nomera	NEWNUM s {agom STEP;
.DFN RUN[NH] [FILSPC]
wypolnitx programmu, nahodq}u`sq w pamqti;
esli ukazana specifikaciq fajla	FILSPC,	to
o~istitx ispolxzuemu` pamqtx, wwesti programmu iz ukazannogo fajla i
wypolnitx wwedennu` programmu; Nn podawlqet wywod stroki zagolowka na
terminal pri zapuske programmy;
.DFN SAVE [FILSPC]
wywesti	programmu, hranq}u`sq w	pamqti,	w ukazannyj fajl;
po umol~ani` w ka~estwe	imeni fajla ispolxzuetsq teku}ee imq programmy;
esli imq programmy ne ukazano, budet sozdan fajl DK:NONAME.BAS;
.DFN SCR
polnostx` o~istitx pamqtx i zamenitx imq programmy na NoName;
.DFN SUB LINENUM@STRING1@STRING2[@INT]
INT ukazywaet ~islo powtorenij stroki STRING1.
propustitx ot na~ala stroki s ukazannym	nomerom	LINENUM
INT-1 ~islo powtorenij stroki STRING1, sledu`}u` stroku
STRING1	zamenitx na stroku STRING2;
znak @ qwlqetsq	razdelitelem w komande
i movet	bytx l`bym simwolom, ne	whodq}im
w STRING1 i STRING2;
.DFN UNSAVE FILSPC
steretx	ukazannyj fajl FILSPC s	ustrojstwa.
.HLV 2
arifmeti~eskie funkcii
.DFN ABS(EXPR)
absol`tnoe zna~enie wyraveniq EXPR;
.DFN ATN(EXPR)
arktangens wyraveniq EXPR kak weli~ina ugla w radianah w predelah
(-rI/2,+rI/2);
.DFN COS(EXPR)
kosinus	ugla, weli~ina kotorogo	w radianah zadana wyraveniem
EXPR;
.DFN EXP(EXPR)
zna~enie stepeni ~isla e, ukazannoj wyraveniem EXPR; e
priblizitelxno rawno 2.71828; EXPR dolvno bytx <= 87.;
.DFN INT(EXPR)
funkciq	opredelqet celu` ~astx wyraveniq EXPR,
okruglqq rezulxtat;
.DFN LOG(EXPR)
naturalxnyj logarifm wyraveniq EXPR;
zna~enie wyraveniq EXPR	dolvno bytx polovitelxnym;
.DFN LOG10(EXPR)
logarifm po osnowani` 10. ot wyraveniq EXPR;
zna~enie wyraveniq EXPR	dolvno bytx polovitelxnym;
.DFN PI
zna~enie rI (3.141593);	movet ispolxzowatxsq kak ~islowaq
konstanta;
.DFN RND[(EXPR)]
psewdoslu~ajnoe	~islo w	interwale [0,1];
pri powtornom wyzowe programmy posledowatelxnostx |tih ~isel budet powtorena,
esli ne	ispolxzuetsq operator RANDOMIZE; argument ignoriruetsq;
.DFN SGN(EXPR)
zna~enie, ukazywa`}ee znak wyraveniq EXPR;
-1, 0, +1 sootwetstwenno dlq otricatelxnogo, nulewogo i	polovitelxnogo
zna~eniq EXPR;
.DFN SIN(EXPR)
sinus ugla, weli~ina kotorogo w	radianah zadana	wyraveniem EXPR;
.DFN SQR(EXPR)
kwadratnyj korenx iz zna~eniq wyraveniq	EXPR;
zna~enie wyraveniq EXPR	dolvno bytx polovitelxnym;
.DFN TAB(EXPR)
ustanawliwaet pe~ata`}u` golowku ustrojstwa wywoda terminala (dlq
wideoterminala - kursor) na pozici` stroki s nomerom, zadannym wyraveniem
EXPR; wyzow funkcii razre{en tolxko w spiske wywoda operatora rRINt.
.HLV 2
strokowye funkcii
.DFN ASC(STRING)
zna~enie 7-bitnogo, wnutrennego	koda simwola, zadannogo
odnosimwolxnoj strokoj STRING;
.DFN BIN(STRING)
preobrazuet simwolxnu` posledowatelxnostx, soderva}u` dwoi~nu` zapisx
~isla, w desqti~noe celoe ~islo; probely ignoriru`tsq;
.DFN CHR$(EXPR)
generiruet odnosimwolxnu` stroku po mlad{emu bajtu zna~eniq wyraveniq EXPR;
mlad{ij	bajt ispolxzuetsq, kak kod koi-7 wozwra}aemogo simwola;
.DFN CLK$
wozwra}aet teku}ee wremq sistemy kak stroku w formate HH:MM:SS (naprimer,
23:57:01);
.DFN DAM$
wozwra}aet teku}u` sistemnu` datu kak stroku w formate DD-MMM-YY (naprimer,
1-OCT-84);
.DFN LEN(STRING)
~islo simwolow w stroke	STRING;
.DFN OCT(STRING)
preobrazuet simwolxnu` posledowatelxnostx STRING, soderva}u`
wosxmeri~nu` zapisx ~isla
w desqti~noe celoe ~islo; probely ignoriru`tsq;
.DFN POS(STRING1,STRING2,EXPR)
proizwodit poisk i wozwra}aet pozici` perwogo whovdeniq	stroki STRING2 w
stroke STRING1;	poisk na~inaetsq s simwola, poziciq kotorogo ukazana
wyraveniem EXPR;
.DFN SEG$(STRING,EXPR1,EXPR2)
wozwra}aet podstroku ukazannoj stroki STRING ot	pozicii,
ukazannoj EXPR1, do pozicii, ukazannoj EXPR2;
.DFN SMR$(EXPR)
wozwra}aet stroku, kotoraq predstawlqet	w simwolxnom wide zna~enie wyraveniq
EXPR;
.DFN TRM$(STRING)
wozwra}aet stroku bez zawer{a`}ih probelow;
.DFN VAL(STRING)
zna~enie ~isla,	desqti~naq zapisx kotorogo nahoditsq w stroke
STRING.
.HLV 2
sistemnye funkcii
.DFN ABORT(EXPR)
pri obra}enii k	|toj funkcii wypolnenie	programmy ostanawliwaetsq i, w
slu~ae EXPR = 1, programma udalqetsq iz	pamqti;
.DFN CTRLC
razre{aet interpretatoru wypolnenie komandy <CTRL/C>;
t.e wosstanawliwaet oby~nu` reakci` sistemy na |tot uprawlq`}ij	simwol;
.DFN RCTRLC
podawlqet standartnu` reakci` na <CTRL/C> i predotwra}aet
prekra}enie raboty
programmy w slu~ae wwoda |togo uprawlq`}ego simwola;
.DFN RCTRLO
razre{aet wywod	na terminal nezawisimo ot komand <CTRL/O> (sbrasywaet
flag <CTRL/O>);
.DFN SYS(EXPR1[,EXPR2])
wypolnqet sistemnye operacii, opredelqemye wyraveniqmi EXPR;
.DFN TTYSET(255,EXPR)
ustanawliwaet {irinu rabo~ego polq terminala rawnoj zna~eni` wyraveniq
EXPR-1.
.HLV 1
qzyk programmirowaniq paskalx
.LIN
translqciq programm, napisannyh	na qzyke paskalx, prowoditsq w dwa |tapa:
.AND
translqciq s qzyka paskalx na makroassembler,
.AND 0
translqciq s qzyka makroassembler w ob'ektnu` formu.
.LIN
perwyj {ag osu}estwlqetsq wyzowom kompilqtora s	qzyka paskalx, za kotorym
sleduet	wwod komandnoj stroki:
.SWT
      .R PASCAL
      *PROG.MAC,PROG.LST,PROG.SYM[/OPT]=P1.PAS,P2.PAS,...

 gde
.DFN PROG.MAC
fajl rezulxtata	translqcii;
.DFN PROG.LST
fajl listinga programmy;
.DFN PROG.SYM
fajl dwoi~noj tablicy simwolow,	opredelennyh w programme;
.DFN P1.PAS, P2.PAS i t.d.
fajly, soderva}ie ishodnyj tekst programmy;
.DFN /OPT
kl`~i kompilqtora (kl`~i pozicionno nezawisimy).
.LIN
wtoroj {ag translqcii movet bytx wypolnen pri pomo}i komandy monitora MACRO.
.HLV 2
kl`~i kompilqtora
.LIN
kompilqtor s qzyka paskalx dopuskaet ispolxzowanie sledu`}ih kl`~ej:
.DFN /D
wkl`~itx w transliruemu` programmu informaci` dlq otlad~ika:
imena peremennyh, procedur, nomera operatorow; pri ispolxzowanii sowmestno
s kl`~om /S ustanawliwaet sootwetstwie nomerow operatorow i strok w
listinge programmy; ispolxzuetsq takve dlq postroeniq "profilq"
programmy s pomo}x` modulq PASPRF;
.DFN /E
ob'qwlqet imq transliruemoj procedury globalxnym simwolom (dlq komponow}ika);
obqzatelen pri razdelxnoj translqcii procedury;
.DFN /F
optimizaciq raboty s ~islowymi dannymi tipa REAL pri rabote
na processorah,	ne ime`}ih instrukcij plawa`}ej	zapqtoj	(FIS) i	ne wkl`~a`}ih
processora plawa`}ej zapqtoj (FPU); uskorqet rabotu programmy
za s~et	uweli~eniq ee ob'ema;
.DFN /L[:K]
razre{enie polnoj raspe~atki teksta programmy w	listinge; "K" opredelqet
~islo strok listinga na	stranice raspe~atki;
.DFN /N
zapre}enie raspe~atki teksta programmy w listinge (krome strok,
soderva}ih o{ibki);
.DFN /S
w processe translqcii programmy	s qzyka	paskalx
na makroassembler wkl`~aet w
polu~ennyj tekst operatory qzyka paskalx w ka~estwe kommentariew;
.DFN /X
ispolxzuetsq dlq raboty	s dejstwitelxnymi ~islami dwojnoj
to~nosti (16 desqti~nyh	znakow posle zapqtoj); pri |tom
wydelqetsq po 4	slowa operatiwnoj pamqti kavdoj	peremennoj tipa	REAL;
po umol~ani` dlq peremennyh tipa REAL otwoditsq	po dwa slowa;
pri razdelxnoj translqcii modulej
programmy ispolxzowanie	kl`~a /X dolvno	bytx soglasowano;
.LIN
dejstwie opisannyh kl`~ej movet	bytx lokalizowano na trebuemom u~astke
programmy putem	wkl`~eniq w tekst programmy kommentariew wida
(*$Z+*)	i (*$Z-*). perwyj iz nih razre{aet, a wtoroj - zapre}aet translqtoru
dejstwiq, opredelqemye kl`~om Z, gde Z = (A, C,	D, E, F, S, T, X).
.LIN
ispolxzowanie Z	= (A, C, T) dopustimo tolxko w kommentariqh:
.DFN (*$A-*)
otmenqet kontrolx dopustimosti zna~enij	indeksow pri rabote s massiwami,
~to uskorqet wypolnenie	i umenx{aet ob'em programmy; po	umol~ani`
translqtor generiruet programmu	s wkl`~eniem instrukcij	kontrolq;
rekomenduetsq primenqtx	tolxko dlq otlavennyh programm;
.DFN (*$C
ob'qwlqet na~alo teksta	na makroassemblere, kotoryj neobhodimo wkl`~itx
w rezulxtat translqcii;	wstawlqemyj tekst dolven nahoditxsq wnutri skobok
kommentariq, t.e. zakan~iwatxsq	posledowatelxnostx` znakow *);
.DFN (*$T-*)
zapre}aet generaci` instrukcij,	prowerq`}ih perepolnenie steka;	ispolxzuetsq
dlq uskoreniq raboty i umenx{eniq zanimaemoj pamqti;
rekomenduetsq primenqtx	tolxko dlq otlavennyh programm.
.HLV 2
zarezerwirowannye identifikatory
.LIN
w realizacii qzyka paskalx su}estwu`t identifikatory,
s~ita`}iesq predopredelennymi (t.e. izwestnymi translqtoru).
pri neobhodimosti |ti identifikatory mogut bytx	pereopredeleny programmistom.
zarezerwirowannymi qwlq`tsq:
.SWT
 1) identifikatory konstant
.DFN ALFALENG =	10
werhnqq	granica	zna~eniq indeksa dlq massiwa tipa ALFA;
.DFN FALSE, TRUE
konstanty tipa BOOLEAN;	obozna~a`t "lovx" i "istina", sootwetstwenno;
.DFN MAXINT = 32767
maksimalxnoe celoe ~islo, dopustimoe w dannoj realizacii qzyka;
.SWT
 2) identifikatory tipow dannyh
.DFN ALFA
dannye,	kotorye	predstawlq`tsq w wide massiwa simwolow
(tipa CHAR); predopredelennyj strukturnyj tip:
.SWT
		ALFA = ARRAY [1..ALFALENG] OF CHAR;
.DFN BOOLEAN
logi~eskie dannye; movno uslowno s~itatx zadannymi pere~isleniem:
.SWT
		BOOLEAN	= (FALSE, TRUE)
.DFN CHAR
simwolxnye dannye; hranenie pobajtnoe (odin simwol koi-7 - odin	bajt);
.DFN INTEGER
celye ~isla; hranenie po odnomu	~islu w	slowe;
movno uslowno s~itatx zadannymi	otrezkom:
.SWT
		INTEGER	= -MAXINT-1..MAXINT
.DFN REAL
dejstwitelxnye ~isla; odno ~islo zanimaet 4 bajta; esli	pri translqcii
ukazywaetsq kl`~ /X, to	kavdoe ~islo zanimaet 8	bajt;
.DFN TEXT
tekstowoj fajl,	hranq}ijsq na wne{nem nositele;
fajl wwoda/wywoda pri rabote s terminalom;
pri wwode/wywode dannyh	bazowyh	tipow w	|tot fajl ispolnq`}aq sistema
proizwodit preobrazowanie wnutrennego predstawleniq w tekstowoe	i obratno;
.SWT
 3) identifikatory bibliote~nyh	funkcij
.DFN ABS (X)
wy~islqet absol`tnu` weli~inu zna~eniq X; tip argumenta	dolven bytx
INTEGER	ili REAL; tip rezulxtata sowpadaet s tipom argumenta;
.DFN ARCTAN (X)
wy~islqet arktangens dejstwitelxnoj weli~iny X;	rezulxtat - dejstwitelxnoe
~islo, predstawlq`}ee weli~inu ugla w radianah;
.DFN CHR (X)
argument wyzowa	dolven imetx tip INTEGER, rezulxtat imeet tip CHAR;
wozwra}aetsq simwol, porqdkowyj	nomer kotorogo w tablice koi-7 rawen X;
.DFN COS (X)
wy~islqet kosinus ugla,	zadannogo w radianah; argument i rezulxtat funkcii
ime`t tip REAL;
.DFN EOF (F)
logi~eskaq funkciq, wozwra}a`}aq zna~enie TRUE,	esli ukazatelx fajla F
nahoditsq w konce fajla	(za poslednej zapisx`);
.DFN EOLN (F)
logi~eskaq funkciq, wozwra}a`}aq zna~enie TRUE,	esli ukazatelx wwodimogo
tekstowogo fajla nahoditsq w konce stroki;
primenimo tolxko dlq fajlow tipa TEXT;
esli pri wyzowe	fajlowaq peremennaq fajla ne ukazana, to funkciq opredelqet
konec stroki, wwodimoj s terminala;
.DFN EXP (X)
|ksponenta ot X; argument i rezulxtat funkcii ime`t dejstwitelxnyj tip;
.DFN EXP10 (X)
|ksponenta po osnowani`	10 ot X; argument i rezulxtat funkcii ime`t
dejstwitelxnyj tip;
.DFN FLOAT (X)
preobrazowanie celogo zna~eniq X w formu s plawa`}ej zapqtoj, t.e. iz tipa
INTEGER	w tip REAL;
.DFN LN	(X)
naturalxnyj logarifm ot	X; argument i rezulxtat	funkcii	ime`t dejstwitelxnyj
tip;
.DFN LOG (X)
desqti~nyj logarifm ot X; argument i rezulxtat funkcii ime`t dejstwitelxnyj
tip;
.DFN ODD (X)
logi~eskaq funkciq; wozwra}aet zna~enie	TRUE, esli argument (tipa INTEGER)
- ne~etnoe ~islo;
.DFN ORD (C)
esli argument wyzowa simwolxnogo tipa (CHAR), to rezulxtat - celoe ~islo,
rawnoe porqdkowomu nomeru litery "C" w tablice koi-7;
esli argument wyzowa imeet tip,	zadannyj pere~isleniem,	to wozwra}aemoe
zna~enie - porqdkowyj nomer zna~eniq w pere~islenii;
.DFN PRED (X)
wozwra}aet zna~enie, pred{estwu`}ee X, esli ono	su}estwuet;
X dolvno bytx skalqrnogo tipa;
wozwra}aemoe zna~enie imeet tot	ve tip,	~to i X;
.DFN ROUND (X)
okruglenie do blivaj{ego celogo; argument wyzowa dolven	bytx tipa REAL;
wozwra}aemoe zna~enie imeet tip	INTEGER;
.DFN SIN (X)
sinus ugla, zadannogo w	radianah; argument wyzowa i zna~enie
funkcii	ime`t tip REAL;
.DFN SQR (X)
wy~islenie kwadrata ~isla; dopustimy argumenty tipa INTEGER i REAL;
wozwra}aemoe zna~enie imeet tot	ve tip,	~to i argument;
.DFN SQRT (X)
wy~islenie kwadratnogo kornq ot	X; argument movet bytx tipa REAL ili INTEGER,
a rezulxtat wsegda tipa	REAL;
.DFN SUCC (X)
wozwra}aet zna~enie, sledu`}ee za X, esli ono su}estwuet;
X dolven bytx skalqrnogo tipa;
wozwra}aemoe zna~enie imeet tot	ve tip,	~to i X;
.DFN TRUNC (X)
use~enie do celogo; argument wyzowa dolven imetx tip REAL;
wozwra}aemoe zna~enie imeet tip	INTEGER;
.DFN TIME
wozwra}aet zna~enie tipa REAL, sootwetstwu`}ee wremeni dnq
(ot poluno~i) w	sekundah; to~nostx ne menee odnoj sekundy;
.SWT
 4) identifikatory procedur
.DFN BREAK (F)
w ispolnq`}ej sisteme paskalx/mikro os osu}estwlqetsq buferizaciq wwoda/wywoda
- fakti~eskij wywod proizwoditsq tolxko	pri zapolnenii bufera obmena;
obra}enie k BREAK wyzywaet nemedlennyj wywod zapolnennoj ~asti bufera
fajla F;
.DFN CLOSE (F)
zakrytx	ukazannyj fajl F; pri zakrytii awtomati~eski wypolnqetsq procedura
BREAK(F) i oswobovdaetsq pamqtx, zanqtaq buferom obmena;
.DFN DISPOSE (P)
oswoboditx (wernutx w spisok swobodnoj pamqti) oblastx pamqti, polu~ennu` po
procedure NEW; P qwlqetsq ukazatelem na	oswobovdaemu` oblastx;
razmer oswobovdaemoj oblasti opredelqetsq tipom	ukazatelq P;
esli P qwlqetsq	ukazatelem wariantnoj zapisi, to za P w	spiske argumentow
mogut bytx zadany zna~eniq polej wariantow, kotorye ignoriru`tsq sistemoj
"DISPOSE (P[,V1,...,VK])";
.DFN GET (F)
peredwinutx ukazatelx w	fajle F	na sledu`}u` zapisx i priswoitx	ee zna~enie
bufernoj peremennoj F^;	w slu~ae EOF(F)=TRUE zna~enie F^ ne opredeleno;
.DFN NEW (P)
wydelqet oblastx pamqti	iz spiska swobodnoj i priswaiwaet P zna~enie,
ukazywa`}ee na |tu oblastx; razmer dinami~eski wydelqemoj oblasti opredelqetsq
tipom ukazatelq	P; esli	P qwlqetsq ukazatelem wariantnoj zapisi, to za P
w spiske argumentow wyzowa mogut bytx zadany zna~eniq polej priznakow,
kotorye	sistemoj ignoriru`tsq "NEW (P[,V1,...,VK])";
.DFN PAGE (F)
wywesti	w tekstowoj fajl F uprawlq`}ij znak <FF> dlq perehoda k	nowoj
stranice;
.DFN PUT (F)
zapisywaet zna~enie bufernoj peremennoj	F^ w fajl F; operaciq opredelena
pri EOF(F)=TRUE;
.DFN RESET (F,FILSPC,DEF,LEN)
otkrytx	su}estwu`}ij na	wne{nem	nositele fajl dlq ~teniq; ustanowitx
sootwetstwie mevdu specifikaciej fajla (w formate CSI) FILSPC i	fajlowoj
peremennoj F, priswoitx	bufernoj peremennoj F^ zna~enie	perwoj zapisi fajla;
DEF opredelqet specifikaci` fajla po
umol~ani`, a wozwra}aemoe w celoj peremennoj LEN zna~enie - dlinu fajla	w
blokah (ili -1,	esli ukazannyj fajl ne najden);	FILSPC i DEF dolvny bytx
odnomernymi massiwami |lementow	tipa CHAR; FILSPC i DEF	mogut sodervatx
sledu`}ie kl`~i:
.DF2 /BUFFERSIZE:N
ukazywaet razmer bufera	obmena w bajtah; po umol~ani` N
rawno 512 (desqti~noe);
.DF2 /GO
ignoriruet o{ibki pri obmene s dannym fajlom;
bez |togo kl`~a	l`bye o{ibki obmena qwlq`tsq
fatalxnymi i priwodqt k	prekra}eni` raboty programmy;
.DF2 /SEEK
razre{aet ispolxzowanie	procedury SEEK() dlq prqmogo dostupa k zapisqm fajla;
.DF2 /SPANNED
razre{aet zapisi peresekatx granicu bloka na nositele; uweli~iwaet
|ffektiwnostx ispolxzowaniq wne{nej pamqti; bez	|togo kl`~a blok wsegda
sodervit celoe ~islo zapisej, ~to uweli~iwaet skorostx obmena za s~et
rashoda	wne{nej	pamqti;
.DF2 /TEMPORARY
sozdaet	wremennyj fajl (tolxko
dlq procedury REWRITE);	posle wypolneniq operacii
zakrytiq (CLOSE) fajl udalqetsq; pri ispolxzowanii |togo kl`~a imq fajla
ne obqzatelxno;
.DFN REWRITE (F,FILSPC,DEF,LEN)
sozdatx	fajl FILSPC na wne{nem nositele	i otkrytx ego dlq zapisi;
ustanowitx sootwetstwie	mevdu fajlom i fajlowoj	peremennoj F;
DEF opredelqet specifikaci` fajla po umol~ani`,	a celo~islennaq	peremennaq
LEN - dlinu sozdawaemogo fajla w blokah; FILSPC	i DEF dolvny bytx odnomernymi
massiwami |lementow tipa CHAR; posle wypolneniq	|toj procedury EOF(F)
prinimaet zna~enie TRUE; FILSPC	i DEF mogut sodervatx kl`~i, ispolxzuemye
w procedure RESET;
.DFN READ (F,LIST)
pro~itatx iz tekstowogo	fajla F	i priswoitx peremennym,	ukazannym w spiske
LIST, zna~eniq;	dlq peremennyh bazowyh tipow proizwoditsq preobrazowanie
zna~enij iz tekstowogo predstawleniq wo	wnutrennee; dopustim wwod w peremennye
tipa odnomernogo simwolxnogo massiwa; esli ne ukazana peremennaq-fajl F, to
wwod osu}estwlqetsq s terminala;
.DFN READLN (F,LIST)
|kwiwalentno READ; dopolnitelxno proizwoditsq propusk
wseh znakow, ostaw{ihsq
w teku}ej stroke wwoda,	do
ograni~itelq stroki wkl`~itelxno;
.DFN SEEK (F,N)
pozicionirowatx	ukazatelx fajla	F na zapisx nomer N i s~itatx |tu zapisx w
bufernu` peremennu` F^;	dlq izmeneniq sodervimogo |toj zapisi posle
pozicionirowaniq neobhodimo priswoitx bufernoj peremennoj nowoe	zna~enie i
wypolnitx PUT(F);
.DFN WRITE (F,LIST)
wywesti	w tekstowoj fajl F zna~eniq, ukazannye w spiske	LIST, ~erez zapqtu`;
dlq peremennyh
bazowyh	tipow proizwoditsq preobrazowanie iz wnutrennego predstawleniq w
tekstowoe; dopustim wywod zna~enij tipa	odnomernogo simwolxnogo	massiwa,
i ispolxzowanie	konstrukcij wida "V:N1"	i "V:N1:N2";
esli ne	ukazana	peremennaq-fajl	F, to wywod proizwoditsq na terminal;
.DFN WRITELN (F,LIST)
|kwiwalentno WRITE; dopolnitelxno proizwoditsq wywod uprawlq`}ih znakow
perehoda na nowu` stroku.
.HLV 2
kl`~ewye slowa
.LIN
kl`~ewye slowa qwlq`tsq	sredstwom opisaniq struktur dannyh i algoritmow
raboty programmy na qzyke paskalx. pereopredelenie |tih	identifikatorow
zapre}eno. k kl`~ewym slowam otnosqtsq:
.DFN AND
operaciq "logi~eskoe "i" operandow tipa	BOOLEAN";
.AND 0
operaciq "porazrqdnoe logi~eskoe "i" operandow tipa INTEGER";
.DFN ARRAY
kl`~ewoe slowo dlq opisaniq massiwa;
.DFN BEGIN
.AND 0
kl`~ewoe slowo na~ala tela procedury, funkcii ili golownoj programmy;
.AND 0
kl`~ewoe slowo na~ala sostawnogo operatora.
.DFN CASE
kl`~ewoe slowo na~ala opisaniq wariantnoj ~asti	zapisi (RECORD);
wariantnaq ~astx dolvna	bytx poslednej w zapisi; ona imeet strukturu
"CASE NAM:SWTYP	OF C1:(L1); C2:(L2) ..."; NAM zadaet imq polq i~eskoe "i" operandow tipa	BOOLEAN";
.AND 0
operaciq "porazrqdnoe logi~eskoe "i" operandow tipa INTEGER";
.DFN ARRAY
kl`~ewoe slowo dlq opisaniq massiwa;
.DFN BEGIN
.AND 0
kl`~ewoe slowo na~ala tela procedury, funkcii ili golownoj programmy;
.AND 0
kl`~ewoe slowo na~ala sostawnogo operatora.
.DFN CASE
kl`~ewoe slowo na~ala opisaniq wariantnoj ~asti	zapisi (RECORD);
wariantnaq ~astx dolvna	bytx poslednej w zapisi; ona imeet strukturu
"CASE NAM:SWTYP	OF C1:(L1); C2:(L2) ..."; NAM zadaet imq polq wok razdela opredeleniq konstant w programme ili procedure;
.DFN DIV
operaciq celo~islennogo	deleniq; imeet operandy	tipa INTEGER;
.DFN DO
kl`~ewoe slowo,	whodq}ee w konstrukcii FOR, WITH, WHILE, za kotorym sleduet
operator, wypolnqemyj w	|toj uprawlq`}ej strukture;
.DFN DOWNTO
kl`~ewoe slowo w konstrukcii FOR, opredelq`{ee,	~to peremennaq cikla dolvna
w konce	kavdoj iteracii	izmenqtx zna~enie na pred{estwu`}ee teku}emu;
.DFN ELSE
kl`~ewoe slowo w konstrukciqh CASE i IF, za kotorym sleduet operator,
polu~a`}ij uprawlenie w	slu~ae newypolneniq uslowiq (IF) ili nesowpadeniq
zna~eniq perekl`~atelq s metkami wariantow (CASE); slowo ELSE i	sledu`}ij
za nim operator	w ukazannyh konstrukciqh ne qwlq`tsq obqzatelxnymi;
.DFN END
kl`~ewoe slowo okon~aniq sostawnogo operatora;
.AND 0
kl`~ewoe slowo okon~aniq tela procedury	ili funkcii;
.AND 0
kl`~ewoe slowo okon~aniq opisaniq struktury dannyh wida	RECORD;
.DFN END.
kl`~ewoe slowo konca teksta programmy;
.DFN EXIT
operator wyhoda	iz teku}ego cikla, obrazowannogo konstrukciqmi FOR, WHILE,
REPEAT,	nezawisimo ot uslowiq zawer{eniq |togo cikla;
.DFN EXTERNAL
kl`~ewoe slowo opisaniq	wne{nej, otdelxno transliruemoj	procedury ili funkcii;
w opisanii sleduet za opredeleniem zagolowka procedury (funkcii) i
otdelqetsq ot nego to~koj s zapqtoj; telo procedury (funkcii) pri |tom ne
zadaetsq;
.DFN FILE
kl`~ewoe slowo opredeleniq fajla w konstrukcii "FILE OF	TYP", gde
TYP - tip zapisi (|lementa) fajla;
.DFN FOR
kl`~ewoe slowo operatora cikla;	operator imeet strukturu
"FOR IVAR:= EXPR1 TO EXPR2
DO STAT", gde IVAR - peremennaq	cikla, EXPR1 i EXPR2 - na~alxnoe i,
sootwetstwenno,	kone~noe zna~enie, prinimaemoe |toj peremennoj;
wypolnenie
operatora STAT prekra}aetsq pri	IVAR>EXPR2; izmenenie peremennoj cikla
opredelqetsq kl`~ewym slowom "TO"; w konce kavdoj iteracii zna~enie IVAR
zame}aetsq na SUCC(IVAR); pri ispolxzowanii wmesto "TO"	kl`~ewogo
slowa "DOWNTO"
zna~enie peremennoj cikla w konce iteracii zamenqetsq
na PRED(IVAR), i cikl zakan~iwaetsq po uslowi` IVAR<EXPR2;
.DFN FORTRAN
kl`~ewoe slowo opisaniq	wne{nej	procedury ili funkcii, napisannoj na qzyke
fortran; w opisanii sleduet za opredeleniem zagolowka procedury	(funkcii)
i otdelqetsq ot	nego to~koj s zapqtoj; telo procedury (funkcii)	pri |tom ne
zadaetsq;
.DFN FORWARD
kl`~ewoe slowo predwaritelxnogo	opisaniq zagolowka procedury ili funkcii;
w opisanii sleduet za opredeleniem i otdelqetsq	ot nego
to~koj s zapqtoj; telo procedury (wmeste s
sokra}ennym zadaniem zagolowka)	opisywaetsq dalee w tekste programmy;
|to kl`~ewoe slowo
ispolxzuetsq pri neobhodimosti wyzowa procedury	do ee polnogo opisaniq;
.DFN FUNCTION
kl`~ewoe slowo opredeleniq zagolowka funkcii, imeet strukturu:
"FUNCTION NAME(PARLIST):TYP", gde NAME - zadaet	imq funkcii, a TYP - tip
wozwra}aemogo rezulxtata; spisok parametrow wyzowa PARLIST movet wkl`~atx
sledu`}ie predloveniq, razdelennye to~kami s zapqtoj:
.DF2 NAM:TYP1
opredelenie parametra, peredawaemogo po	zna~eni`;
.DF2 VAR NAM:TYP
opredelenie parametra, peredawaemogo po	ssylke (parametra s wozwra}aemym
zna~eniem);
.DF2 FUNCTION NAM:TYP
opredelenie parametra -	imeni funkcii, wyzywaemoj wnutri dannoj	funkcii;
.DF2 PROCEDURE NAM
opredelenie parametra -	imeni procedury, wyzywaemoj wnutri dannoj funkcii;
.DFN GOTO LAB
operator bezuslownoj pereda~i uprawleniq na metku LAB; metka dolvna
nahoditxsq w predelah programmnoj edinicy, w razdele opisaniq metok
kotoroj	ona ob'qwlena;
.DFN IF
kl`~ewoe slowo uslownogo operatora, ime`}ego strukturu "IF LOGEXPR THEN
OPER1 ELSE OPER2", gde,	w zawisimosti ot zna~eniq logi~eskogo wyraveniq
LOGEXPR, wypolnqetsq OPER1 (w slu~ae "TRUE") ili OPER2 (w slu~ae "FALSE");
oborot "ELSE OPER2" ne obqzatelen;
pri wlovennosti	IF oborot ELSE s~itaetsq otnosq}imsq k poslednemu (po
wlovennosti) IF, ne ime`}ego ELSE;
.DFN IN
operaciq prowerki prinadlevnosti |lementa mnovestwu; "A	IN B" -	|lement	"A"
whodit w mnovestwo "B";
.DFN LABEL
zagolowok razdela opredeleniq metok w programme	ili procedure;
.DFN MOD
operaciq polu~eniq ostatka pri celo~islennom delenii; argumenty	tipa INTEGER;
.DFN NIL
konstanta specialxnogo wida: neopredelennoe zna~enie ukazatelq;
.DFN NOT
operaciq "otricaniq" operanda tipa BOOLEAN;
.AND 0
porazrqdnaq inwersiq operanda tipa INTEGER;
.DFN OF
kl`~ewoe slowo,	whodq}ee w sostaw konstrukcij ARRAY, CASE, FILE, SET;
.DFN OR
logi~eskaq operaciq "ili" operandow tipa BOOLEAN;
.AND 0
porazrqdnoe logi~eskoe "ili" operandow tipa INTEGER;
.DFN ORIGIN
kl`~ewoe slowo,	whodq}ee w konstrukci` opredeleniq peremennoj
(NAME :	TYP ORIGIN ADR)	pri neobhodimosti
ukazaniq adresa	q~ejki pamqti, s kotoroj peremennaq na~inaet razme}atxsq;
peremennaq NAM tipa TYP	razme}aetsq w pamqti po	adresu ADR;
.DFN PACKED
kl`~ewoe slowo,	opredelq`}ee uplotnennoe (upakowannoe) razme}enie dannyh
ob'qwlqemogo tipa; ignoriruetsq	kompilqtorom;
.DFN PROGRAM
kl`~ewoe slowo opredeleniq imeni programmy, ime`}ee strukturu "PROGRAM
NAME(ARG)"; parametry ARG ukazywa`t peremennye-fajly, zadawaemye pri zapuske
programmy; opredelenie ignoriruetsq kompilqtorom;
.DFN PROCEDURE
kl`~ewoe slowo opredeleniq zagolowka procedury,	imeet strukturu	"PROCEDURE
NAME(PARLIST)",	gde NAME zadaet	imq procedury, a spisok	parametrow wyzowa
PARLIST	imeet tu ve formu, ~to i w opredelenii funkcii;
.DFN RECORD
kl`~ewoe slowo deklaracii tipa dannyh so strukturoj zapisi; deklaraciq imeet
formu "RECORD NAM1: TYP1; NAM2:TYP2,...END;", gde NAM opredelqet
imq polq zapisi, a TYP - tip dannyh, hranq}ihsq	w |tom pole; dopuskaet nali~ie
wariantnoj ~asti (opisano w CASE);
.DFN REPEAT
kl`~ewoe slowo na~ala operatora	cikla "REPEAT STAT UNTIL LOGEXPR";
wypolnenie operatora
STAT powtorqetsq do teh	por, poka logi~eskoe wyravenie LOGEXPR ne polu~it
zna~enie "TRUE"; operator STAT wypolnqetsq po krajnej mere odin	raz;
.DFN SET
kl`~ewoe slowo deklaracii dannyh tipa "mnovestwo"; deklaraciq imeet formu
"SET OF	TYP", gde TYP -	opisanie tipa |lementa mnovestwa; tip TYP obqzan
bytx skalqrnym i imetx ne bolee	64 raznyh zna~enij;
.DFN THEN
kl`~ewoe slowo w konstrukcii IF, opredelq`}ee operator,	wypolnq`}ijsq w	slu~ae
istinnosti uslowiq;
.DFN TO
kl`~ewoe slowo w konstrukcii FOR, opredelq`}ee,	~to peremennoj cikla w konce
iteracii dolvno	bytx priswoeno zna~enie, sledu`}ee za teku}im;
.DFN TYPE
zagolowok razdela opredeleniq imen tipow w programme ili procedure;
.DFN UNTIL
kl`~ewoe slowo konca operatora cikla REPEAT, za	kotorym	sleduet	logi~eskoe
wyravenie, opredelq`}ee	uslowie	zawer{eniq cikla;
.DFN VAR
zagolowok razdela opredeleniq imen peremennyh w	programme ili procedure;
.DFN WHILE
kl`~ewoe slowo na~ala operatora	cikla "WHILE LOGEXPR DO	STAT";
wypolnenie operatora STAT
powtorqetsq, poka logi~eskoe wyravenie LOGEXPR imeet zna~enie "TRUE";
.DFN WITH
kl`~ewoe slowo operatora dostupa k polqm zapisi	"WITH REC DO STAT";
pozwolqet w operatore STAT obra}atxsq k	polqm zapisi REC kak k peremennym
(po imenam);
.DFN @
adresnyj operator; zna~eniem "@VARI" qwlqetsq ukazatelx	na peremennu` VARI;
.DFN :=
operator priswaiwaniq; w operatore "A:=B" peremennoj "A" priswaiwaetsq zna~eni
e
wyraveniq "B";
.DFN ..
konstrukciq "A .. B" opredelqet	tip dannyh, dlq	kotorogo zna~eniq nahodqtsq w
granicah ot A do B wkl`~itelxno; |tot tip qwlqetsq otrezkom tipa, k kotoromu
prinadlevat skalqrnye konstanty	A i B; obqzatelxnym qwlqetsq uslowie A<=B;
k tipu REAL wydelenie otrezka ne primenimo.
.HLV 2
programma PCL
.LIN
programma prednazna~ena	dlq raboty s sistemoj programmirowaniq paskalx:
po wwedennoj komandnoj stroke formata CSI programma formiruet
i zapuskaet na wypolnenie komandnyj fajl (DK:PASCAL.COM), obespe~iwa`}ij
translqci`, komponowku i zapusk	programm na paskale. w komandnoj stroke	PCL
dopustimy kl`~i, razre{ennye translqtorom, i sledu`}ie dopolnitelxnye kl`~i:
.DFN /C
ottranslirowatx	i skomponowatx programmu, no ne	wyzywatx ee na wypolnenie;
.DFN /G
ottranslirowatx, skomponowatx programmu	i wyzwatx ee na	wypolnenie (kl`~ po
umol~ani`);
.DFN /I
posle translqcii kompilqtorom paskalx wypolnitx	optimizaci` polu~ennogo	na
assemblere teksta s pomo}x` programmy PASIMP;
.DFN /M
wypolnitx tolxko translqci` programmy kompilqtorom paskalx;
.DFN /O
wypolnitx translqci` programmy kompilqtorom paskalx i makroassemblerom;
.DFN /P
w processe komponowki prisoedinitx k programme modulx postroeniq profilq
~astoty	wypolneniq operatorow i	procedur; ne sowmestim s kl`~om	/D;
pri ispolxzowanii s kl`~om /S priwodit k wywodu	listinga programmy po
okon~anii ee raboty.
.HLV 2
postroenie profilq (modulx PASPRF)
.LIN
modulx postroeniq profilq  prednazna~en	dlq sbora i raspe~atki statistiki o
wypolnenii operatorow programmy	i wyzowah procedur i
funkcij. modulx	postroeniq
profilq	wkl`~aetsq w programmu s pomo}x` kl`~a /P programmy PCL.
.LIN
pri wyzowe programmy, wkl`~a`}ej PASPRF, modulx
postroeniq profilq zapra{iwaet
imq programmy i, pri neobhodimosti, imena fajlow listinga
i dwoi~noj tablicy simwolow, a takve specifikaci` fajla	wywoda
statistiki (tip	po umol~ani` .PRO).
po okon~anii raboty programmy modulx postroeniq	profilq	wywodit
w zadannyj fajl	sobrannu` statistiku, kotoraq wkl`~aet imena procedur i	~islo
ih wyzowow, a takve nomera operatorow i	~islo ih wypolneniq. esli pri
translqcii ispolxzowalsq kl`~ /S, to wywoditsq listing programmy, w kotorom
kavdaq stroka, soderva}aq wypolnqemyj operator,	pome~ena sootwetstwu`}im
nomerom.
.LIN
statistika nakapliwaetsq tolxko	dlq perwyh 100 operatorow, procedur i funkcij.
maksimalxnoe dopustimoe	~islo procedur i funkcij rawno 40.
.HLV 2
otlad~ik programm na paskale "PDT"
.LIN
otlad~ik programm na paskale predstawlqet programmistu sredstwa
prosmotra i izmeneniq sodervimogo peremennyh, razme}eniq to~ek
ostanowa pered zadannymi operatorami, sleveniq za izmeneniem
zna~enij wybrannoj peremennoj, a takve trassirowki wypolneniq
operatorow i wyzowow procedur. otladka wedetsq w terminah
qzyka paskalx.
.LIN
dlq wkl`~eniq otlad~ika	w programmu ispolxzuetsq programma PCL
(kl`~ /D). pri translqcii programmy
s kl`~om /S otlad~ik polu~aet wozmovnostx raboty
s listingom programmy. poskolxku otlad~ik imeet	strukturu perekrytij,
to dlq otladki programmy s perekrytiqmi	komandnyj fajl,	sozdawaemyj
PCL, dolven bytx sootwetstwu`}im obrazom otredaktirowan. pri zapuske
programmy s otlad~ikom operatoru zadaetsq wopros ob imeni fajla
s listingom programmy.
.LIN
dostup k peremennym iz otlad~ika proizwoditsq tak ve, kak iz
programmy na paskale. PDT raspoznaet wse struktury peremennyh i
skalqrnye tipy,	opredelennye polxzowatelem. dlq	izmeneniq zna~eniq
ispolxzuetsq operator priswaiwaniq ":=", w lewoj ~asti kotorogo
ukazywaetsq izmenqemaq peremennaq, a w prawoj -	konstanta
ili peremennaq,	iz kotoroj beretsq zna~enie. wyraveniq w prawoj
~asti nedopustimy.
.LIN
otlad~ik programm na paskale imeet sledu`}ij nabor komand:
.DFN B
otmenitx teku}u` to~ku ostanowa;
.DFN B(SUBR,N)<COMMAND>
ustanowitx to~ku ostanowa pered	operatorom s nomerom N procedury ili
funkcii	SUBR; w	processe raboty	movet bytx opredeleno do 8 to~ek ostanowa;
neobqzatelxnaq posledowatelxnostx komand otlad~ika COMMAND swqzywaetsq
s ukazannoj to~koj ostanowa i wypolnqetsq, kogda programma wyhodit
na |tu to~ku;
.DFN C(N)
prodolvitx wypolnenie programmy	posle wyhoda w to~ku ostanowa;
neobqzatelxnyj argument	N opredelqet ~islo bezostanowo~nyh
prohodow ~erez dannu` to~ku ostanowa; po umol~ani` N rawno 1;
.DFN D
raspe~atatx na terminale teku}ee sostoqnie otlad~ika: otsleviwaemye
peremennye, su}estwu`}ie to~ki ostanowa	i swqzannye s nimi
posledowatelxnosti komand, a takve operatory, na kotoryh ustanowleny
metki otlad~ika;
.DFN G
na~atx wypolnenie otlaviwaemoj programmy sna~ala;
.DFN G(N)
prodolvitx wypolnenie programmy	s operatora, pome~ennogo metkoj
otlad~ika N;
.DFN H
raspe~atatx 10 poslednih wypolnennyh operatorow	programmy;
.DFN K(SUBR,N)
otmenitx to~ku ostanowa	ili ubratx metku otlad~ika na operatore	N
podprogrammy ili funkcii SUBR; esli argument N
ne ukazan, udalq`tsq wse metki i wse to~ki ostanowa;
.DFN L(N)
pometitx metkoj	otlad~ika N teku}u` to~ku ostanowa;
N - ~islo w diapazone ot 1 do 8;
.DFN P(N)
wypolnitx N o~erednyh operatorow teku}ej procedury;
po umol~ani` N rawno 1;	pri |tom wyzow procedury i obra}eniq k funkciqm
w wyravenii rassmatriwa`tsq kak	odin operator;
pri wyhode iz teku}ej procedury	proishodit ostanow na operatore,
sledu`}em za to~koj wyzowa;
.DFN R
raspe~atatx teku}ee sodervimoe registrow processora R1-R7 w wosxmeri~nom
i desqti~nom wide; ispolxzuetsq	dlq otladki assemblernyh wstawok;
.DFN S(N)
wypolnitx N o~erednyh operatorow programmy, wkl`~aq operatory wyzywaemyh
procedur i funkcij; po umol~ani` N rawno 1;
.DFN T(FALSE)
otmenitx revim trassirowki;
.DFN T(TRUE)
wkl`~itx revim trassirowki; pered wypolneniem o~erednogo operatora
na terminal wywoditsq imq procedury i nomer |togo operatora w procedure;
esli programma translirowalasx s kl`~om	/S, to wywoditsq takve i tekst
stroki,	soderva}ej operator;
.DFN V
otmenitx slevenie za izmeneniem	zna~eniq peremennoj;
.DFN V(VARIABLE)<COMMAND>
slevenie za izmeneniem zna~eniq	ukazannoj peremennoj; pri izmenenii
zna~eniq otlad~ik polu~it uprawlenie, kak w to~ke ostanowa; pri	|tom
budet wypolnena	posledowatelxnostx komand otlad~ika COMMAND, esli
ona byla zadana; ustanowitx slevenie za	lokalxnoj peremennoj
procedury movno	tolxko pri wypolnenii |toj procedury; po okon~anii
procedury slevenie za peremennoj awtomati~eski prekra}aetsq;
pri wypolnenii procedury movet otsleviwatxsq tolxko odna peremennaq;
.DFN W(VAR1,VAR2,...)
raspe~atatx zna~eniq peremennyh, ukazatelej, konstant i	q~eek
pamqti,	pere~islennyh ~erez zapqtu`.

                                                                                                                                                                                                                                                                                                                                                                                                                                                   