Program lab5;
Uses crt;
Type      tmas = array[1..10] of integer
Var       a,b:tmas
          i,j:byte
          na,n,b:word
{$L obrab.obj} { тут мы подключили внешний модуль }
{$F+} {все процедуры после этой директивы будут иметь дальнюю адресацию}
Procedure M_ch_zr (Var x:tmas; n:word); external;
Function max_cl (Var x:tmas; n:word):integer; external;
{$F-}
{Процедуры ввода-вывода массивов}
Begin { main }
  in_massiv (a,na,'A')
  in_massiv (b,nb,'B');
  clrscr;
  out_massiv (a,na,'Исходный массив A');
  Writeln ('Максимальный элемент -',max_el(A,nA));
  M_ch_zr (A,na);
  Out_mas (A,na,'Преобразованный массив A')
End. { /main }

CODE      SEGMENT
PUBLIC    M_ch_Zr
ASSUME    CS:CODE
M_ch_zr   PROC      FAR            ;замена <0 на 0
          PUSH      CX DI BP ES
          mov       BP,SP

;    В данный момент в стек выглядит следующим образом:
;           │        │
;           ├────────┤
;           │ ES     │bp+0
;           ├────────┤
;           │ BP     │ +2
;           ├────────┤
;           │ DI     │ +4
;           ├────────┤
;           │ CX     │ +6
;           ├────────┤
;  адрес   ┌┤смещение│ +8
;  возврата│├────────┤
;          └┤сегмент │ +10
;           ├────────┤
;           │  n     │ +12
;           ├────────┤
;  адрес   ┌┤смещение│ +14
;  x       │├────────┤
;          └┤сегмент │ +16
;           └────────┘

          mov       CX,[BP+12]     ; n
          les       DI,[BP+14]     ; адрес X
c:        mov       AX,es:[DI]
; при трансляции перед этой командой ставится префикс изменения сег-
; мента адресации. При отсутствии ES:  адресация  автоматически  де-
; лается DS:[DI]. Префикс действует только на одну команду.
          cmp       AX,0
          jge       M
          mov       word PTR ES:[DI],0
M:        add       DI,2
          loop      C
          pop       ES BP DI CX
          ret       6
M_ch_zr   ENDP
CODE      ENDS
          END
; Как видите, этот модуль практически ничем не отличается от обычной
; программы на Ассемблере, но отличия все же есть: это, во-первых,
; строго заданные имена сегментов и, во-вторых, вконце модуля стоит END
; без параметров. Это нужно помнить!

Max_el    PROC      FAR
          push      CX DI BP ES
          mov       BP,SP
          mov       CX,[BP+12]
          mov       DI,[BP+14]
          mov       AX,DI
C1:       cmp       AX,[DI]
          jge       M1
          mov       AX,[DI]
M1:       add       [DI],2
          loop      C1
          pop       ES BP DI CX
          ret       6
Max_el    ENDP

Program Prime_p;
Const
  N=255;
Type
  SetOfNumb = set of 1..N;
Var
  n1,next,i : word;
  BeginSet,
  PrimeSet  : SetOfNumb;
begin
  { Тут что-то происходит... }
end.

 Start  Stop   Length Name               Class
(Это описание сегментов)
 00000H 00145H 00146H Prime_p            CODE
 00150H 00B50H 00A01H System             CODE
 00B60H 00E43H 002E4H DATA               DATA
 00E50H 04E4FH 04000H STACK              STACK
 04E50H 04E50H 00000H HEAP               HEAP

  Address         Publics by Value
(А это то, что нас интересует)
 0000:0020       @
 00B6:0002       OvrCodeList
 00B6:0004       OvrHeapSize

      . . . . . . .

 00B6:004C       Test8086
 00B6:004D       Test8087
 00B6:004E       FileMode
 00B6:0052       n1
 00B6:0054       next
 00B6:0056       i
 00B6:0058       BeginSet
 00B6:0078       PrimeSet
 00B6:0098       Input
 00B6:0198       Output
 00B6:0298       SaveInt00
 00B6:029C       SaveInt02

       . . . . . . .
 
 00B6:02D4       SaveInt3D
 00B6:02D8       SaveInt3E
 00B6:02DC       SaveInt3F
 00B6:02E0       SaveInt75

(А это точка входа в программу)
Program entry point at 0000:0020

CODE      SEGMENT
PUBLIC    xxx
EXTRN n1:word, next:word, i:word . . .
ASSUME    CS:CODE
       . . . . . . .     

Program Matrix_asm;
Uses CRT;
Const
  max_n = 10;
  max_m = 5; 
Type
  TMatrix = array[1..max_n, 1..max_m]  of integer;
Var
  Matrix : TMatrix;
  m,n    : word;
