Cap.

4 Informatică

1. Tipuri de limbaje de programare. Clasificare.

• Limbaje de nivel scăzut – de nivel înalt
• Limbaj de programare Pascal
2. Programele realizate pentru macheta funcţională

pg. 90
 Tipuri de limbaje de programare. Clasificare.

Un limbaj de programare este un sistem de convenţii adoptate pentru realizarea unei comunicări –
între programator şi calculator . Limbajele folosite pentru programarea unui calculator sunt extrem de
asemănătoare limbajelor naturale . Ele sunt compuse din :

- cuvinte (rezervate) ;
- punctuaţie ;
- propoziţii şi fraze ;
- reguli sintactice etc .
Aşa cum pentru însuşirea unei limbi străine trebuie învăţate cuvintele acesteia şi regulile cu care
pot fi manevrate tot aşa pentru însuşirea unui limbaj de programare trebuie studiate cuvintele şi
semnele care îl compun împreună cu regulile de manevrare a lor.
După metoda cu care este conceput ansamblu comunicării , limbajele pot fi clasificate în
mai multe moduri . În continuare voi enumera cele mai importante clase de limbaje , descriere ce
acoperă totalitatea limbajelor existente .

Limbaje de nivel scăzut – de nivel înalt

“ Nivelul “ unui limbaj este apreciat prin poziţia pe care o ocupă pe scara constituită de limbajul
recunoscut de microprocesor ( limbaj maşină ) şi limbajul natural al programatorului( limba română ,
limba engleză …).

Un limbaj de nivel scăzut este foarte apropiat de maşină , el manipulează cu elemente de nivel
hardware , fizic , cum ar fi : registru , microprocesor , locaţie de memorie , port de intrare / ieşire etc.
Un limbaj de nivel înalt sau foarte înalt manipulează cu concepte apropiate de limbajul natural ,
concepte de nivel logic , cum ar fi : colecţie de date , nume de operaţie ( sort , writeln , open ) ,
variabile , constante ( asemănătoare ca înţeles cu cele din matematică).

pg. 91
 Cu ajutorul unui limbaj de nivel înalt programatorul se face mult mai uşor înţeles de către
calculator . Uneori o singură limie de program scrisă cu un astfel de limbaj poate echivala cu sute de
linii de program scrise în limbaj maşină . Deci din punct de vedere al reducerii timpului de realizare a
unui program şi al siguranţei în funcţionare ( absenţa erorilor de programare ) este de preferat un limbaj
de nivel cât mai ridicat ( înalt sau foarte înalt ) .În schimb , pe măsură ce limbajul are un nivel mai
ridicat execuţia programului conceput cu ajutorul său va fi mai lentă , decât a unui program ce
realizează aceleaşi operaţii dar este scris în limbaj de asamblare .

O altă diferenţă esenţială între cele două tipuri de limbaje o reprezintă portabilitatea , adică
posibilitatea transferării programelor pe un alt tip de maşină decât cea pe care au fost construite . Din
acest punct de vedere limbajul de asamblare este neportabil deoarece el este specific
microprocesorului . Programele realizate pe un tip de maşină trebuie rescrise integral pentru noul tip de
maşină , folosind un nou set de instrucţiuni – care deobicei diferă foarte mult . Lucrurile stau altfel cu
programele concepute cu ajutorul unui limbaj de nivel înalt , deoarece acestea sunt detaşate de maşină .
Între un astfel de program şi calculator se interpune compilatorul ( sau interpretorul ) care rezolvă
corect transformarea fişierului-sursă în fişier-executabil .

Limbaj de programare Pascal

Apariţia limbajului Pascal este un rezultat al conceptelor dezvoltate ca urmare a crizei

