skripta-spa1.tex

   1 % skripta-spa1.tex
   2 % Skripta za predmet Strukture podataka i algoritmi 1, DMI, PMF, NS
   3
   4 \documentclass[a4paper,twoside]{article}
   5 \usepackage[T1]{fontenc}
   6 \usepackage[utf8]{inputenc}%definišemo da je ulaz utf-8 fajl
   7
   8 % osnovne informacije koje ce se prikazati na naslovnoj strani,
   9 % kao i u informacijama u generisanom pdfu
  10 \newcommand{\autor}{Vladimir Kurbalija, Milos Radovanovic, Doni Pracner}
  11 \newcommand{\naslov}{Skripta za vezbe iz predmeta "Strukture podataka
  12   i algoritmi 1"}
  13 \newcommand{\datum}{Februar 2013, Novi Sad}
  14 \newcommand{\verzija}{ver 13a-jk}
  15 %jk=jedna kolona, dk=dve kolone
  16
  17 \newcommand{\mainstart}{
  18 %\begin{multicols}{2}
  19 }
  20
  21 \newcommand{\mainend}{
  22 %\end{multicols}
  23 }
  24
  25 \usepackage[serbian]{babel}
  26 \usepackage{fancyhdr}
  27 \pagestyle{fancy}
  28
  29 \title{\naslov -- \verzija}
  30 \author{\autor}
  31 \date{\datum}
  32
  33 %change the default font
  34 \usepackage{lmodern}
  35 \usepackage{beramono}
  36 \renewcommand{\familydefault}{\sfdefault}
  37
  38 \usepackage{pifont}
  39
  40 %podesavanja outputa za pdf verzije
  41 \usepackage[bookmarks,pdffitwindow=false,unicode=true,%
  42 pdftitle={\naslov -- \verzija},%
  43 pdfauthor={\autor}%
  44 ]{hyperref}
  45
  46 \usepackage{graphicx}
  47 \usepackage{listings}
  48 \usepackage{amsthm}
  49 \usepackage{amsmath}
  50 \usepackage{latexsym}
  51 \usepackage{multicol}
  52
  53 %margine
  54 %experiment
  55 %\usepackage[top=2.5cm, bottom=1.5cm, left=3cm, right=2cm]{geometry}
  56 %staro:
  57 \usepackage[top=1.5cm, bottom=1cm, left=2cm, right=1cm]{geometry}
  58
  59 \begin{document}
  60
  61 %customize the itemize environments
  62
  63 \let\olditemize=\itemize
  64 \def\itemize{
  65 \olditemize
  66   \setlength{\itemsep}{1pt}
  67   \setlength{\parskip}{0pt}
  68   \setlength{\parsep}{0pt}
  69   \setlength{\topsep}{-1cm}
  70   \setlength{\partopsep}{1pt}
  71 }
  72
  73 %% ovi redovi daju header i footer
  74
  75 \renewcommand{\sectionmark}[1]{\markright{\thesection\ #1}}
  76 \fancyhf{} % delete current setting for header and footer
  77 %\fancyfoot[C]{\thepage}
  78 \fancyhead[LO]{\bfseries\rightmark}
  79 \fancyhead[RO]{\thepage}
  80 \fancyhead[RE]{Strukture podataka i algoritmi 1 -- skripta}
  81 \fancyhead[LE]{\thepage}
  82 \renewcommand{\headrulewidth}{0.5pt}
  83 \renewcommand{\headwidth}{\textwidth}
  84 %\renewcommand{\footrulewidth}{0.5pt}
  85 %\addtolength{\headheight}{0.5pt} % make space for the rule
  86 \fancypagestyle{plain}{%
  87 \fancyhead{} % get rid of headers on plain pages
  88 \fancyfoot{}
  89 \renewcommand{\headrulewidth}{0pt} % and the line
  90 \renewcommand{\footrulewidth}{0pt} % and the line
  91 }
  92 \renewcommand{\headheight}{15pt}
  93
  94 %promene u marginama:
  95 %\setlength{\marginparwidth}{32pt}
  96 %\setlength{\textwidth}{620pt}
  97 %\setlength{\textheight}{620pt}
  98
  99
 100 %% specijalni blokovi koji služe kao podsetnici u radu ili napomene
 101 \newcommand{\skica}[1]{
 102     \noindent \framebox{\parbox[c]{0.9\textwidth}{  {\small** \textit{#1}  }}
 103     \newline }
 104 }
 105
 106 \newcommand{\skicas}[1]{
 107     \framebox{* \textit{#1} *}
 108 }
 109
 110 %boldovane skice visokog prioriteta
 111 \newcommand{\skicab}[1]{
 112   \noindent \framebox{\parbox[c]{0.9\textwidth}{ {\small***
 113         \textbf{#1} }} \newline } }
 114
 115 \newcommand{\kod}[1]{{\small\texttt{#1}}}
 116
 117 % ako je sledeci red odkomentarisan nista od skica nece biti ispisano
 118 % u finalni dokument
 119
 120 % \renewcommand{\skica}[1]{}
 121
 122 % title u skladu sa uobičajenim na Departmanu
 123 \newcommand{\makemytitle}{
 124   \begin{center}
 125         \makebox{%
 126         \includegraphics[width=2cm]{grbPMF}
 127         \parbox[b]{65ex}{\centering
 128                 Univerzitet u Novom Sadu\\
 129                 Prirodno-matematički fakultet\\
 130                 Departman za matematiku i informatiku}
 131         \includegraphics[width=2cm]{grbUNS}
 132         }
 133         \vspace{10ex}
 134
 135         \parbox[b]{\textwidth}{{\Large {\bf
 136               Vladimir Kurbalija, \href{mailto:kurba@dmi.rs}{kurba@dmi.rs}\\
 137               Miloš Radovanović, \href{mailto:radacha@dmi.rs}{radacha@dmi.rs}\\
 138               Doni Pracner, \href{mailto:doni.pracner@dmi.rs}{doni.pracner@dmi.rs}}}}
 139         \vspace{5ex}
 140
 141         {\Large {\bf Skripta za vežbe iz predmeta }}
 142
 143         {\Huge {\bf
 144             \setlength{\baselineskip}{1.5\baselineskip}Strukture
 145               podataka i algoritmi 1}}
 146
 147         \vspace{5ex}
 148         %\vfill
 149
 150         \verzija \ -- \datum
 151
 152         \end{center}
 153         \thispagestyle{plain}
 154 %       \newpage
 155 }
 156
 157 \makemytitle
 158
 159 % theorems, definition etc.
 160 %''''''''''''''''''''''''''
 161
 162 \theoremstyle{definition}
 163 \newtheorem{def1}{Definicija}
 164 \theoremstyle{plain}
 165 \newtheorem{theo}{Teorema}
 166 \newtheorem{lema}{Lema}
 167
 168 \lstloadlanguages{Modula-2}
 169
 170 \lstset{
 171         basicstyle=\footnotesize\ttfamily,
 172         showstringspaces=false,
 173         breaklines=true
 174 }
 175
 176 \lstdefinestyle{codeblock}{
 177         basicstyle=\footnotesize\ttfamily,
 178         keywordstyle=\textbf,
 179         columns=[l]fixed,
 180         breakatwhitespace=true,
 181 %        prebreak=\P,
 182 %        postbreak=\ding{229}\space,
 183         language=Modula-2
 184 }
 185
 186 \lstdefinestyle{numcodeblock}{
 187   style=codeblock,
 188   numbers=left
 189 }
 190
 191 \lstnewenvironment{codeblock}{\lstset{style=codeblock}}{}
 192
 193
 194 % ----------------==================--------------------------------------
 195 %                 Pravi pocetak rada
 196
 197
 198 Programi u ovoj skripti su testirani sa kompajlerom 'Native XDS Modula
 199 2' sa instaliranim dodatnim paketom TSCP (Top Speed Compatibility
 200 Pack), potrebnim za neke od modula koji se ne nalaze u ISO standardu
 201 Module 2.
 202
 203 \tableofcontents
 204
 205 \newpage
 206
 207 \mainstart
 208
 209 \section{Ilustracija efikasnosti algoritma}
 210
 211 \subsection{Zadatak: Pronaći sve pitagorine
 212 trojke do zadate granice}
 213
 214
 215 \begin{lstlisting}[style=codeblock]
 216 MODULE Trojke1;
 217 (* Pitagorine trojke koriscenjem "Brute-force" *)
 218 FROM InOut IMPORT WriteString, WriteLn, WriteCard;
 219 CONST
 220   Gr = 100;
 221 VAR
 222   a, b, c : [1 .. Gr];
 223 BEGIN
 224   FOR a := 1 TO Gr DO
 225     FOR b := 1 TO Gr DO
 226       FOR c := 1 TO Gr DO
 227         IF a*a + b*b = c*c THEN
 228           WriteLn;
 229           WriteString('a = ');
 230           WriteCard(a,2);
 231           WriteString(', b = ');
 232           WriteCard(b,2);
 233           WriteString(', c = ');
 234           WriteCard(c,2)
 235         END
 236       END
 237     END
 238   END
 239 END Trojke1.
 240 \end{lstlisting}
 241
 242 \begin{codeblock}
 243 MODULE Trojke2;
 244 (*Pitagorine trojke koriscenjem zaokrugljivanja*)
 245 FROM InOut IMPORT WriteString, WriteLn, WriteCard;
 246 FROM MathLib0 IMPORT sqrt;
 247 CONST
 248   Gr = 100;
 249 VAR
 250   a, b, c : CARDINAL;
 251   creal : REAL;
 252 BEGIN
 253   FOR a := 1 TO Gr DO
 254     FOR b := 1 TO Gr DO
 255       creal := FLOAT(a*a) + FLOAT(b*b);
 256       creal := sqrt(creal);
 257       c := TRUNC(creal);
 258       IF creal = FLOAT(c) THEN
 259         WriteLn;
 260         WriteString(' a = ');
 261         WriteCard(a,2);
 262         WriteString(', b = ');
 263         WriteCard(b,2);
 264         WriteString(', c = ');
 265         WriteCard(c,2)
 266       END
 267     END
 268   END
 269 END Trojke2.
 270 \end{codeblock}
 271
 272 \begin{codeblock}
 273 MODULE Trojke3;
 274 (* Pitagorine trojke koriscenjem teoreme *)
 275 FROM InOut IMPORT WriteString, WriteLn, WriteCard;
 276 CONST
 277   Gr = 10;
 278 VAR
 279   a, b, c, m, n : CARDINAL;
 280 BEGIN
 281   FOR m := 1 TO Gr DO
 282     FOR n := 1 TO m-1 DO
 283       a := 2*m*n;
 284       b := m*m - n*n;
 285       c := m*m + n*n;
 286       WriteLn;
 287       WriteString('a = ');
 288       WriteCard(a,2);
 289       WriteString(', b = ');
 290       WriteCard(b,2);
 291       WriteString(', c = ');
 292       WriteCard(c,2)
 293     END
 294   END
 295 END Trojke3.
 296 \end{codeblock}
 297
 298 \begin{codeblock}
 299 MODULE Trojke4;
 300 (* Pitagorine trojke kod kojih je razlika
 301    izmedju katete i hipotenuze tacno 1 *)
 302 FROM InOut IMPORT WriteString, WriteLn, WriteCard;
 303 CONST
 304   Gr = 10;
 305 VAR
 306   a, b, c, m, n : CARDINAL;
 307 BEGIN
 308   FOR m := 2 TO Gr DO
 309     n := m - 1;
 310     a := 2*m*n;
 311     b := m*m - n*n;
 312     c := m*m + n*n;
 313     WriteLn;
 314     WriteString('a = ');
 315     WriteCard(a,2);
 316     WriteString(', b = ');
 317     WriteCard(b,2);
 318     WriteString(', c = ');
 319     WriteCard(c,2)
 320   END
 321 END Trojke4.
 322 \end{codeblock}
 323
 324 \begin{lstlisting}[style=codeblock]
 325 MODULE Trojke5;
 326 (* Pitagorine trojke kod kojih je razlika
 327    izmedju kateta jedan *)
 328 FROM InOut IMPORT WriteString, WriteLn, WriteCard;
 329 CONST
 330   Gr = 7;
 331 VAR
 332   a, b, c, m, n, w, i, temp : CARDINAL;
 333 BEGIN
 334   w := 1;
 335   n := 0;
 336   FOR i := 1 TO Gr DO
 337     m := n + w;
 338     a := 2*m*n;
 339     b := m*m - n*n;
 340     c := m*m + n*n;
 341     WriteLn;
 342     WriteString('a = ');
 343     WriteCard(a,2);
 344     WriteString(', b = ');
 345     WriteCard(b,2);
 346     WriteString(', c = ');
 347     WriteCard(c,2);
 348     temp := w;
 349     w := 3*w + 4*n;
 350     n := 2*temp + 3*n
 351   END
 352 END Trojke5.
 353 \end{lstlisting}
 354
 355
 356 \subsection[Zadatak: Maksimalna suma susednih elemenata u
 357 nizu]{Zadatak: Maksimalna suma proizvoljnog broja susednih elemenata u
 358   nizu celih brojeva}
 359
 360 \begin{lstlisting}[style=codeblock]
 361 MODULE MaxNiza1;
 362 (* Prvo resenje. Brute Force: O(n^3)  *)
 363 FROM InOut IMPORT WriteString,ReadInt,
 364            WriteInt,WriteCard,WriteLn;
 365 CONST
 366   N = 10;
 367 TYPE
 368   Interval = [1..N];
 369 VAR
 370   Max, Suma : INTEGER;
 371   d,g,i,Ood,Doo : Interval;
 372   X : ARRAY Interval OF INTEGER;
 373 BEGIN
 374   WriteString(' Unesite niz X ');
 375   WriteLn;
 376   FOR i := 1 TO N DO
 377     ReadInt(X[i]);
 378     WriteLn
 379   END;
 380   Max := 0;
 381   FOR d := 1 TO N DO
 382     FOR g := 1 TO N DO
 383       Suma := 0;
 384       FOR i := d TO g DO
 385         Suma := Suma + X[i]
 386       END;
 387       IF Suma > Max THEN
 388         Max := Suma;
 389         Ood := d;
 390         Doo := g
 391       END
 392     END
 393   END;
 394   WriteLn;
 395   WriteString(' Maksimum je ');
 396   WriteInt(Max,3);
 397   WriteString(' u intervalu od ');
 398   WriteCard(Ood,3);
 399   WriteString(' do ');
 400   WriteCard(Doo,3)
 401 END MaxNiza1.
 402
 403 MODULE MaxNiza2;
 404 (* Drugo resenje: O(n^2).
 405    Koristi se cinjenica da je suma X[d..g]
 406    izracunljiva iz X[d..g-1].  *)
 407 FROM InOut IMPORT WriteString,ReadInt,
 408            WriteInt,WriteCard,WriteLn;
 409 CONST
 410   N = 10;
 411 TYPE
 412   Interval = [1..N];
 413 VAR
 414   Max, Suma : INTEGER;
 415   d,g,i,Ood,Doo : Interval;
 416   X : ARRAY Interval OF INTEGER;
 417 BEGIN
 418   WriteString(' Unesite niz X ');
 419   WriteLn;
 420   FOR i := 1 TO N DO
 421     ReadInt(X[i]);
 422     WriteLn
 423   END;
 424   Max := 0;
 425   FOR d := 1 TO N DO
 426     Suma := 0;
 427     FOR g := d TO N DO
 428       Suma := Suma + X[g];
 429       IF Suma > Max THEN
 430         Max := Suma;
 431         Ood := d;
 432         Doo := g
 433       END
 434     END
 435   END;
 436   WriteLn;
 437   WriteString(' Maksimum je ');
 438   WriteInt(Max,3);
 439   WriteString(' u intervalu od ');
 440   WriteCard(Ood,3);
 441   WriteString(' do ');
 442   WriteCard(Doo,3)
 443 END MaxNiza2.
 444 \end{lstlisting}
 445
 446 \begin{codeblock}
 447 MODULE MaxNiza3;
 448 (* Trece resenje: O(n^2).
 449    Koristi pomocni niz u kome je na i-tom mestu
 450    suma podniza x[1..i] *)
 451 FROM InOut IMPORT WriteString,ReadInt,
 452            WriteInt,WriteCard,WriteLn;
 453 CONST
 454   N = 10;
 455 TYPE
 456   Interval = [1..N];
 457 VAR
 458   Max, Suma : INTEGER;
 459   d,g,i,Ood,Doo : Interval;
 460   X : ARRAY Interval OF INTEGER;
 461   Pom : ARRAY [0..N] OF INTEGER;
 462 BEGIN
 463   WriteString(' Unesite niz X ');
 464   WriteLn;
 465   FOR i := 1 TO N DO
 466     ReadInt(X[i]);
 467     WriteLn
 468   END;
 469   Pom[0] := 0;
 470   FOR i := 1 TO N DO
 471     Pom[i] := Pom[i-1] + X[i]
 472   END;
 473   Max := 0;
 474   FOR d := 1 TO N DO
 475     FOR g := d TO N DO
 476       Suma := Pom[g] - Pom[d-1];
 477       IF Suma > Max THEN
 478         Max := Suma;
 479         Ood := d;
 480         Doo := g
 481       END
 482     END
 483   END;
 484   WriteLn;
 485   WriteString(' Maksimum je ');
 486   WriteInt(Max,3);
 487   WriteString(' u intervalu od ');
 488   WriteCard(Ood,3);
 489   WriteString(' do ');
 490   WriteCard(Doo,3)
 491 END MaxNiza3.
 492 \end{codeblock}
 493
 494 \begin{codeblock}
 495 MODULE MaxNiza4;
 496 (* Cetvrto resenje. Najbolje moguce: O(n)  *)
 497 FROM InOut IMPORT WriteString,ReadInt,
 498            WriteInt,WriteCard,WriteLn;
 499 CONST
 500   N = 10;
 501 TYPE
 502   Interval = [1..N];
 503 VAR
 504   Max, MaxDovde : INTEGER;
 505   i,d,Ood,Doo : Interval;
 506   X : ARRAY Interval OF INTEGER;
 507 BEGIN
 508   WriteString(' Unesite niz X ');
 509   WriteLn;
 510   FOR i := 1 TO N DO
 511     ReadInt(X[i]);
 512     WriteLn
 513   END;
 514   Max := 0;
 515   MaxDovde := 0;
 516   FOR i := 1 TO N DO
 517     IF MaxDovde = 0 THEN
 518       d := i
 519     END;
 520     MaxDovde := MaxDovde + X[i];
 521     IF MaxDovde < 0 THEN
 522       MaxDovde := 0
 523     END;
 524     IF MaxDovde > Max THEN
 525       Ood := d;
 526       Doo := i;
 527       Max := MaxDovde
 528     END
 529   END;
 530   WriteLn;
 531   WriteString(' Maksimum je ');
 532   WriteInt(Max,3);
 533   WriteString(' u intervalu od ');
 534   WriteCard(Ood,3);
 535   WriteString(' do ');
 536   WriteCard(Doo,3)
 537 END MaxNiza4.
 538 \end{codeblock}
 539
 540 \section{Rad sa fajlovima}
 541
 542 \subsection{Modul FIO}
 543
 544 U ovom modulu je definisan tip \kod{File}, koji predstavlja jedan fajl
 545 sa kojim radimo.
 546
 547 \begin{quote}U primerima se pretpostavlja da je ``f'' tipa \kod{File}, ``str'' niz
 548 znakova, ``i'' tipa \kod{INTEGER}, ``c'' tipa \kod{CARDINAL} i ``ch''
 549 tipa \kod{CHAR}. Dodatna promenljiva ``n'' tipa \kod{INTEGER} služi za
 550 formatiranje slično kao u modulu \kod{InOut}.
 551 \end{quote}
 552
 553 Promenljiva tipa \kod{File} se mora vezati za neki fajl
 554 jednom od sledećih komandi:
 555 \begin{itemize}
 556 \item \kod{f := Open(str);} -- otvara se postojeci fajl za čitanje\\
 557 \item \kod{f := Create(str);} -- kreira se fajl za pisanje\\
 558 \item \kod{f := Append(str);} -- otvara se postojeći fajl za
 559   dopisivanje na kraj
 560 \end{itemize}
 561
 562 Po završetku rada fajl se mora zatvoriti, u našem primeru to bi bilo
 563 \kod{Close(f);}
 564
 565 Procedure za čitanje i pisanje su vrlo slične onima iz modula
 566 \kod{IO}, osim što imaju dodatni parametar „\kod{f}“ koji označava
 567 fajl sa kojim se radi.
 568 \begin{itemize}
 569 \item \kod{RdStr(f,str)} -- učitava ceo red u string str\\
 570 \item   \kod{RdItem(f,str)} -- učitava jednu reč u string str (učitava znakove iz fajla dok ne naiđe na separator)\\
 571 \item   \kod{i:= RdInt(f); c:= RdCard(f)} -- učitava broj, koji se dobija kao rezultat procedure\\
 572 \item   \kod{ch:= RdChar(f)} -- vraća jedan znak iz fajla
 573 \end{itemize}
 574
 575 Analogne su i procedure za pisanje različitih tipova u fajl:
 576 \begin{itemize}
 577 \item \kod{WrStr(f,str); WrInt(f,i,n);}\ \kod{WrCard(f,c,n);}\
 578   \kod{WrChar(f,ch);}
 579 \end{itemize}
 580
 581
 582 Prelom reda se eksplicitno upisuje u fajl komandom \kod{WrLn(f);}.
 583
 584 Da bi odredili da li smo stigli do kraja fajla možemo koristiti
 585 \kod{EOF}. U pitanju je logička promenljiva koja se uvozi iz modula
 586 FIO kao bilo kakva normalna komanda. Ona označava da li smo poslednjom
 587 operacijom čitanja stigli do kraja fajla.  Ne menja joj se vrednost
 588 pri operacijama otvaranja i zatvaranja fajlova, odnosno neće se pri
 589 tome resetovati na \kod{FALSE}, pa na ovo treba obratiti pažnju pri
 590 radu.
 591
 592 \subsection{Zadatak: ispis sadržaja fajla na ekran}
 593
 594 Potrebno je sve redove iz fajla učitati i ispisati ih na ekran.
 595
 596 \begin{lstlisting}[style=codeblock]
 597 MODULE ispis;
 598 FROM FIO IMPORT File, Open, Close, EOF, RdStr;
 599 FROM InOut IMPORT WriteString, WriteLn, ReadString;
 600
 601 PROCEDURE ispisF(ime: ARRAY OF CHAR);
 602 VAR
 603   f:File;
 604   s : ARRAY[1..100] OF CHAR;
 605 BEGIN
 606   f:=Open(ime);
 607   EOF := FALSE;
 608   WHILE NOT EOF DO
 609       RdStr(f,s);
 610       WriteString(s);
 611       WriteLn;
 612   END;
 613   Close(f);
 614 END ispisF;
 615
 616 VAR
 617   ime: ARRAY[1..100] OF CHAR;
 618 BEGIN
 619   WriteString("unesite ime fajla:");
 620   ReadString(ime);
 621   ispisF(ime);
 622 END ispis.
 623 \end{lstlisting}
 624
 625 \subsection{Zadatak: spisak studenata}
 626
 627 Napraviti program koji iz fajla učitava podatke o studentima, dodaje
 628 novog studenta u spisak i snima fajl.  U fajlu se u svakom redu nalazi
 629 podatak o jednom studentu, redom prezime, ime i godina rođenja,
 630 razdvojeni razmacima.
 631
 632 \begin{lstlisting}[style=codeblock]
 633 MODULE nizslog;
 634 FROM InOut IMPORT WriteString, WriteLn,
 635      WriteCard, ReadCard, ReadString;
 636 FROM FIO IMPORT File, Open, Create, Close, EOF,
 637     RdItem, RdCard, WrStr, WrCard, WrLn;
 638 FROM Str IMPORT Compare;
 639
 640 CONST
 641     MaxStud = 100;
 642 TYPE
 643     String = ARRAY[1..30] OF CHAR;
 644     Student = RECORD
 645         ime, prez: String;
 646         god: CARDINAL;
 647     END;
 648     Studenti = ARRAY[1..MaxStud] OF Student;
 649
 650 PROCEDURE UcitajF(fajl:String;
 651           VAR spisak: Studenti; VAR n:CARDINAL);
 652 VAR
 653     f:File;
 654 BEGIN
 655     n:=0;
 656     f:= Open(fajl);
 657     EOF := FALSE;
 658     WHILE NOT EOF DO
 659         INC(n);
 660         RdItem(f, spisak[n].prez);
 661         RdItem(f, spisak[n].ime);
 662         spisak[n].god := RdCard(f);
 663     END;
 664     Close(f);
 665 END UcitajF;
 666
 667 PROCEDURE Ispisi(spisak:Studenti; n:CARDINAL);
 668 VAR
 669     i: CARDINAL;
 670 BEGIN
 671     FOR i:=1 TO n DO
 672         WriteString(spisak[i].prez);
 673         WriteString(" ");
 674         WriteString(spisak[i].ime);
 675         WriteString(" ");
 676         WriteCard(spisak[i].god,1);
 677         WriteLn;
 678     END;
 679 END Ispisi;
 680
 681 PROCEDURE IspisiF(fajl:String;
 682           spisak:Studenti; n:CARDINAL);
 683 VAR
 684     f:File;
 685     i: CARDINAL;
 686 BEGIN
 687     IF (n>0) AND (n<=MaxStud) THEN
 688         f:=Create(fajl);
 689         (* pravimo takav fajl da ne
 690            postoji zadnji prazan red *)
 691         FOR i:=1 TO n-1 DO
 692             WrStr(f,spisak[i].prez);
 693             WrStr(f," ");
 694             WrStr(f,spisak[i].ime);
 695             WrStr(f," ");
 696             WrCard(f,spisak[i].god,1);
 697             WrLn(f);
 698         END;
 699         WrStr(f,spisak[n].prez);
 700         WrStr(f," ");
 701         WrStr(f,spisak[n].ime);
 702         WrStr(f," ");
 703         WrCard(f,spisak[n].god,1);
 704         Close(f);
 705     END;
 706 END IspisiF;
 707
 708 PROCEDURE NoviStudent(VAR spisak:Studenti;
 709                       VAR n:CARDINAL);
 710 VAR
 711     stud,temp:Student;
 712     i:CARDINAL;
 713     dodaj:BOOLEAN;
 714 BEGIN
 715     IF n<MaxStud THEN
 716         WriteString("Prezime novog studenta?");
 717         ReadString(stud.prez);
 718         WriteString("Ime novog studenta?");
 719         ReadString(stud.ime);
 720         WriteString("Godina rodjenja");
 721         WriteString("novog studenta?");
 722         ReadCard(stud.god);
 723         (* proverimo da li vec postoji *)
 724         i:=1;
 725         dodaj := TRUE;
 726         WHILE (i<=n) AND dodaj DO
 727             temp := spisak[i];
 728             IF (temp.god = stud.god) &
 729               (Compare(temp.prez,stud.prez)=0) &
 730               (Compare(temp.ime,stud.ime)=0) THEN
 731                 dodaj:=FALSE;
 732             END;
 733             INC(i);
 734         END;
 735         IF dodaj THEN
 736             INC(n);
 737             spisak[n]:=stud;
 738         ELSE
 739             WriteString("podaci vec postoje!");
 740         END;
 741     ELSE
 742         WriteString("popunjen kapacitet!");
 743     END;
 744 END NoviStudent;
 745
 746 VAR
 747     spisak : Studenti;
 748     fajl:String;
 749     n:CARDINAL;
 750 BEGIN
 751     fajl:="studenti.txt";
 752     UcitajF(fajl, spisak, n);
 753     Ispisi(spisak, n);
 754     NoviStudent(spisak,n);
 755     IspisiF(fajl, spisak, n);
 756 END nizslog.
 757 \end{lstlisting}
 758
 759 \section{Liste i pokazivači}
 760
 761 Za rad sa pokazivačima je potrebno iz modula \kod{Storage} uvesti procedure
 762 \kod{ALLOCATE} i \kod{DEALLOCATE}. U kodu se tada mogu koristiti i njihovi
 763 skraćeni oblici \kod{NEW} i \kod{DISPOSE}.
 764
 765 \subsection{Zadatak: Formiranje, štampanje i brisanje listi}
 766
 767
 768 \begin{lstlisting}[style=codeblock]
 769 MODULE liste;
 770 FROM InOut IMPORT WriteString, WriteLn, WriteInt,
 771         ReadInt, ReadCard;
 772 FROM Storage IMPORT ALLOCATE, DEALLOCATE;
 773 TYPE
 774   brojevi = POINTER TO brojSlog;
 775   brojSlog = RECORD
 776       info:INTEGER;
 777       veza:brojevi;
 778   END;
 779 VAR
 780   n,i:CARDINAL;
 781   lista : brojevi;
 782   br:INTEGER;
 783
 784 PROCEDURE DodajPoc(VAR lista:brojevi; br:INTEGER);
 785 (* dodaje broj br na pocetak liste *)
 786 VAR
 787   temp:brojevi;
 788 BEGIN
 789   NEW(temp);
 790   temp^.info := br;
 791   temp^.veza := lista;
 792   lista := temp;
 793 END DodajPoc;
 794
 795 PROCEDURE Stampaj(lista:brojevi);
 796 VAR
 797   temp:brojevi;
 798 BEGIN
 799   temp:=lista;
 800   WHILE temp # NIL DO
 801       WriteInt(temp^.info,0);
 802       WriteLn;
 803       temp := temp^.veza;
 804   END;
 805 END Stampaj;
 806
 807 PROCEDURE Unisti(VAR lista:brojevi);
 808 VAR
 809   temp:brojevi;
 810 BEGIN
 811   temp:=lista;
 812   WHILE temp # NIL DO
 813         lista:=lista^.veza;
 814         DISPOSE(temp);
 815         temp:=lista;
 816   END;
 817 END Unisti;
 818
 819 BEGIN
 820   lista := NIL;
 821   WriteString('unesite n (broj brojeva): ');
 822   ReadCard(n);
 823   WriteString('unesite brojeve: ');
 824   WriteLn;
 825   FOR i:= 1 TO n DO
 826       ReadInt(br);
 827       DodajPoc(lista,br);
 828   END;
 829   WriteString('sadrzaj liste:');
 830   WriteLn;
 831   Stampaj(lista);
 832   Unisti(lista);
 833   WriteString('memorija je oslobodjena');
 834   WriteLn;
 835 END liste.
 836 \end{lstlisting}
 837
 838 Alternativno je poziv \kod{DodajPoc} moguće zameniti pozivom jedne od
 839 sledeće dve procedure čime se dobija dodavanje elementa na kraj liste,
 840 ili kreiranje sortirane liste:
 841
 842 \begin{lstlisting}[style=codeblock]
 843 PROCEDURE DodajKraj(VAR lista:brojevi; br:INTEGER);
 844 (* dodaje element na kraj liste *)
 845 VAR
 846   tekuci, temp :brojevi;
 847 BEGIN
 848   NEW(temp);
 849   temp^.info := br;
 850   temp^.veza := NIL;
 851   IF lista = NIL THEN
 852      (* prazna lista *)
 853      lista:=temp;
 854   ELSE
 855      tekuci := lista;
 856      WHILE tekuci^.veza#NIL DO
 857         tekuci:=tekuci^.veza;
 858      END;
 859      tekuci^.veza := temp;
 860   END;
 861 END DodajKraj;
 862
 863 PROCEDURE DodajSort(VAR lista:brojevi; br:CARDINAL);
 864 (* dodaje broj tako da lista ostane sortirana
 865    (podrazumeva se da je vec sortirana) *)
 866 VAR
 867   temp, tekuci : brojevi;
 868 BEGIN
 869   NEW(temp);
 870   temp^.info:=br;
 871   temp^.veza:=NIL;
 872   IF (lista = NIL) OR (lista^.info>=br) THEN
 873   (*prazna lista ili na pocetak*)
 874     temp^.veza:=lista;
 875     lista := temp;
 876   ELSE
 877   (*negde u listi*)
 878     tekuci:= lista;
 879     WHILE (tekuci^.veza # NIL) AND
 880           (tekuci^.veza^.info<=br) DO
 881       tekuci:=tekuci^.veza;
 882     END;
 883     temp^.veza := tekuci^.veza;
 884     tekuci^.veza:=temp;
 885   END;
 886 END DodajSort;
 887 \end{lstlisting}
 888
 889 \subsection{Zadatak: Prikaz osnovih operacija nad listama}
 890
 891 \begin{lstlisting}[style=codeblock]
 892 MODULE liste2;
 893 FROM InOut IMPORT WriteString, WriteLn,
 894            WriteCard, ReadCard;
 895 FROM IO IMPORT RdKey;
 896 FROM Storage IMPORT ALLOCATE, DEALLOCATE;
 897 TYPE
 898   skupZn = SET OF CHAR;
 899   brojevi = POINTER TO brojSlog;
 900   brojSlog = RECORD
 901       info:CARDINAL;
 902       veza:brojevi;
 903   END;
 904 VAR
 905   lista : brojevi;
 906   menu,prazno:CHAR;
 907
 908 PROCEDURE DodajPoc(VAR lista:brojevi; br:INTEGER);
 909 (* dodaje broj pom na pocetak liste *)
 910 VAR
 911   temp:brojevi;
 912 BEGIN
 913   (* kreiramo novi element *)
 914   NEW(temp);
 915   temp^.info := br;
 916   (* treba da pokazuje na ostatak liste *)
 917   temp^.veza := lista;
 918   (* pocetak liste je novi element *)
 919   lista := temp;
 920 END DodajPoc;
 921
 922 PROCEDURE Unos(VAR lista:brojevi);
 923 (* dodaje n brojeva u listu *)
 924 VAR
 925   n,i,br:CARDINAL;
 926 BEGIN
 927   WriteString('unesite n (broj brojeva): ');
 928   ReadCard(n);
 929   FOR i:= 1 TO n DO
 930       WriteString("unesite broj ");
 931       WriteCard(i,0);
 932       WriteString(": ");
 933       ReadCard(br);
 934       DodajPoc(lista,br);
 935   END;
 936 END Unos;
 937
 938 (* -- procedure za stampu -- *)
 939
 940 PROCEDURE Stampaj(lista:brojevi);
 941 (* stampa sadrzaj liste na ekran *)
 942 VAR
 943   temp:brojevi;
 944 BEGIN
 945   WriteLn;
 946   WriteString("Sadrzaj liste:");
 947   WriteLn;
 948   temp:=lista;
 949   WHILE temp # NIL DO
 950       WriteCard(temp^.info,0);
 951       WriteLn;
 952       temp := temp^.veza;
 953   END;
 954 END Stampaj;
 955
 956 PROCEDURE StampajK(VAR lista:brojevi);
 957 (* stampa k-ti element (k unosi korisnik) *)
 958 VAR
 959   temp:brojevi;
 960   k,brojac:CARDINAL;
 961 BEGIN
 962   WriteString("unesite redni broj elementa:");
 963   ReadCard(k);
 964   temp:=lista;
 965   brojac := 1;
 966   WHILE (temp# NIL) AND (k>brojac) DO
 967     temp:=temp^.veza;
 968     INC(brojac);
 969   END;
 970   IF (temp#NIL) THEN
 971     WriteCard(temp^.info,2);
 972   ELSE
 973     WriteString("greska! - ne postoji element");
 974     WriteString(" u listi sa rednim brojem ");
 975     WriteCard(k,2);
 976   END;
 977   WriteLn();
 978 END StampajK;
 979
 980 PROCEDURE StampajMinimum(VAR lista:brojevi);
 981 (* nalazi i stampa minimalni element liste *)
 982 VAR
 983   temp:brojevi;
 984   min:CARDINAL;
 985 BEGIN
 986   IF (lista=NIL) THEN
 987     WriteString("prazna lista!");
 988   ELSE
 989     min:=lista^.info;
 990     temp:=lista^.veza;
 991     WHILE temp # NIL DO
 992       IF temp^.info < min THEN
 993         min := temp^.info;
 994       END;
 995       temp := temp^.veza;
 996     END;
 997     WriteString("Minimalni element liste je ");
 998     WriteCard(min,0);
 999   END;
1000   WriteLn;
1001 END StampajMinimum;
1002
1003 (* -- pomocne procedure, bez ispisa  -- *)
1004
1005 PROCEDURE UListi(lista:brojevi;
1006                  br: CARDINAL):BOOLEAN;
1007 (* vraca da li se 'br' nalazi u listi 'lista' *)
1008 VAR
1009   temp:brojevi;
1010 BEGIN
1011   temp:=lista;
1012   WHILE (temp # NIL) AND (temp^.info # br) DO
1013     (* dok ne dodjemo do kraja liste
1014        ili ne nadjemo broj *)
1015       temp := temp^.veza;
1016   END;
1017   IF temp#NIL THEN
1018     (* znaci da nismo na kraju liste,
1019        tj da je nadjen broj *)
1020     RETURN TRUE;
1021   ELSE (* temp = NIL *)
1022     RETURN FALSE;
1023   END;
1024 END UListi;
1025
1026 PROCEDURE IzbaciIzListe(VAR lista:brojevi;
1027                         br: CARDINAL):BOOLEAN;
1028 (* izbacuje broj 'br' iz liste, naravno ako
1029    postoji i vraca da li je operacija uspesno
1030    obavljena *)
1031 VAR
1032   temp,prethodni:brojevi;
1033 BEGIN
1034   (* proverimo da li je prvi element *)
1035   IF (lista # NIL) AND (lista^.info = br) THEN
1036     temp:=lista;
1037     lista :=lista^.veza;
1038     DISPOSE(temp);
1039     RETURN TRUE;
1040   ELSE
1041   (* trazimo u ostatku liste *)
1042     temp:=lista;
1043     prethodni:=NIL;
1044     WHILE (temp # NIL) AND (temp^.info # br) DO
1045         (* dok ne dodjemo do kraja liste
1046            ili ne nadjemo broj *)
1047         prethodni:=temp;
1048         temp := temp^.veza;
1049     END;
1050     IF temp#NIL THEN
1051       (* znaci da nismo na kraju liste,
1052          odnosno da smo nasli broj *)
1053       (* prevezemo listu oko elementa *)
1054       prethodni^.veza:=temp^.veza;
1055       DISPOSE(temp);
1056       RETURN TRUE;
1057     ELSE
1058       RETURN FALSE;
1059     END;
1060   END;
1061 END IzbaciIzListe;
1062
1063 (* - procedure sa interakcijom sa korisnikom - *)
1064
1065 PROCEDURE IzbacivanjeEl(VAR lista:brojevi);
1066 (* izbacuje uneti broj iz liste koristeci proceduru IzbaciIzListe *)
1067 VAR
1068   br:CARDINAL;
1069 BEGIN
1070   WriteString("unesite broj za izbacivanje: ");
1071   ReadCard(br);
1072   IF IzbaciIzListe(lista,br) THEN
1073     WriteString("broj je izbacen iz liste");
1074   ELSE
1075     WriteString("greska! - broj ne postoji");
1076   END;
1077   WriteLn;
1078 END IzbacivanjeEl;
1079
1080 PROCEDURE IzbacivanjeK(VAR lista:brojevi);
1081 (* izbacuje k-ti element iz liste *)
1082 VAR
1083   temp,tekuci:brojevi;
1084   k,brojac:CARDINAL;
1085 BEGIN
1086   IF lista=NIL THEN
1087     WriteString("lista je prazna, nema ");
1088     WriteString("elemenata za izbacivanje");
1089   ELSE
1090     WriteString("unesite redni broj elementa");
1091     WriteString(" koji zelite izbaciti:");
1092     ReadCard(k);
1093     IF k=1 THEN (*izbacivanje prvog *)
1094       temp:=lista;
1095       lista := lista^.veza;
1096       DISPOSE(temp);
1097     ELSE
1098       tekuci := lista;
1099       brojac := 2; (*gledamo jedan unapred*)
1100       WHILE (tekuci^.veza# NIL) AND (k>brojac) DO
1101         (* idemo kroz listu do k-tog el *)
1102         tekuci:=tekuci^.veza;
1103         INC(brojac);
1104       END;
1105       IF (tekuci^.veza#NIL) THEN
1106          (* pamtimo element za brisanje *)
1107          temp:=tekuci^.veza;
1108          (* prevezujemo listu oko njega*)
1109          tekuci^.veza:=tekuci^.veza^.veza;
1110          DISPOSE(temp);
1111       ELSE
1112         WriteString("greska! - ne postoji el ");
1113         WriteString("u listi sa rednim brojem ");
1114         WriteCard(k,2);
1115       END;
1116       WriteLn();
1117     END;
1118   END;
1119 END IzbacivanjeK;
1120
1121 PROCEDURE Pretraga(lista:brojevi);
1122 (* provera da li se uneti broj nalazi u listi *)
1123 VAR
1124   br:CARDINAL;
1125 BEGIN
1126   WriteString("unesite trazeni broj");
1127   ReadCard(br);
1128   IF UListi(lista,br) THEN
1129     WriteString("broj postoji u listi");
1130   ELSE
1131     WriteString("broj ne postoji u listi");
1132   END;
1133   WriteLn;
1134 END Pretraga;
1135
1136 (* -- oslobadjanje memorije -- *)
1137
1138 PROCEDURE Unisti(VAR lista:brojevi);
1139 VAR
1140   temp:brojevi;
1141 BEGIN
1142   temp:=lista;
1143   WHILE temp # NIL DO
1144         lista:=lista^.veza;
1145         DISPOSE(temp);
1146         temp:=lista;
1147   END;
1148 END Unisti;
1149
1150 BEGIN
1151   (* pocinjemo od prazne liste *)
1152   lista := NIL;
1153   REPEAT
1154      WriteLn;
1155      WriteString("Ilustracija rada sa");
1156      WriteString(" listama brojeva");
1157      WriteLn;
1158      WriteString("=============================");
1159      WriteLn;
1160      WriteString("s - stampa");WriteLn;
1161      WriteString("u - unos");WriteLn;
1162      WriteString("i - izbacivanje br iz liste");
1163      WriteLn;
1164      WriteString("e - izbacivanje k-tog el.");
1165      WriteLn;
1166      WriteString("k - stampanje k-tog elementa");
1167      WriteLn;
1168      WriteString("m - minimalni broj u listi");
1169      WriteLn;
1170      WriteString("p - pretraga el. u listi");
1171      WriteLn;
1172      WriteLn;
1173      WriteString("q - kraj rada (quit)");WriteLn;
1174       REPEAT
1175         menu := CAP(RdKey());
1176       UNTIL menu IN skupZn{'S','U','E','I',
1177                            'M','K','P','Q'};
1178       IF menu#'Q' THEN
1179         CASE menu OF
1180          'S' : Stampaj(lista);|
1181          'U' : Unos(lista);|
1182          'I' : IzbacivanjeEl(lista);|
1183          'E' : IzbacivanjeK(lista);|
1184          'K' : StampajK(lista); |
1185          'M' : StampajMinimum(lista); |
1186          'P' : Pretraga(lista);|
1187         END;
1188         WriteLn;
1189         WriteString("--- pritisnite bilo koji ");
1190         WriteString("taster za povratak u meni");
1191         prazno:=RdKey();
1192       ELSE
1193         WriteString("Kraj rada")
1194       END;
1195       WriteLn;
1196   UNTIL menu='Q';
1197   Unisti(lista);
1198 END liste2.
1199 \end{lstlisting}
1200
1201
1202 \subsection{Zadatak: Prikaz operacija nad listama sa jedinstvenim ključem}
1203
1204 \begin{lstlisting}[style=codeblock]
1205 MODULE Radnici;
1206
1207 FROM InOut IMPORT WriteString, ReadString,
1208            WriteLn, WriteCard, ReadCard, Done;
1209 FROM IO IMPORT RdKey;
1210 FROM Storage IMPORT ALLOCATE, DEALLOCATE;
1211
1212 TYPE
1213   skupZn = SET OF CHAR;
1214   str = ARRAY [1..20] OF CHAR;
1215   radnici = POINTER TO slog;
1216   slog = RECORD
1217            ime, prez : str;
1218            broj : CARDINAL;
1219            sled : radnici
1220          END;
1221 VAR
1222   meni, pom : CHAR;
1223   rad : radnici;
1224
1225   PROCEDURE Clear();
1226   VAR
1227     br: CARDINAL;
1228   BEGIN
1229     FOR br:=1 TO 100 DO
1230       WriteLn;
1231     END;
1232   END Clear;
1233
1234   PROCEDURE Spisak(rad : radnici);
1235   BEGIN
1236     WHILE rad # NIL DO
1237       WriteString(rad^.ime);
1238       WriteString(' ');
1239       WriteString(rad^.prez);
1240       WriteCard(rad^.broj, 8);
1241       WriteLn;
1242       rad := rad^.sled
1243     END
1244   END Spisak;
1245
1246   PROCEDURE Zaposli(VAR rad : radnici);
1247   VAR
1248     novi, tek : radnici;
1249     nadjen : BOOLEAN;
1250   BEGIN
1251     NEW(novi);
1252     REPEAT
1253       WriteString('Ime, prezime i jedinstveni');
1254       WriteString(' broj novog radnika: ');
1255       WriteLn;
1256       ReadString(novi^.ime);
1257       ReadString(novi^.prez);
1258       ReadCard(novi^.broj);
1259       nadjen := FALSE;
1260       tek := rad;
1261       WHILE NOT nadjen AND (tek # NIL) AND
1262             (tek^.broj <= novi^.broj) DO
1263         IF novi^.broj = tek^.broj THEN
1264           nadjen := TRUE
1265         ELSE
1266           tek := tek^.sled
1267         END
1268       END
1269     UNTIL Done AND NOT nadjen;
1270     IF (rad = NIL) OR (novi^.broj<rad^.broj) THEN
1271       novi^.sled := rad;
1272       rad := novi
1273     ELSE
1274       tek := rad;
1275       WHILE (tek^.sled # NIL) AND
1276             (tek^.sled^.broj < novi^.broj) DO
1277         tek := tek^.sled
1278       END;
1279       novi^.sled := tek^.sled;
1280       tek^.sled := novi
1281     END
1282   END Zaposli;
1283
1284   PROCEDURE Otpusti(VAR rad : radnici);
1285   VAR
1286     tek, pom : radnici;
1287     br : CARDINAL;
1288   BEGIN
1289     REPEAT
1290       WriteLn;
1291       WriteString('Unesite redni broj radnika:');
1292       ReadCard(br)
1293     UNTIL Done;
1294     WriteLn;
1295     IF rad = NIL THEN
1296       WriteString('Greska.')
1297     ELSIF br = rad^.broj THEN
1298       pom := rad;
1299       rad := rad^.sled;
1300       DISPOSE(pom)
1301     ELSE
1302       tek := rad;
1303       WHILE (tek^.sled # NIL) AND
1304             (tek^.sled^.broj < br) DO
1305         tek := tek^.sled
1306       END;
1307       IF (tek^.sled = NIL) OR
1308          (tek^.sled^.broj > br) THEN
1309         WriteString('Greska.')
1310       ELSE
1311         pom := tek^.sled;
1312         tek^.sled := tek^.sled^.sled;
1313         DISPOSE(pom)
1314       END
1315     END
1316   END Otpusti;
1317
1318   PROCEDURE Inform(rad : radnici);
1319   VAR
1320     br : CARDINAL;
1321   BEGIN
1322     REPEAT
1323       WriteLn;
1324       WriteString('Unesite redni broj radnika:');
1325       ReadCard(br)
1326     UNTIL Done;
1327     WriteLn;
1328     WHILE (rad # NIL) AND (rad^.broj < br) DO
1329       rad := rad^.sled
1330     END;
1331     IF (rad = NIL) OR (rad^.broj # br) THEN
1332       WriteString('Greska.')
1333     ELSE
1334       WriteString(rad^.ime);
1335       WriteString(' ');
1336       WriteString(rad^.prez)
1337     END
1338   END Inform;
1339
1340   PROCEDURE Bankrot(VAR rad : radnici);
1341   VAR
1342     pom : radnici;
1343   BEGIN
1344     WHILE rad # NIL DO
1345       pom := rad;
1346       rad := rad^.sled;
1347       DISPOSE(pom)
1348     END
1349   END Bankrot;
1350
1351 BEGIN
1352   rad := NIL;
1353   REPEAT
1354     Clear;
1355     WriteString('s - spisak svih zaposlenih');
1356     WriteLn;
1357     WriteString('z - zaposljavanje radnika');
1358     WriteLn;
1359     WriteString('o - otpustanje radnika');
1360     WriteLn;
1361     WriteString('i - informacije o radniku');
1362     WriteLn;
1363     WriteString('b - bankrot firme');
1364     WriteLn;
1365     WriteString('k - kraj rada');
1366     WriteLn;
1367     REPEAT
1368       meni := RdKey();
1369     UNTIL CAP(meni) IN skupZn{'S', 'Z', 'O',
1370                               'I', 'B', 'K'};
1371     Clear;
1372     IF CAP(meni) # 'K' THEN
1373       CASE CAP(meni) OF
1374         'S' : Spisak(rad)|
1375         'Z' : Zaposli(rad)|
1376         'O' : Otpusti(rad)|
1377         'I' : Inform(rad)|
1378         'B' : Bankrot(rad)
1379       END;
1380       WriteLn;
1381       WriteString('-- pritisnite bilo koji ');
1382       WriteString('taster za nastavak --');
1383       pom := RdKey()
1384     END
1385   UNTIL CAP(meni) = 'K'
1386 END Radnici.
1387 \end{lstlisting}
1388
1389 Procedura \kod{Spisak} se može realizovati i u rekurzivnoj verziji:
1390
1391 \begin{lstlisting}[style=codeblock]
1392   PROCEDURE Spisak(rad : radnici);
1393   BEGIN
1394     IF rad # NIL THEN
1395       WriteString(rad^.ime);
1396       WriteString(' ');
1397       WriteString(rad^.prez);
1398       WriteCard(rad^.broj, 8);
1399       WriteLn;
1400       Spisak(rad^.sled)
1401     END
1402   END Spisak;
1403 \end{lstlisting}
1404
1405 \subsection[Zadatak: Dve liste osoba sa istim sadržajem]{Zadatak: Dve
1406   liste osoba koje dele sadržaj, jedna sortirana po visini, druga po
1407   težini}
1408
1409 Sa tastature učitavati po dva broja koji opisuju osobu (visina i
1410 težina) i smeštati ih u povezane listu, tako da postoji neopadajuće
1411 uređenje i po visini i po težini.
1412
1413 \begin{lstlisting}[style=codeblock]
1414 MODULE VisTez;
1415 FROM Storage IMPORT ALLOCATE, DEALLOCATE;
1416 FROM IO IMPORT WrLn, WrStr, RdCard, WrCard;
1417 FROM SYSTEM IMPORT TSIZE;
1418 TYPE
1419   pok = POINTER TO element;
1420   element = RECORD
1421               visina, tezina : CARDINAL;
1422               Vveza, Tveza : pok
1423             END;
1424 VAR
1425   pocV, pocT : pok;
1426   vis, tez : CARDINAL;
1427 PROCEDURE Ispisi(pocV, pocT : pok);
1428 VAR
1429   tek : pok;
1430 BEGIN
1431   tek := pocV;
1432   WrStr('Po visini:');
1433   WrLn;
1434   WHILE tek # NIL DO
1435     WrCard(tek^.visina, 6);
1436     tek := tek^.Vveza
1437   END;
1438   WrLn;
1439   tek := pocT;
1440   WrStr('Po tezini:');
1441   WrLn;
1442   WHILE tek # NIL DO
1443     WrCard(tek^.tezina,6);
1444     tek := tek^.Tveza
1445   END
1446 END Ispisi;
1447
1448 PROCEDURE Ubaci(VAR pocV, pocT : pok;
1449                 vis, tez : CARDINAL);
1450 VAR
1451   novi, tek, iza : pok;
1452   nadjen : BOOLEAN;
1453 BEGIN
1454   IF pocV = NIL THEN
1455     ALLOCATE(pocV, TSIZE(element));
1456     pocV^.visina := vis;
1457     pocV^.tezina := tez;
1458     pocV^.Vveza := NIL;
1459     pocV^.Tveza := NIL;
1460     pocT := pocV
1461   ELSE
1462     ALLOCATE(novi, TSIZE(element));
1463     novi^.visina := vis;
1464     novi^.tezina := tez;
1465     tek := pocV;
1466     nadjen := FALSE;
1467     WHILE (tek # NIL) AND NOT nadjen DO
1468       nadjen := vis <= tek^.visina;
1469       IF NOT nadjen THEN
1470         iza := tek;
1471         tek := tek^.Vveza
1472       END
1473     END;
1474     novi^.Vveza := tek;
1475     IF tek = pocV THEN
1476       pocV := novi
1477     ELSE
1478       iza^.Vveza := novi
1479     END;
1480     tek := pocT;
1481     nadjen := FALSE;
1482     WHILE (tek # NIL) AND NOT nadjen DO
1483       nadjen := tez <= tek^.tezina;
1484       IF NOT nadjen THEN
1485         iza := tek;
1486         tek := tek^.Tveza
1487       END
1488     END;
1489     novi^.Tveza := tek;
1490     IF tek = pocT THEN
1491       pocT := novi
1492     ELSE
1493       iza^.Tveza := novi
1494     END
1495   END
1496 END Ubaci;
1497
1498 BEGIN
1499   pocV := NIL;
1500   pocT := NIL;
1501   WrStr('Unesite visinu ---- ');
1502   vis := RdCard();
1503   WHILE vis > 0 DO
1504     WrStr('Unesite tezinu ---- ');
1505     tez := RdCard();
1506     Ubaci(pocV, pocT, vis, tez);
1507     WrLn;
1508     WrStr('Unesite visinu ---- ');
1509     vis := RdCard()
1510   END;
1511   WrLn;
1512   Ispisi(pocV, pocT)
1513 END VisTez.
1514 \end{lstlisting}
1515
1516 \section{Polinomi preko listi}
1517
1518 \subsection{Moduli}
1519
1520 Polinomi su predstavljeni pomoću pokazivača. Apstraktni tip podataka
1521 \kod{Polinom} je definisan u globalnom modulu.
1522
1523 \paragraph{PolinomL.DEF} \
1524
1525 \begin{lstlisting}[style=codeblock]
1526 DEFINITION MODULE PolinomL;
1527 TYPE
1528   Polinom = POINTER TO Monom;
1529   Monom = RECORD
1530             k : REAL;
1531             st : CARDINAL;
1532             veza : Polinom
1533           END;
1534
1535 PROCEDURE Anuliraj(VAR p: Polinom);
1536 PROCEDURE Unos(VAR p: Polinom);
1537 PROCEDURE Stampaj(p: Polinom; d: CARDINAL);
1538 PROCEDURE Kopiraj(p: Polinom;
1539                   VAR kopija: Polinom);
1540 PROCEDURE UbaciMonom(mon:Polinom;
1541                      VAR p: Polinom);
1542 PROCEDURE PromeniZnak(VAR p: Polinom);
1543 PROCEDURE Saberi(p1, p2: Polinom;
1544                  VAR zbir: Polinom);
1545 PROCEDURE SaberiNa(p: Polinom; VAR rez: Polinom);
1546 PROCEDURE Oduzmi(p1,p2: Polinom;
1547                  VAR razlika: Polinom);
1548 PROCEDURE MonomPuta(p, mon: Polinom;
1549                     VAR mp : Polinom);
1550 PROCEDURE Puta(p1, p2: Polinom; VAR pr: Polinom);
1551 PROCEDURE Kolicnik(p1, p2: Polinom;
1552                    VAR kol, ost: Polinom;
1553                    VAR ok : BOOLEAN);
1554 PROCEDURE PolinomNaN(p: Polinom; n: CARDINAL;
1555                      VAR rez: Polinom);
1556 PROCEDURE DisposePolinom(VAR p: Polinom);
1557
1558 END PolinomL.
1559 \end{lstlisting}
1560
1561 \paragraph{PolinomL.MOD} \
1562
1563 \begin{codeblock}
1564 IMPLEMENTATION MODULE PolinomL;
1565 FROM InOut IMPORT Write, WriteString, WriteLn,
1566            WriteCard, ReadCard, Done;
1567 FROM RealInOut IMPORT WriteReal, ReadReal;
1568 FROM Storage IMPORT ALLOCATE, DEALLOCATE;
1569
1570 PROCEDURE Anuliraj(VAR p: Polinom);
1571 BEGIN
1572   IF p # NIL THEN
1573     DisposePolinom(p);
1574   END;
1575 END Anuliraj;
1576
1577 PROCEDURE Kopiraj(p: Polinom;
1578                   VAR kopija: Polinom);
1579 VAR
1580   pomocni: Polinom;
1581 BEGIN
1582   IF p = NIL THEN
1583     kopija := NIL
1584   ELSE
1585     NEW(kopija);
1586     kopija^ := p^;
1587     p := p^.veza;
1588     pomocni := kopija;
1589     WHILE p <> NIL DO
1590       NEW(pomocni^.veza);
1591       pomocni := pomocni^.veza;
1592       pomocni^ := p^;
1593       p := p^.veza
1594     END
1595   END
1596 END Kopiraj;
1597
1598 PROCEDURE Stampaj(p: Polinom; d: CARDINAL);
1599
1600   PROCEDURE StampajMonom(m : Polinom);
1601   BEGIN
1602     WITH m^ DO
1603       IF st <> 0 THEN
1604         IF ABS(k) <> 1.0 THEN
1605           WriteReal(ABS(k), d)
1606         END;
1607         Write('x');
1608         IF st <> 1 THEN
1609           Write('^');
1610           WriteCard(st, 1)
1611         END
1612       ELSE
1613         WriteReal(ABS(k), d)
1614       END
1615     END
1616   END StampajMonom;
1617
1618 BEGIN
1619   IF p = NIL THEN
1620     WriteReal(0., d)
1621   ELSE
1622     IF p^.k < 0.0 THEN
1623       WriteString(' - ')
1624     END;
1625     StampajMonom(p);
1626     p := p^.veza;
1627     WHILE p <> NIL DO
1628       IF p^.k > 0.0 THEN
1629         WriteString(' + ')
1630       ELSE
1631         WriteString(' - ')
1632       END;
1633       StampajMonom(p);
1634       p := p^.veza
1635     END
1636   END
1637 END Stampaj;
1638
1639 PROCEDURE UbaciMonom(mon :Polinom;
1640                      VAR p: Polinom);
1641 VAR
1642   stari, tekuci, kopija: Polinom;
1643 BEGIN
1644   IF mon # NIL THEN
1645     NEW(kopija);
1646     kopija^ := mon^;
1647     tekuci := p;
1648         stari := NIL;
1649     WHILE (tekuci#NIL) AND (tekuci^.st>kopija^.st) DO
1650       stari := tekuci;
1651       tekuci := tekuci^.veza
1652     END;
1653     kopija^.veza := tekuci;
1654     IF tekuci = p THEN
1655       p := kopija
1656     ELSE
1657       stari^.veza := kopija
1658     END;
1659     IF (tekuci#NIL) AND
1660            (kopija^.st = tekuci^.st) THEN
1661       kopija^.k := kopija^.k + tekuci^.k;
1662       kopija^.veza := tekuci^.veza;
1663       DISPOSE(tekuci);
1664       IF kopija^.k = 0.0 THEN
1665         IF p = kopija THEN
1666           p := kopija^.veza
1667         ELSE
1668           stari^.veza := kopija^.veza
1669         END;
1670         DISPOSE(kopija)
1671       END
1672     END
1673   END
1674 END UbaciMonom;
1675
1676 PROCEDURE Unos(VAR p : Polinom);
1677 VAR
1678   i, n: CARDINAL;
1679   novi: Polinom;
1680 BEGIN
1681   Anuliraj(p);
1682   REPEAT
1683     WriteLn;
1684     WriteString('Unesite broj monoma n (n>=0) ');
1685     ReadCard(n);
1686   UNTIL Done;
1687   WriteLn;
1688   FOR i := 1 TO n DO
1689     NEW(novi);
1690     WITH novi^ DO
1691       REPEAT
1692         WriteString('koeficijent monoma br.');
1693         WriteCard(i, 1);
1694         WriteString(' (<> 0):');
1695         ReadReal(k);
1696         WriteLn
1697       UNTIL k <> 0.0;
1698       REPEAT
1699         WriteLn;
1700         WriteString('eksponent monoma br.');
1701         WriteCard(i, 1);
1702         WriteString(' (>= 0): ');
1703         ReadCard(st);
1704       UNTIL Done;
1705       WriteLn;
1706     END;
1707     UbaciMonom(novi, p);
1708     DISPOSE(novi);
1709   END
1710 END Unos;
1711
1712 PROCEDURE Saberi(p1, p2: Polinom;
1713                  VAR zbir: Polinom);
1714 BEGIN
1715   Kopiraj(p1, zbir);
1716   WHILE p2 <> NIL DO
1717     UbaciMonom(p2, zbir);
1718     p2 := p2^.veza
1719   END
1720 END Saberi;
1721
1722 PROCEDURE SaberiNa(p: Polinom;
1723                    VAR rez: Polinom);
1724 BEGIN
1725   WHILE p <> NIL DO
1726     UbaciMonom(p,rez);
1727     p := p^.veza;
1728   END;
1729 END SaberiNa;
1730
1731 PROCEDURE PromeniZnak(VAR p: Polinom);
1732 VAR
1733   t: Polinom;
1734 BEGIN
1735   t := p;
1736   WHILE t <> NIL DO
1737     t^.k := - t^.k;
1738     t := t^.veza
1739   END
1740 END PromeniZnak;
1741
1742 PROCEDURE Oduzmi(p1,p2: Polinom;
1743                  VAR razlika: Polinom);
1744 BEGIN
1745   Kopiraj(p2, razlika);
1746   PromeniZnak(razlika);
1747   WHILE p1 <> NIL DO
1748     UbaciMonom(p1, razlika);
1749     p1 := p1^.veza
1750   END
1751 END Oduzmi;
1752
1753 PROCEDURE MonomPuta(p, mon: Polinom;
1754                     VAR mp: Polinom);
1755 VAR
1756   tekuci: Polinom;
1757 BEGIN
1758   Anuliraj(mp);
1759   IF (mon <> NIL) AND (p <> NIL) THEN
1760     NEW(mp);
1761     mp^.k := p^.k * mon^.k;
1762     mp^.st := p^.st + mon^.st;
1763     p := p^.veza;
1764     tekuci := mp;
1765     WHILE p <> NIL DO
1766       NEW(tekuci^.veza);
1767       tekuci := tekuci^.veza;
1768       tekuci^.k := p^.k * mon^.k;
1769       tekuci^.st := p^.st + mon^.st;
1770       p := p^.veza
1771     END;
1772     tekuci^.veza := NIL
1773   END
1774 END MonomPuta;
1775
1776 PROCEDURE Puta(p1, p2: Polinom; VAR pr: Polinom);
1777 VAR
1778   pomocni: Polinom;
1779 BEGIN
1780   Anuliraj(pr);
1781   IF (p1 <> NIL) AND (p2 <> NIL) THEN
1782     MonomPuta(p1, p2, pr);
1783     p2 := p2^.veza;
1784     WHILE p2 <> NIL DO
1785       MonomPuta(p1, p2, pomocni);
1786       REPEAT
1787         UbaciMonom(pomocni, pr);
1788         pomocni := pomocni^.veza
1789       UNTIL pomocni = NIL;
1790       p2 := p2^.veza
1791     END
1792   END
1793 END Puta;
1794
1795 PROCEDURE Kolicnik(p1, p2: Polinom;
1796                    VAR kol, ost: Polinom;
1797                    VAR ok: BOOLEAN);
1798
1799   PROCEDURE Deli(VAR kol, ost: Polinom);
1800   VAR
1801     novi, pomocni: Polinom;
1802   BEGIN
1803     IF ost <> NIL THEN
1804       IF ost^.st >= p2^.st THEN
1805         NEW(novi);
1806         novi^.k := - ost^.k / p2^.k;
1807         novi^.st := ost^.st - p2^.st;
1808         MonomPuta(p2, novi, pomocni);
1809         Saberi(ost, pomocni, ost);
1810         novi^.k := - novi^.k;
1811         UbaciMonom(novi, kol);
1812         DISPOSE(novi);
1813         Deli(kol, ost)
1814       END
1815     END
1816   END Deli;
1817
1818 BEGIN (* Kolicnik *)
1819   ok := TRUE;
1820   Anuliraj(kol);
1821   IF p2 = NIL THEN
1822     ok := FALSE
1823   ELSE
1824     Kopiraj(p1, ost);
1825     Deli(kol, ost)
1826   END
1827 END Kolicnik;
1828
1829 PROCEDURE PolinomNaN(p: Polinom; n: CARDINAL;
1830                      VAR rez: Polinom);
1831 VAR
1832   i: CARDINAL;
1833 BEGIN
1834   IF n = 0 THEN
1835     NEW(rez);
1836     rez^.k := 1.0;
1837     rez^.st := 0;
1838     rez^.veza := NIL;
1839   ELSIF n = 1 THEN
1840     Kopiraj( rez, p );
1841   ELSE
1842     rez := p;
1843     FOR i := 2 TO n DO
1844       Puta(rez, p, rez)
1845     END
1846   END;
1847 END PolinomNaN;
1848
1849 PROCEDURE DisposePolinom(VAR p: Polinom);
1850 VAR
1851   pomocni: Polinom;
1852 BEGIN
1853   pomocni := p;
1854   WHILE pomocni # NIL DO
1855     p := p^.veza;
1856     DISPOSE(pomocni);
1857     pomocni := p
1858   END
1859 END DisposePolinom;
1860
1861 END PolinomL.
1862 \end{codeblock}
1863
1864
1865 \subsection{Zadatak: Sabiranje sa unapred određenim polinomom}
1866
1867 Želimo da ispišemo uneti polinom uvećan za\\ $x^5 - 3x^4 + 4x + 7$.
1868
1869 \begin{lstlisting}[style=codeblock]
1870 MODULE polinom;
1871 FROM PolinomL IMPORT Polinom, Stampaj, Anuliraj, DisposePolinom, UbaciMonom, Unos, Saberi;
1872 FROM InOut IMPORT WriteString, WriteLn;
1873 FROM Storage IMPORT ALLOCATE, DEALLOCATE;
1874
1875 VAR
1876   p,q,rez,pom : Polinom;
1877
1878 BEGIN
1879   (* korisnik unosi prvi polinom *)
1880   WriteString("Unesite polinom:");
1881   WriteLn;
1882   Unos(p);
1883   (* drugi polinom kreiramo mi,
1884      monom po monom *)
1885   Anuliraj(q); (* isto sto i q:=NIL; *)
1886   (* formiramo monom x^5 *)
1887   NEW(pom);
1888   pom^.st:=5;
1889   pom^.k:=1.0;
1890   (* dodajemo ga u polinom *)
1891   UbaciMonom(pom,q);
1892   DISPOSE(pom);
1893   (* -3 x^4 *)
1894   NEW(pom);
1895   pom^.st := 4;
1896   pom^.k := -3.0;
1897   UbaciMonom(pom,q);
1898   DISPOSE(pom);
1899   (* 4 x *)
1900   NEW(pom);
1901   pom^.st := 1;
1902   pom^.k := 4.0;
1903   UbaciMonom(pom,q);
1904   DISPOSE(pom);
1905   (* 7 (x^0) *)
1906   NEW(pom);
1907   pom^.st := 0;
1908   pom^.k := 7.0;
1909   UbaciMonom(pom,q);
1910   DISPOSE(pom);
1911   (* saberemo polinome *)
1912   Saberi(p, q, rez);
1913   (* odstampamo rezultat *)
1914   Stampaj(rez,0);
1915   WriteLn;
1916   (* oslobadjanje zauzete memorije *)
1917   DisposePolinom(p);
1918   DisposePolinom(q);
1919   DisposePolinom(rez);
1920 END polinom.
1921 \end{lstlisting}
1922
1923 \subsection{Zadatak: Suma k polinoma}
1924
1925 Napisati program koji ucitava broj k (1<=k<=50) i k polinoma, a nakon
1926 toga izracunava njihovu sumu
1927
1928 \begin{lstlisting}[style=codeblock]
1929 MODULE PolSuma;
1930
1931 FROM PolinomL IMPORT Polinom, Anuliraj, DisposePolinom, Unos, Stampaj, SaberiNa;
1932 FROM InOut IMPORT WriteLn, WriteString, ReadCard, WriteCard;
1933 CONST
1934   maxk = 50;
1935 TYPE
1936   nizPol = ARRAY [1..maxk] OF Polinom;
1937 VAR
1938   i, k: CARDINAL;
1939   suma : Polinom;
1940   p : nizPol;
1941 BEGIN
1942   REPEAT
1943     WriteString('Unesite broj k (1 <= k <= ');
1944     WriteCard(maxk, 1);
1945     WriteString(') ');
1946     ReadCard(k);
1947     WriteLn;
1948   UNTIL (1 <= k) AND (k <= maxk);
1949   FOR i := 1 TO k DO
1950     WriteLn;
1951     WriteString('Unos ');
1952     WriteCard(i, 1);
1953     WriteString('. polinoma.');
1954     WriteLn;
1955     Unos(p[i])
1956   END;
1957   Anuliraj(suma);
1958   FOR i := 1 TO k DO
1959     SaberiNa(suma, p[i])
1960   END;
1961   WriteLn;
1962   WriteString('Njihova suma je:');
1963   WriteLn;
1964   Stampaj(suma, 4);
1965   DisposePolinom(suma);
1966   FOR i := 1 TO k DO
1967     DisposePolinom(p[i]);
1968   END;
1969 END PolSuma.
1970 \end{lstlisting}
1971
1972 \section{Stek i red opsluživanja}
1973
1974 \subsection{Zadatak: Ilustracija pisanja u fajl uz pomoć bafera}
1975
1976 \begin{lstlisting}[style=codeblock]
1977 DEFINITION MODULE QueueInfo;
1978 CONST
1979   Maxqueue = 100;
1980 TYPE
1981   InfoTip = CHAR;
1982
1983 END QueueInfo.
1984
1985 IMPLEMENTATION MODULE QueueInfo;
1986 END QueueInfo.
1987
1988 DEFINITION MODULE RedOpsl1;
1989 FROM QueueInfo IMPORT InfoTip,Maxqueue;
1990 TYPE
1991   Niz = ARRAY[1..Maxqueue] OF InfoTip;
1992   RedOpslTip = RECORD
1993         Prvi, Zadnji : CARDINAL;
1994         Element : Niz
1995   END;
1996
1997 PROCEDURE MakeNull(VAR q : RedOpslTip);
1998 PROCEDURE Empty(VAR q : RedOpslTip) : BOOLEAN;
1999 PROCEDURE First(VAR q : RedOpslTip;
2000                 VAR x : InfoTip;
2001                 VAR ok : BOOLEAN);
2002 PROCEDURE PopFirst(VAR q : RedOpslTip;
2003                    VAR ok : BOOLEAN);
2004 PROCEDURE AddRear(VAR q : RedOpslTip;
2005                   x : InfoTip;
2006                   VAR ok : BOOLEAN);
2007
2008 END RedOpsl1.
2009
2010 IMPLEMENTATION MODULE RedOpsl1;
2011 FROM QueueInfo IMPORT Maxqueue,InfoTip;
2012
2013 PROCEDURE MakeNull(VAR q : RedOpslTip);
2014 BEGIN
2015   WITH q DO
2016     Prvi := 0;
2017     Zadnji := 0
2018   END
2019 END MakeNull;
2020
2021 PROCEDURE Empty(VAR q : RedOpslTip) : BOOLEAN;
2022 BEGIN
2023   RETURN q.Zadnji = 0
2024 END Empty;
2025
2026
2027 PROCEDURE First(VAR q : RedOpslTip;
2028                 VAR x : InfoTip;
2029                 VAR ok : BOOLEAN);
2030 BEGIN
2031   IF Empty(q) THEN
2032     ok := FALSE
2033   ELSE
2034     ok := TRUE;
2035     WITH q DO
2036       x := Element[Prvi]
2037     END
2038   END
2039 END First;
2040
2041 PROCEDURE AddOne(i : CARDINAL) : CARDINAL;
2042 BEGIN
2043   IF i = Maxqueue THEN
2044     RETURN 1
2045   ELSE
2046     RETURN i+1
2047   END
2048 END AddOne;
2049
2050 PROCEDURE PopFirst(VAR q : RedOpslTip;
2051                    VAR ok : BOOLEAN);
2052 BEGIN
2053   IF Empty(q) THEN
2054     ok := FALSE
2055   ELSE
2056     ok := TRUE;
2057     WITH q DO
2058       IF Prvi = Zadnji THEN
2059         MakeNull(q)
2060       ELSE
2061         Prvi := AddOne(Prvi)
2062       END
2063     END
2064   END
2065 END PopFirst;
2066
2067 PROCEDURE AddRear(VAR q : RedOpslTip;
2068                   x : InfoTip;
2069                   VAR ok : BOOLEAN);
2070 BEGIN
2071   WITH q DO
2072     IF AddOne(Zadnji) = Prvi THEN
2073       ok := FALSE
2074     ELSE
2075       ok := TRUE;
2076       IF Empty(q) THEN
2077         Prvi := 1;
2078         Zadnji := 1
2079       ELSE
2080         Zadnji := AddOne(Zadnji)
2081       END;
2082       Element[Zadnji] := x
2083     END
2084   END
2085 END AddRear;
2086
2087 END RedOpsl1.
2088
2089 MODULE Bafer;
2090 FROM RedOpsl1 IMPORT RedOpslTip, MakeNull, Empty, First, PopFirst, AddRear;
2091 FROM FIO IMPORT File,WrChar, Create, Close;
2092 IMPORT IO;
2093
2094 CONST
2095   ImeIzlaza = 'izlaz.txt';
2096
2097 VAR
2098   izlaz : File;
2099   znak : CHAR;
2100   buffer : RedOpslTip;
2101
2102 PROCEDURE IsprazniBafer(VAR dat : File;
2103                         VAR buf : RedOpslTip);
2104 VAR
2105   znak : CHAR;
2106   ok : BOOLEAN;
2107 BEGIN
2108   WHILE NOT Empty(buf) DO
2109     First(buf, znak, ok);
2110     PopFirst(buf, ok);
2111     WrChar(dat, znak)
2112   END
2113 END IsprazniBafer;
2114
2115 PROCEDURE BaferWrite(VAR dat : File;
2116                      VAR buf : RedOpslTip;
2117                      znak : CHAR);
2118 VAR
2119   ok : BOOLEAN;
2120 BEGIN
2121   AddRear(buf, znak, ok);
2122   IF NOT ok THEN
2123     IsprazniBafer(dat, buf);
2124     AddRear(buf, znak, ok)
2125   END
2126 END BaferWrite;
2127
2128 BEGIN
2129   izlaz := Create(ImeIzlaza);
2130   MakeNull(buffer);
2131   IO.WrStr('Unesite tekst, koji treba da se unese u datoteku ');
2132   IO.WrStr(ImeIzlaza);
2133   IO.WrChar('.');
2134   IO.WrLn;
2135   IO.WrStr('Unos zavrsite tackom.');
2136   IO.WrLn;
2137   znak := IO.RdChar();
2138   WHILE znak # '.' DO
2139     BaferWrite(izlaz, buffer, znak);
2140     znak := IO.RdChar();
2141   END;
2142   IsprazniBafer(izlaz, buffer);
2143   Close(izlaz)
2144 END Bafer.
2145 \end{lstlisting}
2146
2147 \subsection%
2148 {Zadatak: Ispitivanje da li reč pripada gramatici wcw$^+$}
2149
2150 Reč pripada ovoj gramatici ako joj se prvi deo (w) sastoji samo od
2151 slova 'a' i 'b', sledi slovo 'c' a nakon njega obrnuta reč reči w.
2152
2153 \begin{lstlisting}[style=codeblock]
2154 DEFINITION MODULE Stek;
2155 CONST
2156   Maxstack = 100;
2157 TYPE
2158   Niz = ARRAY [1..Maxstack] OF CHAR;
2159   StekTip = RECORD
2160             Top : CARDINAL;
2161             Element : Niz
2162           END;
2163 PROCEDURE MakeNull(VAR s : StekTip);
2164 PROCEDURE Empty(VAR s : StekTip) : BOOLEAN;
2165
2166 PROCEDURE Top(VAR s : StekTip;
2167               VAR x : CHAR;
2168               VAR ok : BOOLEAN);
2169 PROCEDURE Pop(VAR s : StekTip;
2170               VAR ok : BOOLEAN);
2171 PROCEDURE Push(VAR s : StekTip;
2172                x : CHAR;
2173                VAR ok : BOOLEAN);
2174 END Stek.
2175
2176
2177 IMPLEMENTATION MODULE Stek;
2178
2179 PROCEDURE MakeNull(VAR s : StekTip);
2180 BEGIN
2181   s.Top := 0
2182 END MakeNull;
2183
2184 PROCEDURE Empty(VAR s : StekTip) : BOOLEAN;
2185 BEGIN
2186   RETURN s.Top = 0
2187 END Empty;
2188
2189 PROCEDURE Top(VAR s : StekTip;
2190               VAR x : CHAR;
2191               VAR ok : BOOLEAN);
2192 BEGIN
2193   IF Empty(s) THEN
2194     ok := FALSE
2195   ELSE
2196     ok := TRUE;
2197     WITH s DO
2198       x := Element[Top]
2199     END
2200   END
2201 END Top;
2202
2203 PROCEDURE Pop(VAR s : StekTip;
2204               VAR ok : BOOLEAN);
2205 BEGIN
2206   IF Empty(s) THEN
2207     ok := FALSE
2208   ELSE
2209     ok := TRUE;
2210     DEC(s.Top)
2211   END
2212 END Pop;
2213
2214 PROCEDURE Push(VAR s : StekTip;
2215                x : CHAR;
2216                VAR ok : BOOLEAN);
2217 BEGIN
2218   WITH s DO
2219     IF Top = Maxstack THEN
2220       ok := FALSE
2221     ELSE
2222       ok := TRUE;
2223       INC(Top);
2224       Element[Top] := x
2225     END
2226   END
2227 END Push;
2228 END Stek.
2229
2230 MODULE wcw;
2231 (* Da li rec pripada gramatici wcw+. *)
2232 FROM Stek IMPORT StekTip, MakeNull, Empty,
2233                  Top, Pop, Push;
2234 FROM InOut IMPORT Read, Write, WriteString, EOL;
2235 TYPE
2236   slova = SET OF CHAR;
2237 VAR
2238   S : StekTip;
2239   Ch, C : CHAR;
2240   ok : BOOLEAN;
2241 BEGIN
2242   MakeNull(S);
2243   Read(Ch);
2244   ok := TRUE;
2245   WHILE ok AND (Ch IN slova{'a', 'b'}) DO
2246     Push(S, Ch, ok);
2247     Read(Ch);
2248   END;
2249   IF NOT ok THEN
2250     WriteString('Greska - mali stek')
2251   ELSIF Ch # 'c' THEN
2252     WriteString('Pogresan string')
2253   ELSE
2254     Read(Ch);
2255     WHILE ok AND (Ch # EOL) DO
2256       Top(S, C, ok);
2257       ok := ok AND (C = Ch);
2258       IF ok THEN
2259         Pop(S, ok);
2260         Read(Ch);
2261       END
2262     END;
2263     IF NOT (ok AND Empty(S)) THEN
2264       WriteString('Pogresan string')
2265     ELSE
2266       WriteString('String pripada jeziku L')
2267     END
2268   END
2269 END wcw.
2270 \end{lstlisting}
2271
2272 \subsection{Zadatak: Kalkulator za izračunavanje postfiksnih izraza}
2273
2274
2275 Napraviti kalkulator za izračunavanje postfiksnih izraza. Svi brojevi
2276 koji figurišu u izrazu su jednocifreni.
2277
2278 \begin{lstlisting}[style=codeblock]
2279 MODULE PostFix;
2280
2281 FROM StekI IMPORT StekTip, MakeNull, Empty, Top, Pop, Push;
2282 FROM InOut IMPORT Read, Write, WriteInt, EOL;
2283 TYPE
2284   slova = SET OF CHAR;
2285 VAR
2286   S : StekTip;
2287   Ch : CHAR;
2288   Op1, Op2 : INTEGER;
2289   ok : BOOLEAN;
2290 PROCEDURE Conv(Ch : CHAR) : INTEGER;
2291 BEGIN
2292   RETURN  ORD(Ch) - ORD('0')
2293 END Conv;
2294
2295 BEGIN
2296   MakeNull(S);
2297   Read(Ch);
2298   WHILE Ch # EOL DO
2299     IF Ch IN slova{'+', '-', '/', '*', '%'} THEN
2300       Top(S, Op2, ok);
2301       Pop(S, ok);
2302       Top(S, Op1, ok);
2303       Pop(S, ok);
2304       CASE Ch OF
2305         '+' : Op1 := Op1 + Op2 |
2306         '-' : Op1 := Op1 - Op2 |
2307         '*' : Op1 := Op1 * Op2 |
2308         '/' : Op1 := Op1 DIV Op2 |
2309         '%' : Op1 := Op1 MOD Op2
2310       END;
2311       Push(S, Op1, ok)
2312     ELSE
2313       Push(S, Conv(Ch), ok)
2314     END;
2315     Read(Ch);
2316   END;
2317   Top(S, Op1, ok);
2318   Write('=');
2319   WriteInt(Op1,5)
2320 END PostFix.
2321 \end{lstlisting}
2322
2323
2324 \section{Simulacija rekurzije}
2325
2326
2327 Na početku označiti sve rekurzivne pozive u originalnoj proceduri
2328 adresama (npr. 1,2,3... ili konstante nabrojivog tipa podataka).
2329
2330 Na steku se čuvaju lokalne promenljive, parametri procedure i adresa
2331 mesta poziva, a u skladu sa tim se kreira InfoTip.
2332
2333 Trivijalnim pozivom se smatra onaj koji se izračunava bez dodatnih
2334 rekurzivnih poziva.
2335
2336 U kodu ispod, \kod{treba\_rekurzija} znači da je poziv netrivijalan,
2337 odnosno treba naći uslove pod kojima se sigurno dešavaju rekurzivni
2338 pozivi.
2339
2340 \begin{lstlisting}
2341 MakeNull(S);
2342 REPEAT
2343   WHILE treba_rekurzija DO
2344     -prepisati sve od pocetka originalne
2345      procedure do prvog rekurzivnog poziva
2346     -staviti na stek potrebne
2347      lokalne promenljive, parametre procedure i
2348      adresu mesta poziva
2349     -podesiti vrednosti parametara da budu
2350      kao u rekurzivnom pozivu procedure
2351   END;
2352   trivijalan poziv
2353   umesto RETURN x pisati rez := x
2354   jos := TRUE;
2355   WHILE jos AND NOT Empty(S) DO
2356     Top(S, el, ok);
2357     Pop(S, ok);
2358     -restauriramo vrednosti sa steka
2359     -u zavisnosti od adrese poziva nastavimo
2360      prepisivanje originalne procedure sa
2361      tog mesta
2362     -ako se dodje do novog rek. poziva tada:
2363        -sacuvati na steku vrednosti
2364        -podesiti vrednosti parametara da budu
2365         kao u rekurzivnom pozivu procedure
2366        -ici na pocetak koda
2367         (ovo se postize sa jos := FALSE)
2368     -inace
2369        ako se naidje na RETURN x pisati rez := x
2370   END
2371 UNTIL Empty(S);
2372 \end{lstlisting}
2373
2374 Ako je procedura funkcijska tada se na kraj dodaje \kod{RETURN rez}.
2375
2376 \subsection*{ZADACI}
2377
2378 Simulirati ponašanje sledećih rekurzivnih procedura (funkcija) upotrebom steka:
2379
2380 \subsection{Primer 1 -- faktorijel}
2381
2382
2383 \begin{lstlisting}[style=codeblock]
2384 MODULE Fakto;
2385 (* InfoTip = CARDINAL; *)
2386
2387 FROM IO IMPORT WrStr, WrLn, WrCard, RdCard;
2388 FROM StekC IMPORT StekTip, MakeNull, Empty,
2389                   Top, Pop, Push;
2390 VAR
2391   n : CARDINAL;
2392 PROCEDURE RFakto(n : CARDINAL) : CARDINAL;
2393 BEGIN
2394   IF n <= 1 THEN
2395     RETURN 1
2396   ELSE
2397     RETURN n * RFakto(n-1)
2398   END
2399 END RFakto;
2400
2401
2402 PROCEDURE SFakto(n : CARDINAL) : CARDINAL;
2403 VAR
2404   s : StekTip;
2405   rez : CARDINAL;
2406   OK : BOOLEAN;
2407 BEGIN
2408   MakeNull(s);
2409   WHILE n > 1 DO
2410     Push(s,n,OK);
2411     DEC(n)
2412   END;
2413   rez := 1;
2414   WHILE NOT Empty(s) DO
2415     Top(s, n, OK);
2416     Pop(s, OK);
2417     rez := n * rez
2418   END;
2419   RETURN rez
2420 END SFakto;
2421
2422 BEGIN
2423   WrStr('n = ');
2424   n := RdCard();
2425   WrLn
2426   WrStr('n! = ');
2427   WrCard(RFakto(n), 1);
2428   WrStr(' = ');
2429   WrCard(SFakto(n), 1)
2430 END Fakto.
2431 \end{lstlisting}
2432
2433 \subsection{Primer 2 -- stepenovanje}
2434
2435 \begin{lstlisting}[style=codeblock]
2436 MODULE Step;
2437 (* InfoTip = RECORD
2438                 x : REAL;
2439                 n : CARDINAL;
2440                 adr : (par, nepar)
2441              END;
2442 *)
2443
2444 FROM IO IMPORT WrStr, WrLn, WrReal,
2445         RdReal, RdCard;
2446 FROM StekStep IMPORT StekTip, MakeNull, Empty,
2447              Top, Pop, Push, InfoTip, AdrTip;
2448
2449 VAR
2450   n : CARDINAL;
2451   x : REAL;
2452
2453 PROCEDURE Sqr(y : REAL) : REAL;
2454 BEGIN
2455   RETURN y * y
2456 END Sqr;
2457
2458 PROCEDURE RStep(x : REAL;
2459                 n : CARDINAL) : REAL;
2460 BEGIN
2461   IF n = 0 THEN
2462     RETURN 1.
2463   ELSIF ODD(n) THEN
2464     RETURN x * Sqr( RStep(x, n DIV 2) )
2465   ELSE
2466     RETURN Sqr( RStep(x, n DIV 2) )
2467   END
2468 END RStep;
2469
2470 PROCEDURE SStep(x : REAL;
2471                 n : CARDINAL ) : REAL;
2472 VAR
2473   s : StekTip;
2474   OK : BOOLEAN;
2475   rez : REAL;
2476   el : InfoTip;
2477 BEGIN
2478   MakeNull(s);
2479   WHILE n > 0 DO
2480     el.x := x;
2481     el.n := n;
2482     IF ODD(n) THEN
2483       el.adr := nepar;
2484     ELSE
2485       el.adr := par
2486     END;
2487     Push(s,el,OK);
2488     n := n DIV 2
2489   END;
2490   rez := 1.;
2491   WHILE NOT Empty(s) DO
2492     Top(s, el, OK);
2493     Pop(s, OK);
2494     x := el.x;
2495     n := el.n;
2496     IF el.adr = nepar THEN
2497       rez := x * Sqr(rez)
2498     ELSE
2499       rez := Sqr(rez)
2500     END
2501   END;
2502   RETURN rez
2503 END SStep;
2504
2505 BEGIN
2506   WrStr('x =? ');
2507   x := RdReal();
2508   WrLn;
2509   WrStr('n =? ');
2510   n := RdCard();
2511   WrStr('x^n = ');
2512   WrReal(RStep(x, n), 10, 1);
2513   WrStr(' = ');
2514   WrReal(SStep(x, n), 10, 1)
2515 END Step.
2516 \end{lstlisting}
2517
2518 \subsection{Primer 3 -- Fibonači}
2519
2520 \begin{lstlisting}[style=codeblock]
2521 MODULE Fib;
2522 (* InfoTip = RECORD
2523                 n : CARDINAL;
2524                 PrviSab : CARDINAL;
2525                 adr : (prvi, drugi)
2526              END;
2527 *)
2528
2529 FROM IO IMPORT WrStr, WrLn, WrCard, RdCard;
2530 FROM StekFib IMPORT StekTip, MakeNull, Empty,
2531        Top, Pop, Push, InfoTip, AdrTip;
2532 VAR
2533   n : CARDINAL;
2534
2535 PROCEDURE RFib(n : CARDINAL) : CARDINAL;
2536 BEGIN
2537   IF n <= 1 THEN
2538     RETURN n
2539   ELSE
2540     RETURN RFib(n-1) + RFib(n-2)
2541   END
2542 END RFib;
2543
2544 PROCEDURE SFib(n : CARDINAL ) : CARDINAL;
2545 VAR
2546   s : StekTip;
2547   OK, jos : BOOLEAN;
2548   rez, PrviSab : CARDINAL;
2549   el : InfoTip;
2550 BEGIN
2551   MakeNull(s);
2552   REPEAT
2553     WHILE n > 1 DO
2554       el.n := n;
2555       el.adr := prvi;
2556       Push(s,el,OK);
2557       DEC(n)
2558     END;
2559     rez := (n);
2560     jos := TRUE;
2561     WHILE (NOT Empty(s)) AND jos DO
2562       Top(s, el, OK);
2563       Pop(s, OK);
2564       n := el.n;
2565       IF el.adr = prvi THEN
2566         PrviSab := rez;
2567         el.n := n;
2568         el.adr := drugi;
2569         el.PrviSab := PrviSab;
2570         Push(s, el, OK);
2571         DEC(n, 2);
2572         jos := FALSE
2573       ELSE
2574         PrviSab := el.PrviSab;
2575         rez := PrviSab + rez
2576       END
2577     END
2578   UNTIL Empty(s);
2579   RETURN rez
2580 END SFib;
2581
2582 BEGIN
2583   WrStr('n =? ');
2584   n := RdCard();
2585   WrStr('F(n) = ');
2586   WrCard(RFib(n), 1);
2587   WrStr(' = ');
2588   WrCard(SFib(n), 1)
2589 END Fib.
2590 \end{lstlisting}
2591
2592 \subsection{Primer 4 -- faktorijel 2}
2593
2594
2595 \begin{lstlisting}[style=codeblock]
2596 MODULE Faktor;
2597 (* InfoTip = CARDINAL; *)
2598 FROM IO IMPORT WrStr, WrLn, WrCard, RdCard;
2599 FROM StekC IMPORT StekTip, MakeNull, Empty,
2600                   Top, Pop, Push;
2601
2602 VAR
2603   n,rez : CARDINAL;
2604
2605 PROCEDURE RFakto(n : CARDINAL;
2606                  VAR rez : CARDINAL);
2607 BEGIN
2608   IF n = 0 THEN
2609     rez := 1
2610   ELSE
2611     RFakto(n-1, rez);
2612     rez := n * rez
2613   END
2614 END RFakto;
2615
2616 PROCEDURE SFakto(n : CARDINAL;
2617                  VAR rez : CARDINAL);
2618 VAR
2619   s : StekTip;
2620   OK : BOOLEAN;
2621 BEGIN
2622   MakeNull(s);
2623   WHILE n > 0 DO
2624     Push(s,n,OK);
2625     DEC(n)
2626   END;
2627   rez := 1;
2628   WHILE NOT Empty(s) DO
2629     Top(s, n, OK);
2630     Pop(s, OK);
2631     rez := n * rez
2632   END
2633 END SFakto;
2634
2635 BEGIN
2636   WrStr('n =? ');
2637   n := RdCard();
2638   WrLn;
2639   WrStr('n! = ');
2640   RFakto(n, rez);
2641   WrCard(rez, 1);
2642   WrStr(' = ');
2643   SFakto(n, rez);
2644   WrCard(rez, 1)
2645 END Faktor.
2646 \end{lstlisting}
2647
2648 \subsection{Primer 5 (ispitni)}
2649
2650
2651 \begin{lstlisting}[style=codeblock]
2652 MODULE Rek1;
2653 (* InfoTip = RECORD
2654                 d, g, m1, m2 : INTEGER;
2655                 adr : (prvi, drugi)
2656              END;
2657 *)
2658 FROM Stek1 IMPORT StekTip, adresa, InfoTip,
2659          MakeNull, Empty, Top, Pop, Push;
2660 IMPORT IO;
2661 VAR
2662   X : ARRAY [1..20] OF INTEGER;
2663
2664 PROCEDURE Max(d, g: INTEGER) : INTEGER;
2665 VAR
2666   m1, m2 : INTEGER;
2667 BEGIN
2668   IF d>g THEN
2669     RETURN MIN(INTEGER)
2670   ELSIF d=g THEN
2671     RETURN X[d]
2672   ELSE
2673     m1 := Max(d, (d+g) DIV 2);
2674     m2 := Max((d+g) DIV 2 +1, g);
2675     IF m1 > m2 THEN
2676       RETURN m1
2677     ELSE
2678       RETURN m2
2679     END
2680   END
2681 END Max;
2682
2683 PROCEDURE SMax(d, g: INTEGER) : INTEGER;
2684 VAR
2685   S : StekTip;
2686   el : InfoTip;
2687   ok, jos : BOOLEAN;
2688   m1, m2, rez : INTEGER;
2689 BEGIN
2690   MakeNull(S);
2691   REPEAT
2692     WHILE d<g DO
2693       el.d := d;
2694       el.g := g;
2695       el.adr := prvi;
2696       Push(S, el, ok);
2697       g := (d+g) DIV 2
2698     END;
2699     IF d>g THEN
2700       rez := MIN(INTEGER)
2701     ELSE (* d=g *)
2702       rez := X[d]
2703     END;
2704     jos := TRUE;
2705     WHILE jos AND NOT Empty(S) DO
2706       Top(S, el, ok);
2707       Pop(S, ok);
2708       d := el.d;
2709       g := el.g;
2710       m1 := el.m1;
2711       IF el.adr = prvi THEN
2712         m1 := rez;
2713         el.m1 := m1;
2714         el.adr := drugi;
2715         Push(S, el, ok);
2716         d := (d+g) DIV 2 + 1;
2717         jos := FALSE
2718       ELSE (*el.adr = drugi*)
2719         m2 := rez;
2720         IF m1 > m2 THEN
2721           rez := m1
2722         ELSE
2723           rez := m2
2724         END
2725       END
2726     END
2727   UNTIL Empty(S);
2728   RETURN rez
2729 END SMax;
2730
2731 BEGIN (* glavni program *)
2732   X[1] := 3;
2733   X[2] := 2;
2734   X[3] := 5;
2735   X[4] := -7;
2736   X[5] := 0;
2737   IO.WrCard(Max(1, 5), 3);
2738   IO.WrLn;
2739   IO.WrCard(SMax(1, 5), 3);
2740   IO.WrLn
2741 END Rek1.
2742 \end{lstlisting}
2743
2744 \subsection{Primer 6 (ispitni)}
2745
2746
2747 \begin{lstlisting}[style=codeblock]
2748 MODULE Rek2;
2749 (* InfoTip = RECORD
2750                 x, y, n : CARDINAL;
2751                 adr : (prvi, drugi, treci, cetvrti)
2752              END;
2753 *)
2754 FROM Stek2 IMPORT StekTip, adresa, InfoTip,
2755            MakeNull, Empty, Top, Pop, Push;
2756 IMPORT IO;
2757
2758 PROCEDURE g(x : CARDINAL; y : CARDINAL;
2759             n : CARDINAL) : CARDINAL;
2760 BEGIN
2761   IF n < 3 THEN
2762     RETURN x + y
2763   ELSIF ODD(n) THEN
2764     RETURN g(g(x+1, y, n-2), y, n-3)
2765   ELSE
2766     RETURN g(x, g(x, y+1, n-2), n-3)
2767   END
2768 END g;
2769
2770 PROCEDURE Sg(x : CARDINAL; y : CARDINAL;
2771              n : CARDINAL) : CARDINAL;
2772 VAR
2773   S : StekTip;
2774   el : InfoTip;
2775   ok, jos : BOOLEAN;
2776   rez : CARDINAL;
2777 BEGIN
2778   MakeNull(S);
2779   REPEAT
2780     WHILE n >= 3 DO
2781       IF ODD(n) THEN
2782         el.x := x;
2783         el.y := y;
2784         el.n := n;
2785         el.adr := prvi;
2786         Push(S, el, ok);
2787         INC(x);
2788         DEC(n, 2)
2789       ELSE
2790         el.x := x;
2791         el.y := y;
2792         el.n := n;
2793         el.adr := treci;
2794         Push(S, el, ok);
2795         INC(y);
2796         DEC(n, 2)
2797       END
2798     END;
2799     rez := x+y;
2800     jos := TRUE;
2801     WHILE jos AND NOT Empty(S) DO
2802       Top(S, el, ok);
2803       Pop(S, ok);
2804       x := el.x;
2805       y := el.y;
2806       n := el.n;
2807       IF el.adr = prvi THEN
2808         el.adr := drugi;
2809         Push(S, el, ok);
2810         x := rez;
2811         DEC(n, 3);
2812         jos := FALSE
2813       ELSIF el.adr = treci THEN
2814         el.adr := cetvrti;
2815         Push(S, el, ok);
2816         y := rez;
2817         DEC(n, 3);
2818         jos := FALSE
2819       END
2820     END
2821   UNTIL Empty(S);
2822   RETURN rez
2823 END Sg;
2824
2825 BEGIN (* glavni program *)
2826   IO.WrCard(g(2, 3, 10), 3);
2827   IO.WrCard(Sg(2, 3, 10), 3);
2828 END Rek2.
2829 \end{lstlisting}
2830
2831 %\columnbreak
2832
2833 \appendix
2834
2835 \section{Native XDS Modula 2 -- kratko uputstvo}
2836
2837
2838 Ovo uputstvo ukratko pokriva kako se može nabaviti XDS Modula 2 za Windows
2839 sistem, njenu instalaciju, te kako napraviti i pokretnuti jednostavan program.
2840
2841 \subsection*{Dobavljanje instalacije}
2842
2843
2844 Native XDS Modula 2 se može besplatno skinuti sa sajta proizvođača,
2845 \url{http://www.excelsior-usa.com/}, tačnije na adresi:
2846
2847 \url{http://www.excelsior-usa.com/xdsdl.html}
2848
2849 Prvo se prikazuje ugovor o korišćenju koji na dnu treba potvrditi da ste
2850 razumeli i da ćete ga se pridržavati.
2851
2852 Na stranici koja se potom otvara je potrebno odabrati sledeće pakete za
2853 download:
2854
2855 * Native XDS-x86 2.51 for Windows (6.5MB)
2856 \url{http://www.excelsior-usa.com/download/xds25x/xds-x86-251-enduser-win32.exe}
2857
2858 * TSCP add-on (2.4MB)
2859 \url{http://www.excelsior-usa.com/download/xds25x/tscp-x86-251-enduser-win32.exe}
2860
2861 \subsection*{Instalacija okruženja}
2862
2863 Prvo treba instalirati osnovno okruženje (xds-x86...), a potom i Top
2864 Speed Compatibility Pack (tscp-x86...), koji je potreban za neke
2865 module koji se koriste.
2866
2867 \emph{Korisnicima Windows-a 7 preporučujemo da pokrenu instalacione
2868   pakete pomoću opcije ``Run as administrator'' do koje se stiže desnim
2869   klikom miša.}
2870
2871 Pretpostavićemo u daljem tekstu da je program instaliran u
2872 \kod{C:/XDS/}
2873
2874 \subsection*{Pokretanje okruženja}
2875
2876 Po uspešnoj instalaciji bi trebalo da postoji ikonica na desktopu, kao
2877 i grupa sa programom u start meniju.
2878
2879 Ukoliko iz bilo kakvog razloga ne postoje odgovarajuće prečice,
2880 okruženje se može pokrenuti uz pomoć izvršnog fajla
2881 \kod{C:/XDS/BIN/xds.exe} (ako je instalirano na podrazumevanoj
2882 lokaciji).
2883
2884 \subsection*{Prvi projekat}
2885
2886 Da bismo mogli da pišemo i pokrećemo svoj program, potrebno je prvo
2887 napraviti projekat za njega, što se radi na sledeći način:
2888
2889 \begin{itemize}
2890
2891 \item
2892  Iz menija se odabere Project->New.
2893 \item U dijalogu se klikne na gornje dugme ``Browse'', odabere se putanja gde
2894   će se kreirati projekat i ukuca se ime novog projekta.
2895
2896 \item U drugom polju ``Template'' ne treba da piše ništa. Ukoliko
2897   postoji neki tekst, obrisati ga.
2898
2899 \item Kliknuti na ``OK''
2900
2901 \item Iskočiće dijalog na kome piše da ne postoji fajl za editovanje,
2902   kliknuti na ``OK'' da se on napravi.
2903
2904 \item Pojavljuje se forma za kucanje programa, ukucati (na primer):
2905
2906 \begin{minipage}{\columnwidth}
2907 \begin{lstlisting}[style=codeblock]
2908   MODULE Hello;
2909   FROM InOut IMPORT WriteString,WriteLn;
2910   BEGIN
2911     WriteString("Hello World");
2912     WriteLn;
2913   END Hello.
2914 \end{lstlisting}
2915 \end{minipage}
2916
2917 \item Program se može pokrenuti na različite načine, pri čemu se
2918   automatski prevodi:
2919
2920   \begin{itemize}
2921
2922   \item Klik na ``Run'' ikonicu u toolbaru (plavi čovečuljak koji trči)
2923
2924   \item Meni Debug->Run
2925
2926   \item Prečica Ctrl+F9 na tastaturi
2927
2928   \end{itemize}
2929
2930 \item Ako je sve u redu sa programom, treba da se pojavi novi terminal
2931   u kome se ispisuje rezultat izvršavanja programa, u našem slučaju
2932   jednostavna pozdravna poruka.
2933 \end{itemize}
2934
2935 Naravno moguće je i samo prevesti (kompajlirati) program, tako da se
2936 samo prikažu greške (ako ih ima) i bez pokretanja programa:
2937 \begin{itemize}
2938 \item Klik na ``Compile'' ikonicu u toolbaru
2939 \item Meni Tools->Compile
2940 \item Prečica F9 na tastaturi
2941 \end{itemize}
2942
2943 Ukoliko u programu postoje greške, on neće biti pokrenut, već će se
2944 dobiti lista grešaka u donjem delu prozora. Na primer ako obrišemo ``S''
2945 u četvrtom redu i probamo da pokrenemo program, taj red će biti
2946 označen svetlo plavom bojom i dobićemo poruku:
2947
2948 \kod{- Error in pro1.mod [4:5]: Undeclared identifier "Writeting"}
2949
2950 Što znači da u četvrtom redu, kod petog karatkera postoji problem, da
2951 identifikator nije deklarisan, što najčešće znači da ga nismo uvezli,
2952 ili, kao u našem slučaju, da smo napravili grešku u kucanju.
2953
2954 Stvar na koju isto treba obratiti pažnju je da se nekad greška
2955 prijavljue nešto kasnije u tekstu nego što je napravljena. Na primer,
2956 ako obrišemo ``;'' na kraju četvrtog reda i probamo da pokrenemo
2957 program, peti red će biti označen svetlo plavom bojom i dobićemo
2958 poruku:
2959
2960 \kod{- Error in pro1.mod [5:5]: Expected symbol ";" }
2961
2962 Ovo se desilo jer nedostaje tačka zarez na kraju četvrtog reda, ali će
2963 kompajler probati da je traži i dalje, pa će tek na početku petog reda
2964 prijaviti grešku.
2965
2966 U spisku se takođe pojavljuje i upozorenje (Warning) o tome da se
2967 uvezena komanda WriteString ne koristi nigde u programu. Često se
2968 upozorenja mogu ignorisati, a pažnju uglavnom treba obraćati na
2969 greške, odnosno poruke koje počinju sa ``Error''.
2970
2971 Takođe se često dešava da su druge prijavljene greške posledica prve,
2972 te je poželjno ponovo kompajlirati (ili pokretati) program posle svake
2973 ispravljene greške.
2974
2975 \paragraph{Napomena o template-ovima pri kreiranju projekta:}
2976 Moguće je namestiti da u dijalogu za novi projekat drugo polje ``Template''
2977  uvek bude prazno. Potrebno je u tom istom dijalogu kliknuti na
2978  ``Configure'', a potom isprazniti polje ``default template''.
2979
2980
2981 \mainend
2982
2983 \end{document}