Begin
  n:=0;
  m:=0;
  repeat
    ClrScr;
    write('Введите размеры матрицы n, m');
    readln(n,m)
  until (n>0 and n <= max_n) and (m>0 and m <= max_m);
  { Здесь осуществляется ввод матрицы }
            . . .
  { Здесь осуществляется обработка матрицы }
            . . .
  { Здесь осуществляется вывод матрицы }
End.

{ Т.е. процедура должна быть описана так: }
  Procedure Do_Something(Var Matr: TMatrix; n,m,max_n: word); external;

{ А вызов, соответственно, делать так: }
  Do_Something(Matrix, n,m,max_n);

; Turbo Assembler example. Copyright (c) 1993 By Borland International, Inc.
;
; HEX.ASM
;
; Usage: Run tasm on this file and link with hex.pas

CODE      SEGMENT
          ASSUME cs:CODE,ds:NOTHING

; Parameters (+2 because of push bp)

byteCount EQU BYTE PTR  ss:[bp+6]  ; а это параметры
num       EQU DWORD PTR ss:[bp+8]       ; функции HexStr.

; Function result address (+2 because of push bp)

resultPtr EQU DWORD PTR ss:[bp+12]      ; это результат функции

HexStr    PROC FAR
          PUBLIC HexStr

          push bp
          mov bp,sp          ;get pointer into stack
          les di,resultPtr   ;get address of function result
          mov dx,ds          ;save Turbo's DS in DX
          lds si,num         ;get number address
          mov al,byteCount   ;how many bytes?
          xor ah,ah          ;make a word
          mov cx,ax          ;keep track of bytes in CX
          add si,ax          ;start from MS byte of number
          dec si
          shl ax,1           ;how many digits? (2/byte)
          cld                ;store # digits (going forward)

; Важно!!! Не забывайте записывать длину строки в нулевой байт!
          stosb              ;in destination string's length byte

HexLoop:
          std                ;scan number from MSB to LSB
          lodsb              ;get next byte
          mov ah,al          ;save it
          shr al,1           ;extract high nibble
          shr al,1
          shr al,1
          shr al,1
          add al,90h         ;special hex conversion sequence
          daa                ;using ADDs and DAA's
          adc al,40h
          daa                ;nibble now converted to ASCII
          cld                ;store ASCII going up
          stosb
          mov al,ah          ;repeat conversion for low nibble
          and al,0Fh
          add al,90h
          daa
          adc al,40h
          daa
          stosb
          loop HexLoop       ;keep going until done
          mov ds,dx          ;restore Turbo's DS
          pop bp
          ret 6              ;parameters take 6 bytes
HexStr    ENDP
CODE      ENDS
          END

{ Turbo Assembler example. Copyright (c) 1993 By Borland International, Inc. }

{ Use with hex.asm }

Program HexTest;
Var
  num : Word;

Function HexStr (Var num; byteCount : Byte) : string; far; external;

{$L HEX.OBJ}

Begin
  num := $face;
  Writeln('The Converted Hex String is"',HexStr(num,sizeof(num)),'"');
End.

; Turbo Assembler example. Copyright (c) 1993 By Borland International, Inc.
;
; ENVSTR.ASM - Example program to scan the DOS environment
;
; Usage: Run tasm on this file and link with envstr.pas

          .MODEL  large,PASCAL
; Эта директива создает сегменты по умолчанию и соответствующие им
; выражения ASSUME и GROUP. В кач-ве параметра указана модель памяти,
; полностью соответствующая Паскалю.
          .DATA
; А тут мы начали сегмент данных.
          EXTRN prefixSeg : WORD  ;gives location of PSP
; А тут одной строкой объявили адрес PSP.
          .CODE
; А вот и сегмент кода.
EnvString PROC FAR  EnvVar:DWORD  RETURNS EnvVal:DWORD
; Тут мы объявили дальнюю функцию с параметром EnvVar размером в 4 байта
; (сегм. + смещ.) и указали что EnvVal тогоже размера будет
; нашой переменной, куда мы запишем результат ;)
          PUBLIC  EnvString
; А это для того чтобы Паскаль смог "увидеть" нашу функцию.
; Это что-то типа объявления функций в интерфейсе модуля ;)
; И еще, как видите, в начале подпрограммы команды "push bp" и
; "mov bp,sp" писать не нужно. За вас это сделает компилятор ;)
          cld                     ;work upward
          mov     es,[prefixSeg]  ;look at PSP
          mov     es,es:[2Ch]     ;ES:DI points at environment
          xor     di,di           ;which is paragraph-aligned
          mov     bp,sp           ;find the parameter address
          lds     si,EnvVar       ;which is right above the return address
          ASSUME  ds:NOTHING
          lodsb              ;look at length
          or      al,al      ;is it zero?
          jz      RetNul     ;if so, return
          mov     ah,al      ;otherwise, save in AH
          mov     dx,si      ;DS:DX contains pointer to first parm character
          xor     al,al      ;make a zero