programării ce caracterizează domeniul programării calculatoarelor la sfarşitul anilor ’60. În această
perioadă, răspândirea pe plan mondial a prelucrării automate a datelor a cunoscut o extindere
remarcabilă, trecându-se la abordarea şi rezolvarea unor probleme din ce în ce mai complexe.
Programele mari asociate acestor probleme s-au complicat în aşa măsură încât au devenit foarte greu
accesibile, chiar şi pentru autorii lor. Întelegerea, depanarea şi dezvoltarea unor astfel de programe
prezintă dificultăţi majore. Limitările limbajelor de programare cu largă utilizare în epoca (FORTRAN,
COBOL etc.), dublată de inexistenţa unor principii clare, care să impună o disciplină a programării, au
favorizat în mare măsura programarea empirică. Ca răspuns la cerinţa de elaborare a unei metodologii
generale de dezvoltare sistematică a programelor s-a cristalizat metoda proiectării şi programării
structurate.
Un program structurat este constituit din unităţi funcţionale bine conturate, ierarhizate conform
naturii intrinseci a problemei. În interiorul unor astfel de unităţi, structura se manifestă atât la nivelul
pg. 92
acţiunilor (instrucţiunilor), cât şi al datelor.
Programarea structurată este o metodă independentă de limbajul de programare, actionând la
nivelul stilului de lucru. Totuşi, practica a demonstrat că limbajul de programare poate înlesni în mod
hotărâtor realizarea desideratelor evidenţiate. Limbajul Pascal reprezintă un exemplu edificator în acest
sens. El a apărut într-o formă preliminară în 1968, autorul său fiind profesorul elveţian Niklaus Wirth.
Numele limbajului a fost ales ca un omagiu adus marelui matematician, fizician, filosof şi scriitor
francez Blaise Pascal (1623-1662), primul care, în 1642, a inventat o maşină de calcul. După o faza de
dezvoltare extensivă, un prim compilator devine operaţional în 1970, limbajul fiind publicat în 1971.
Interesul trezit de apariţia sa a condus la necesitatea unor consolidări ale limbajului, finalizate prin
publicarea în 1973 a unui raport revizuit, în care se realizează o definire a formei de referinţă numită
Pascal Standard, redactată ulterior conform normelor ISO şi devenită bază comună pentru diverse
implementări.
Limbajul Pascal include conceptele programării structurate în ambele laturi ale efortului de
abstractizare presupus de realizarea unui program - organizarea datelor şi conceperea acţiunilor. Printre
principalele caracteristici ale lui pot fi mentionate:
• Include o serie de instrucţiuni care reprezintă chiar structurile de control impuse de tehnica
programării structurate (IF-THEN-ELSE, CASE, REPEAT, WHILE, FOR).
• Are facilităţi puternice şi deosebit de flexibile pentru reprezentarea datelor. Noţiunea de tip de
date a fost extinsă dincolo de cercul restrâns al datelor întregi, reale, şiruri de caractere şi tablouri
(masive). S-au introdus structuri de date complexe, ca articolul (înregistrarea), mulţimea, fişierul şi
posibilităţi de a descrie altele noi, combinându-le pe cele existente. La acestea se adaugă facilitatea de a
defini şi manipula structuri dinamice (liste liniare, arbori etc.). În anumite implementări ale limbajului a
fost introdus tipul obiect, care permite reunirea în aceeaşi construcţie a datelor şi metodelor care le
prelucrează (proceduri şi funcţii), creând cadrul trecerii la programarea orientată pe obiect (POO).
• Oferă posibilităţi de modularizare a programelor, prin structurarea lor în module cărora le pot
fi asociate construcţii ale limbajului (proceduri şi funcţii).
• Fundamentează construcţiile pe conceptul de bloc, care permite, pe de o parte, definirea de
date proprii (variabile locale) şi, pe de altă parte, accesul la datele din blocurile de pe nivelurile
superioare (variabile globale).
• Posedă o bibliotecă bogată de funcţii şi proceduri standard, cu elemente specifice diverselor
implementări ale limbajului şi permite, totodată, construirea de biblioteci ale utilizatorului.
Aceste caracteristici au facut ca, deşi conceput iniţial pentru a servi ca suport de studiu al
pg. 93
programarii structurate, limbajul să fie folosit intens şi de către programatorii profesionişti. Ca efect, s-
a ajuns rapid la o creştere spectaculoasă a productivitaţii muncii de programare, ducând la răspândirea
utilizării limbajului.
Limbajul Pascal beneficiază de implementări pe toate tipurile de sisteme de calcul. Multe dintre
aceste implementări marchează şi dezvoltări ale limbajului însuşi, adică în raport cu care Pascal
Standard apare ca un subset. Dintre variantele utilizate de informaticienii români pot fi menţionate:
implementarea pe calculatoarele din generaţia a treia din familia FELIX, din 1978; Pascal Oregon
pentru minicalculatoarele din familiile Independent şi Coral; implementările realizate de firma Borland
International pentru microcalculatoarele IBM PC şi compatibile. Firma Borland a realizat, începând
cu 1983, medii integrate de dezvoltare (IDE - Integrated Development Environment) cu denumirile
generice Turbo Pascal, Borland Pascal şi Delphi. Turbo Pascal, ajuns la versiunea 7.0, a marcat
introducerea progresiva a unor noi facilităţi, dintre care cele mai semnificative sunt: · realizarea
segmentării programelor folosind tehnica overlay, începând cu versiunea 5.0 (1988); · introducerea
conceptelor POO, începând cu versiunea 5.5 (1989); · folosirea mouse-ului, ferestrelor de editare
multiple, asamblorului integrat şi sistemului Turbo Vision, pentru dezvoltarea de aplicaţii orientate
obiect, în versiunea 6.0 (1990).
Versiunile din categoria Turbo Pascal sunt destinate utilizării sub DOS. Pentru dezvoltarea de
aplicaţii Windows a fost lansată implementarea Borland Pascal 7.0 pentru Windows, cu posibilităţi
superioare de utilizare a POO. Ultima realizare a firmei Borland o reprezintă Delphi, care
implementează facilităţi de POO şi programare vizuală. Evoluţia acestei implementări a cunoscut, de
asemenea, două etape: pentru sisteme pe 16 biţi, specifice platformelor Windows 3.x, în versiunea
Delphi 1.0; pentru sisteme pe 32 de biţi (Windows 95, Windows NT), începând cu Delphi 2.0.
Dacă în cazul implementărilor pe 16 biţi apare limitarea importantă a dimensiunii segmentelor
de date şi de cod la 64 KB (spaţiul maxim de adrese care poate fi gestionat cu un cuvânt de 16 biţi),
trecerea la cod pe 32 de biţi face ca limitările să fie impuse numai de sistemul de operare (2 GB la
Windows 95).

Pentru a putea realiza o interfaţă între macheta funcţională si PC am conceput urmatorul

program realizat în Turbo Pascal.

program robo;

uses crt;

pg. 94
var c:char;

procedure sens1;

begin

clrscr;

gotoxy(2,2);write('SENS 1 = TASTA <A>');

gotoxy(2,3);write('SENS 2 = TASTA <D>');

gotoxy(2,4);write('S T O P= TASTA <S>');

gotoxy(2,5);write('E X I T= TASTA <Q>');

gotoxy(15,15);write('sens1');

port[$378]:=2;

end;

procedure sens2;

begin

clrscr;

gotoxy(2,2);write('SENS 1 = TASTA <A>');

gotoxy(2,3);write('SENS 2 = TASTA <D>');

gotoxy(2,4);write('S T O P= TASTA <S>');

gotoxy(2,5);write('E X I T= TASTA <Q>');

gotoxy(15,15);write('sens2');

port[$378]:=7;

end;

procedure stop;
pg. 95
begin

clrscr;

gotoxy(2,2);write('SENS 1 = TASTA <A>');

gotoxy(2,3);write('SENS 2 = TASTA <D>');

gotoxy(2,4);write('S T O P= TASTA <S>');

gotoxy(2,5);write('E X I T= TASTA <Q>');

textcolor(5);

gotoxy(15,15);write('S T O P');

textcolor(7);

port[$378]:=12;

end;

begin

clrscr;

gotoxy(2,2);write('SENS 1 = TASTA <A>');