Compare:
          mov     ch,al      ;we want ch=0 for next count, if any
          mov     si,dx      ;get back pointer to string sought
          mov     cl,ah      ;get length
          mov     si,dx      ;get pointer to string sought
          repe    cmpsb      ;compare bytes
          jne     Skip       ;if compare fails, try next string
          cmp     byte PTR es:[di],'='
                             ;compare succeeded; is next char '='
          jne     NoEqual    ;if not, still no match
Found:
          mov     ax,es      ;make DS:SI point to string we found
          mov     ds,ax
          mov     si,di
          inc     si         ;get past the equal (=) sign
          les     bx,EnvVal  ;get address of function result
          mov     di,bx      ;put it in ES:DI
          inc     di         ;get past the length byte
          mov     cl,255     ;set up a maximum length
CopyLoop:
          lodsb              ;get a byte
          or      al,al      ;zero test
          jz      Done       ;if zero, we're done
          stosb              ;put it in the result
          loop    CopyLoop   ;move up to 255 bytes
Done:     not     cl         ;we've been decrementing CL from
                             ; 255 during save
          mov     es:[bx],cl           ;save the length
          mov     ax,@DATA
; А тут мы в АХ поместили сегмент данных ;)
          mov     ds,ax                ;restore DS
          ASSUME  ds:@DATA
          ret
; Как видите, тут ret без параметров ;)
; А знаете почему? А потому что компилятор сам сюда напишет все что
; нужно: восстановит ВР и напишет retf с нужным параметром в зависимости
; от входных параметров. В нашем случае выход будет таким:
; "pop bp" + "retf 4".
          ASSUME  ds:NOTHING
Skip:
          dec     di         ;check for null from this char on
NoEqual:
          mov     cx,7FFFh   ;search a long way if necessary
          sub     cx,di      ;environment never >32K
          jbe     RetNul     ;if we're past end, leave
          repne   scasb      ;look for the next null
          jcxz    RetNul               ;exit if not found
          cmp     byte PTR es:[di],al  ;second null in a row?
          jne     Compare              ;if not, try again
RetNul:
          les     di,EnvVal            ;get address of result
          stosb                        ;store a zero there
          mov     ax,@DATA
          mov     ds,ax                ;restore DS
          ASSUME  ds:@DATA
          ret
; Как видите, тут тоже ret без параметров(см. выше) ;)
EnvString ENDP
          END
; И еще, как вы заметили, ребята из Борланда не сильно беспокоятся о регистрах.
; Точнее беспокоятся только о DS, SS и SP, а о ВР заботится сам компилятор при
; входе и выходе из п/п (только при использовании ключевого слова PASCAL в
; объявлении п/п или при указании модели памяти!). Т.е. Все остальные регистры
; к моменту выхода из п/п могут иметь произвольные значения ;-). Исключение
; составляют только функции, которые возвращают результат в некоторых из
; регистров ЦП.

{ Turbo Assembler example. Copyright (c) 1993 By Borland International, Inc. }

{ Use with envstr.asm }

Program EnvTest;
{ program looks for environment strings }

Var
  EnvVariable : string;
  EnvValue : string;

Function EnvString(s:string) : string; far; external;
{$L ENVSTR.OBJ}
Begin
  EnvVariable := 'PROMPT';
  EnvValue := EnvString(EnvVariable);
  if EnvValue='' then EnvValue := '*** not found ***';
  Writeln('Environment Variable:',EnvVariable,'Value:',EnvValue);
End.

     procedure proc_name(Var a: longint; b: integer; c: longint);

CODE      SEGMENT
PUBLIC    proc_name
ASSUME    CS:CODE
proc_name PROC      FAR
          PUBLIC  proc_name
          push bp ds ss sp
          mov  bp,sp
a         equ  [bp+12]    ;   Это
b         equ  [bp+10]    ;     параметры
c         equ  [bp+6]     ;       процедуры
 . . .
          pop  sp ss ds bp
          ret  10     ; 10 - кол-во переданных байт
proc_name ENDP
CODE      ENDS
          END

;     Процедуру можно было объявить и так:

proc_name PROC FAR PASCAL, a:dword,b:word,c:dword ; Это параметры
          PUBLIC  proc_name
          push ds ss sp
 . . .
          pop  sp ss ds
          ret ; без параметров
proc_name endp

;          или

          .MODEL  large,PASCAL
          .DATA
 . . .          
          .CODE
proc_name PROC FAR  a:dword,b:word,c:dword ; Это параметры процедуры
          PUBLIC  proc_name
          push ds ss sp
 . . .
          pop  sp ss ds
          ret ; без параметров