gotoxy(2,3);write('SENS 2 = TASTA <D>');

gotoxy(2,4);write('S T O P= TASTA <S>');

gotoxy(2,5);write('E X I T= TASTA <Q>');

REPEAT

c:=readkey;

case c of

'a': sens1;

's': stop;
pg. 96
 'd': sens2;

end;

UNTIL c='q';

port[$378]:=12;

end.

Cu ajutorul programului realizat în Turbo Pascal PC trimite semnale digitale pe

microcontroller-ul PiC16F877 de pe placa electronică a machetei. Pic-ul preia semnalele digitale si le
prelucrează transmitând-ule mai departe către electronic de putere. Microcontroler-ul prelucrează
semnalele cu ajutorul unui program special realizat în mycropascal.

Programul realizat în mycropascal pentru microcontroller este următorul:

program microcontroler;

label et1, et2,et3;

var k:byte;

procedure mcc1_s;

begin

portc:=16;

end;

procedure mcc1_d;

begin

portc:=32;

end;

procedure mcc2_s;

begin
pg. 97
 portc:=64;

end;

procedure mcc2_d;

begin

portc:=128;

end;

begin

trisd:=255; // intrare interfata

trisc:=0; // port iesire comanda MPP

k:=0;

k:=portD;

et1:

portc:=0;

repeat

begin

k:=portD;

if k=1 then

begin

mcc1_s;

delay_ms(500);

end;

if k=2 then
pg. 98
 begin

mcc1_d;

delay_ms(500);

end;

if k=4 then

begin

mcc2_s;

delay_ms(500);

end;

if k=8 then

begin

mcc2_d;

delay_ms(500);

if k=5 then

begin

mcc2_s;

mcc1_s;

end;

if k=9 then

begin

mcc2_d;

mcc1_s;
pg. 99
 end;

if k=6 then

begin

mcc2_s;

mcc1_d;

end;

if k=10 then

begin

mcc2_d;

mcc1_d;

end;

end;

end;

until (1=0); end.

În urma compilării programului în assembly am obţinut următorul cod generat în

mikroVirtualMachine.

; Assembly code generated by mikroVirtualMachine - V. 5.0.0.3

; Date/Time: 25.06.2009 00:28:51

; Info: http://www.mikroe.com

; ADDRESS OPCODE ASM

; ----------------------------------------------

pg. 100
$0000 $2804 GOTO _main

$00BF $ _mcc1_s:

;dorulet.ppas,7 :: begin

;dorulet.ppas,8 :: portc:=16;

$00BF $3010 MOVLW 16

$00C0 $1303 BCF STATUS, RP1

$00C1 $1283 BCF STATUS, RP0

$00C2 $0087 MOVWF PORTC

$00C3 $ dorulet_L_0:

;dorulet.ppas,9 :: end;

$00C3 $0008 RETURN

$00BA $ _mcc1_d:

;dorulet.ppas,12 :: begin

;dorulet.ppas,13 :: portc:=32;

$00BA $3020 MOVLW 32

$00BB $1303 BCF STATUS, RP1

$00BC $1283 BCF STATUS, RP0

$00BD $0087 MOVWF PORTC

$00BE $ dorulet_L_1:

;dorulet.ppas,14 :: end;

$00BE $0008 RETURN

$00C9 $ _mcc2_s:
pg. 101
;dorulet.ppas,17 :: begin

;dorulet.ppas,18 :: portc:=64;

$00C9 $3040 MOVLW 64

$00CA $1303 BCF STATUS, RP1

$00CB $1283 BCF STATUS, RP0

$00CC $0087 MOVWF PORTC

$00CD $ dorulet_L_2:

;dorulet.ppas,19 :: end;

$00CD $0008 RETURN

$00C4 $ _mcc2_d:

;dorulet.ppas,22 :: begin

;dorulet.ppas,23 :: portc:=128;

$00C4 $3080 MOVLW 128

$00C5 $1303 BCF STATUS, RP1

$00C6 $1283 BCF STATUS, RP0

$00C7 $0087 MOVWF PORTC

$00C8 $ dorulet_L_3:

;dorulet.ppas,24 :: end;

$00C8 $0008 RETURN

$0004 $ _main:

;dorulet.ppas,26 :: begin

;dorulet.ppas,28 :: trisd:=255; // intrare interfata

pg. 102
$0004 $30FF MOVLW 255

$0005 $1303 BCF STATUS, RP1

$0006 $1683 BSF STATUS, RP0

$0007 $0088 MOVWF TRISD

;dorulet.ppas,29 :: trisc:=0; // port iesire comanda MPP

$0008 $0187 CLRF TRISC, 1

;dorulet.ppas,30 :: k:=0;

$0009 $1283 BCF STATUS, RP0

$000A $01A0 CLRF _k, 1

;dorulet.ppas,31 :: k:=portD;

$000B $0808 MOVF PORTD, 0

$000C $00A0 MOVWF _k

;dorulet.ppas,33 :: et1:

$000D $ _main_et1:

;dorulet.ppas,34 :: portc:=0;

$000D $0187 CLRF PORTC, 1

;dorulet.ppas,35 :: repeat

$000E $ dorulet_L_5:

;dorulet.ppas,37 :: k:=portD;

$000E $0808 MOVF PORTD, 0

$000F $00A0 MOVWF _k

;dorulet.ppas,39 :: if k=1 then

pg. 103
$0010 $0820 MOVF _k, 0

$0011 $3A01 XORLW 1

$0012 $1D03 BTFSSSTATUS, Z

$0013 $2834 GOTO dorulet_L_11

$0014 $ dorulet_L_10:

;dorulet.ppas,41 :: mcc1_s;

$0014 $20BF CALL _mcc1_s

;dorulet.ppas,42 :: delay_ms(500);

$0015 $3003 MOVLW 3

$0016 $00FC MOVWF STACK_12

$0017 $30FF MOVLW 255

$0018 $00FB MOVWF STACK_11

$0019 $30FF MOVLW 255

$001A $00FA MOVWF STACK_10

$001B $0BFC DECFSZ STACK_12, F

$001C $281E GOTO $+2

$001D $2825 GOTO $+8

$001E $0BFB DECFSZ STACK_11, F

$001F $2821 GOTO $+2

$0020 $2824 GOTO $+4

$0021 $0BFA DECFSZ STACK_10, F

$0022 $2821 GOTO $-1

pg. 104
$0023 $281E GOTO $-5

$0024 $281B GOTO $-9

$0025 $308C MOVLW 140

$0026 $00FB MOVWF STACK_11

$0027 $30FF MOVLW 255

$0028 $00FA MOVWF STACK_10

$0029 $0BFB DECFSZ STACK_11, F

$002A $282C GOTO $+2

$002B $282F GOTO $+4

$002C $0BFA DECFSZ STACK_10, F

$002D $282C GOTO $-1

$002E $2829 GOTO $-5

$002F $30A1 MOVLW 161

$0030 $00FA MOVWF STACK_10

$0031 $0BFA DECFSZ STACK_10, F

$0032 $2831 GOTO $-1

$0033 $0000 NOP

;dorulet.ppas,43 :: end;

$0034 $ dorulet_L_11:

$0034 $ dorulet_L_12:

;dorulet.ppas,45 :: if k=2 then

$0034 $0820 MOVF _k, 0

pg. 105
$0035 $3A02 XORLW 2

$0036 $1D03 BTFSSSTATUS, Z

$0037 $2858 GOTO dorulet_L_14

$0038 $ dorulet_L_13:

;dorulet.ppas,47 :: mcc1_d;

$0038 $20BA CALL _mcc1_d

;dorulet.ppas,48 :: delay_ms(500);

$0039 $3003 MOVLW 3

$003A $00FC MOVWF STACK_12

$003B $30FF MOVLW 255

$003C $00FB MOVWF STACK_11

$003D $30FF MOVLW 255

$003E $00FA MOVWF STACK_10