proc_name ENDP
          END

	b:=5;
	Include(X,b);

	old X		0000 0000
	or
	[3]		0001 0000
	=
	new X		0001 0000

	Y:=X+[2..4,7]

	X		0001 0000
	or
	[2..4,7]	0011 1001
	=
	Y		0011 1001

	X:=X*Y

	old X		0001 0000
	and
	Y		0011 1001
	=
	new X		0001 0000

	X:=X-[2..3];

	[2..3]		0011 0000
	not [2..3]	1100 1111

	old X		0001 0000
	*
	not [2..3]	1100 1111
	=
	new X		0000 0000

; File name: "Prime_m.asm"
; Работа с множествами (решето Эратосфена).
; Данный файл является asm модулем к программе "Prime_a.pas"
        .MODEL  large,PASCAL
        .DATA
n1       dw      ?
next     dw      2
BytesInSet dw    ?
        .CODE
PUBLIC CalcPrime
CalcPrime proc far
        push    bp
        mov     bp,sp
Set_Adr      equ [bp+8]
N    equ [bp+6]
        mov     si,Set_Adr   ; si - адрес исходного мн-ва

        mov     ax,N
        mov     dl,8
        div     dl
        sub     dl,ah
        add     N,dl
        dec     byte ptr N
        mov     dx,N         ; dx=N

        mov     cx,dx
        shr     cx,3
        inc     cx
        mov     BytesInSet,cx   ; BytesInSet=SizeOf(Set);

        mov     di,si
c:       mov     byte ptr [di],0 ; Set:=[];
        inc     di
        loop    c
        mov     byte ptr [si],2 ; Set:=[1]

        sub     sp,BytesInSet   ; Создадим вспомогательное мн-во в стеке
        mov     di,sp           ; di - адрес нового мн-ва
        push    di
        mov     cx,BytesInSet
c1:      mov     byte ptr [di],0FFh ; Set:=[0..N];
        inc     di
        loop    c1
        pop     di
        mov     byte ptr [di],11111100b    ; Set:=[2..N];
ccc:                      ; While Set <> []
        mov     al,0
        cld
        mov     cx,BytesInSet
        push    di si
        repe    scasb
        pop     si di
        je      m_end
        push    next
        pop     n1
m_wh:                     ; while n1 do begin<=N
        cmp     n1,dx
        ja      m_endd
        mov     ax,n1
        call    Excl
        mov     ax,next
        add     n1,ax
        jmp     m_wh
m_endd:                   ; end { while n1<=N }
        mov     ax,next
        call    Incl

m_rep:                    ; repeat
        inc     next
        mov     ax,next
        Call    In_s
        jnz     m_end_rep
        cmp     next,dx
        ja      m_end_rep
        jmp     m_rep

m_end_rep:                ; until (next in Set) or (next > N)

        jmp     ccc

m_end:
        add     sp,BytesInSet   ; Удалим вспомогательное мн-во в стеке
        pop     bp
        ret     6
CalcPrime endp
; - - - - - - - - - -
Incl    proc near
; Set:=set+[al]
        push    si bx cx
        xor     ah,ah
        mov     bx,ax
        shr     bx,3
        add     si,bx
        shl     bx,3
        sub     ax,bx
        mov     bx,1
        mov     cl,al
        shl     bx,cl
        or      [si],bx
        pop     cx bx si
        ret
Incl    endp
; - - - - - - - - - -
Excl    proc near
; Set:=set-[al]
        push    di bx cx
        xor     ah,ah
        mov     bx,ax
        shr     bx,3
        add     di,bx
        shl     bx,3
        sub     ax,bx
        mov     bx,1
        mov     cl,al
        shl     bx,cl
        not     bx
        and     [di],bx
        pop     cx bx di
        ret
Excl    endp
; - - - - - - - - - - - - -
In_s    proc near
; [al] in Set ?
        push    di bx cx
        xor     ah,ah
        mov     bx,ax
        shr     bx,3
        add     di,bx
        shl     bx,3
        sub     ax,bx
        mov     bx,1
        mov     cl,al
        shl     bx,cl
        and     bx,[di]
        pop     cx bx di
        ret
In_s    endp
        end

{
 File name: "Prime_a.pas"
 Работа с множествами (решето Эратосфена).
 Данный файл компилируется вместе с "Prime_m.obj"
}
Program Prime_a;
Const
  N=255;
Type
  SetOfNumb = set of 1..N;
Var
  i : word;
  PrimeSet   : SetOfNumb;
{$L prime_m.obj}
Procedure CalcPrime(Var SetOfNumb; n:word); far; external;
Begin
  CalcPrime(PrimeSet,N);
  for i:=1 to N do
    if i in PrimeSet then
      Write(i:8);
  WriteLn;
End.