$003F $0BFC DECFSZ STACK_12, F

$0040 $2842 GOTO $+2

$0041 $2849 GOTO $+8

$0042 $0BFB DECFSZ STACK_11, F

$0043 $2845 GOTO $+2

$0044 $2848 GOTO $+4

$0045 $0BFA DECFSZ STACK_10, F

$0046 $2845 GOTO $-1

$0047 $2842 GOTO $-5

pg. 106
$0048 $283F GOTO $-9

$0049 $308C MOVLW 140

$004A $00FB MOVWF STACK_11

$004B $30FF MOVLW 255

$004C $00FA MOVWF STACK_10

$004D $0BFB DECFSZ STACK_11, F

$004E $2850 GOTO $+2

$004F $2853 GOTO $+4

$0050 $0BFA DECFSZ STACK_10, F

$0051 $2850 GOTO $-1

$0052 $284D GOTO $-5

$0053 $30A1 MOVLW 161

$0054 $00FA MOVWF STACK_10

$0055 $0BFA DECFSZ STACK_10, F

$0056 $2855 GOTO $-1

$0057 $0000 NOP

;dorulet.ppas,49 :: end;

$0058 $ dorulet_L_14:

$0058 $ dorulet_L_15:

;dorulet.ppas,51 :: if k=4 then

$0058 $0820 MOVF _k, 0

$0059 $3A04 XORLW 4

pg. 107
$005A $1D03 BTFSSSTATUS, Z

$005B $287C GOTO dorulet_L_17

$005C $ dorulet_L_16:

;dorulet.ppas,53 :: mcc2_s;

$005C $20C9 CALL _mcc2_s

;dorulet.ppas,54 :: delay_ms(500);

$005D $3003 MOVLW 3

$005E $00FC MOVWF STACK_12

$005F $30FF MOVLW 255

$0060 $00FB MOVWF STACK_11

$0061 $30FF MOVLW 255

$0062 $00FA MOVWF STACK_10

$0063 $0BFC DECFSZ STACK_12, F

$0064 $2866 GOTO $+2

$0065 $286D GOTO $+8

$0066 $0BFB DECFSZ STACK_11, F

$0067 $2869 GOTO $+2

$0068 $286C GOTO $+4

$0069 $0BFA DECFSZ STACK_10, F

$006A $2869 GOTO $-1

$006B $2866 GOTO $-5

$006C $2863 GOTO $-9

pg. 108
$006D $308C MOVLW 140

$006E $00FB MOVWF STACK_11

$006F $30FF MOVLW 255

$0070 $00FA MOVWF STACK_10

$0071 $0BFB DECFSZ STACK_11, F

$0072 $2874 GOTO $+2

$0073 $2877 GOTO $+4

$0074 $0BFA DECFSZ STACK_10, F

$0075 $2874 GOTO $-1

$0076 $2871 GOTO $-5

$0077 $30A1 MOVLW 161

$0078 $00FA MOVWF STACK_10

$0079 $0BFA DECFSZ STACK_10, F

$007A $2879 GOTO $-1

$007B $0000 NOP

;dorulet.ppas,55 :: end;

$007C $ dorulet_L_17:

$007C $ dorulet_L_18:

;dorulet.ppas,56 :: if k=8 then

$007C $0820 MOVF _k, 0

$007D $3A08 XORLW 8

$007E $1D03 BTFSSSTATUS, Z

pg. 109
$007F $28B8 GOTO dorulet_L_20

$0080 $ dorulet_L_19:

;dorulet.ppas,58 :: mcc2_d;

$0080 $20C4 CALL _mcc2_d

;dorulet.ppas,59 :: delay_ms(500);

$0081 $3003 MOVLW 3

$0082 $00FC MOVWF STACK_12

$0083 $30FF MOVLW 255

$0084 $00FB MOVWF STACK_11

$0085 $30FF MOVLW 255

$0086 $00FA MOVWF STACK_10

$0087 $0BFC DECFSZ STACK_12, F

$0088 $288A GOTO $+2

$0089 $2891 GOTO $+8

$008A $0BFB DECFSZ STACK_11, F

$008B $288D GOTO $+2

$008C $2890 GOTO $+4

$008D $0BFA DECFSZ STACK_10, F

$008E $288D GOTO $-1

$008F $288A GOTO $-5

$0090 $2887 GOTO $-9

$0091 $308C MOVLW 140

pg. 110
$0092 $00FB MOVWF STACK_11

$0093 $30FF MOVLW 255

$0094 $00FA MOVWF STACK_10

$0095 $0BFB DECFSZ STACK_11, F

$0096 $2898 GOTO $+2

$0097 $289B GOTO $+4

$0098 $0BFA DECFSZ STACK_10, F

$0099 $2898 GOTO $-1

$009A $2895 GOTO $-5

$009B $30A1 MOVLW 161

$009C $00FA MOVWF STACK_10

$009D $0BFA DECFSZ STACK_10, F

$009E $289D GOTO $-1

$009F $0000 NOP

;dorulet.ppas,61 :: if k=5 then

$00A0 $0820 MOVF _k, 0

$00A1 $3A05 XORLW 5

$00A2 $1D03 BTFSSSTATUS, Z

$00A3 $28A6 GOTO dorulet_L_23

$00A4 $ dorulet_L_22:

;dorulet.ppas,63 :: mcc2_s;

$00A4 $20C9 CALL _mcc2_s

pg. 111
;dorulet.ppas,64 :: mcc1_s;

$00A5 $20BF CALL _mcc1_s

;dorulet.ppas,65 :: end;

$00A6 $ dorulet_L_23:

$00A6 $ dorulet_L_24:

;dorulet.ppas,67 :: if k=9 then

$00A6 $0820 MOVF _k, 0

$00A7 $3A09 XORLW 9

$00A8 $1D03 BTFSSSTATUS, Z

$00A9 $28AC GOTO dorulet_L_26

$00AA$ dorulet_L_25:

;dorulet.ppas,69 :: mcc2_d;

$00AA$20C4 CALL _mcc2_d

;dorulet.ppas,70 :: mcc1_s;

$00AB $20BF CALL _mcc1_s

;dorulet.ppas,71 :: end;

$00AC $ dorulet_L_26:

$00AC $ dorulet_L_27:

;dorulet.ppas,72 :: if k=6 then

$00AC $0820 MOVF _k, 0

$00AD$3A06 XORLW 6

$00AE $1D03 BTFSSSTATUS, Z

pg. 112
$00AF $28B2 GOTO dorulet_L_29

$00B0 $ dorulet_L_28:

;dorulet.ppas,74 :: mcc2_s;

$00B0 $20C9 CALL _mcc2_s

;dorulet.ppas,75 :: mcc1_d;

$00B1 $20BA CALL _mcc1_d

;dorulet.ppas,76 :: end;

$00B2 $ dorulet_L_29:

$00B2 $ dorulet_L_30:

;dorulet.ppas,77 :: if k=10 then

$00B2 $0820 MOVF _k, 0

$00B3 $3A0A XORLW 10

$00B4 $1D03 BTFSSSTATUS, Z

$00B5 $28B8 GOTO dorulet_L_32

$00B6 $ dorulet_L_31:

;dorulet.ppas,79 :: mcc2_d;

$00B6 $20C4 CALL _mcc2_d

;dorulet.ppas,80 :: mcc1_d;

$00B7 $20BA CALL _mcc1_d

;dorulet.ppas,81 :: end;

$00B8 $ dorulet_L_32:

$00B8 $ dorulet_L_33:
pg. 113
;dorulet.ppas,82 :: end;

$00B8 $ dorulet_L_20:

$00B8 $ dorulet_L_21:

;dorulet.ppas,84 :: until (1=0);

$00B8 $ dorulet_L_6:

$00B8 $ dorulet_L_8:

$00B8 $280E GOTO dorulet_L_5

;dorulet.ppas,85 :: end.

$00B9 $28B9 GOTO $

pg. 114