w12

Programy pomocnicze: diff, make, systemy rcs
i cvs, debugger. Zarz¡dzanie wersjami.
wer. 8 z drobnymi mody kacjami
Wojciech Myszka
2014-02-09 16:32:37 +0100
Co jest potrzebne programi±cie?
1. Umiej¦tno±¢ logicznego my±lenia.
2. Uko«czone kursy doksztaªcaj¡ce.
3. Motywacja do pracy.
4. Komputer.
5. Zadanie.
6. Kompilator (program, który kod ¹ródªowy przetªumaczy na
na kod maszynowy).
7. Jaki± edytor (program pozwalaj¡cy na wygodne wpisywanie
kodu ¹ródªowego).
Jak to robiono kiedy±?
1. Czas komputera byª drogi a dost¦p do niego limitowany.
2. Gdy algorytm byª gotowy rozpoczynaªo si¦ jego kodowanie (na
papierze).
3. Nast¦pnie przenoszono kod na no±nik maszynowy (ta±ma papierowa,
karty perforowane, ta±ma magnetyczna).
4. No±nik z kodem ¹ródªowym byª czytany przez kompilator, który tªumaczyª
na posta¢ maszynow¡; w razie bª¦dów byªy one zaznaczane na wydruku.
5. W przypadku bª¦dów formalnych koder poprawiaª je i zaczynaª cykl od
pocz¡tku.
6. Gdy bª¦dów nie byªo nast¦powaªo uruchomienie programu (na
dostarczonych danych).
7. Wyniki otrzymywaª programista i sprawdzaª czy s¡ zgodne
z oczekiwaniami. Je»eli nie rozpoczynaªa si¦ »mudna analiza
algorytmu. Program byª uruchamiany po raz kolejny na danych
testowych. ›eby uªatwi¢ sobie prac¦ dodawano wydruki kontrolne .
8. I tak do skutku.
Praca w ±rodowisku interaktywnym
1. Najpierw odpadªy no±niki maszynowe (cho¢ w okresie
przej±ciowym znacznie taniej byªo wpisa¢ kod na
prymitywnym urz¡dzeniu na kartach lub tasiemce
papierowej ni» blokowa¢ dost¦p do de cytowego terminala
komputera i linii telekomunikacyjnej.
2. Pojawiªy si¦ ±rodowiska uªatwiaj¡ce uruchamianie
programów w trybie interaktywnym.
3. Pojawiªy si¦ j¦zyki konwersacyjne.
Jak jest dzi±?
Ci z Pa«stwa, którzy programuj¡
wiedz¡ doskonale. Inni. . .
Jak jest tworzony du»y program?
1. Podzielony jest na kawaªki (moduªy obejmuj¡ce pewne
dobrze zde niowane caªo±ci ).
2. Grupy moduªów tworz¡ce pewne caªo±ci
w biblioteki .
grupowane s¡
3. Wspólne de nicje grupowane s¡ w plikach
nagªówkowych .
Kompilacja
Tworzenie programu jest procesem wieloetapowym.
1. Fragmenty programu mog¡ by¢ pisane w jakim±
metaj¦zyku, który tªumaczony jest na kod ¹ródªowy.
2. Program w kodzie ¹ródªowym tªumaczony jest na posta¢
wynikow¡ (zazwyczaj nazywa si¦ to object).
3. Niektóre moduªy wynikowe grupowane s¡ w biblioteki.
4. Moduªy wynikowe i biblioteki u»ywane s¡ do budowy
programu wykonywalnego.
Schemat
metajęzyk1 -->
+
|
+
pliki nagł---+
kod
kod
kod
kod
źródłowy1
źródłowy2
źródłowy3
źródłowy4
-->
-->
-->
-->
object1
object2
object3
object4
+
+--> biblioteka1 +
+
--->exe
--------------> +
Program make
Jakakolwiek zmiana w plikach z kodem metaj¦zyka, plikach
nagªówkowych lub z kodem ¹ródªowym wymaga
przekompilowania cz¦±ci lub wszystkich plików.
Gdy projekt jest bardzo du»y problem jest bardzo powa»ny.
Wymy±lono program make pozwalaj¡cy uªatwiaj¡cy
programi±cie »ycie.
Program korzysta ze specjalnego pliku (tradycyjnie nazywa si¦
on Make le) który opisuje struktur¦ projektu.
Make le
Plik Make le de niuje czynno±ci jakie nale»y wykona¢ aby
z pliku jednego typu uzyska¢ plik wynikowy oraz zale»no±ci
pomi¦dzy plikami.
metajęzyk1 -->
+
|
+
pliki nagł---+
kod
kod
kod
kod
źródłowy1
źródłowy2
źródłowy3
źródłowy4
-->
-->
-->
-->
object1
object2
object3
object4
+
+--> biblioteka1 +
+
--->exe
--------------> +
W naszym przypadku exe zale»y od biblioteka1 i object4.
biblioteka1 zale»y od object1, object2, object3.
object1 zale»y od kod ¹ródªowy1.
kod ¹ródªowy1 zale»y od metaj¦zyk1.
object2 zale»y od kod ¹ródªowy2
object3 zale»y od kod ¹ródªowy3
kod ¹ródªowy2 zale»y plik nagª
Przykªadowy plik Make le
albo raczej jego idea
exe :
b i b l i o t e k a 1 , object4
l i n k −o exe object4 −L b i b l i o t e k a 1
biblioteka1 :
object1 , object2 , object3
ar −o b i b l i o t e k a 1 object1 object2 object3
object1 :
kod ¹ r ód ª owy1
kompiluj kod ¹ r ód ª owy1
object2 :
kod ¹ r ód ª owy2 , p l i k nag ª
kompiluj kod ¹ r ód ª owy2
object3 :
kod ¹ r ód ª owy3 , p l i k nag ª
kompiluj kod ¹ r ód ª owy3
object4 :
kod ¹ r ód ª owy4 , p l i k nag ª
kompiluj kod ¹ r ód ª owy4
kod ¹ r ód ª owy1 :
all :
metaj¦ zyk1
metakompiluj metaj¦ zyk1 −o kod ¹ r ód ª owy1
exe
clea n :
k a s u j o b j e c t ∗ b i b l i o t e k a 1 exe p l i k ¹ r ód ª owy1
Metaj¦zyki
1. Metaj¦zyki to j¦zyki jeszcze wy»szego poziomu ni» j¦zyki typu
C, Pascal, Fortan.
2. Pozwalaj¡ one za pomoc¡ stosunkowo prostych zale»no±ci (i bez
przejmowania si¦ szczegóªami) stworzy¢ kod ¹ródªowy programu
.
3. Przykªad. Chcemy napisa¢ program, który b¦dzie rozró»niaª
liczby od sªów.
I
I
Najpierw precyzyjnie musimy zde niowa¢ co to jest liczba.
Liczba to jedna lub wi¦cej cyfr z zakresu od 0 do 9. W kategoriach
wyra»e« regularnych mo»na to zapisa¢ tak: [0123456789]+ lub
[0-9]+ (plus oznacza tu jedno lub wi¦cej powtórze«).
Natomiast sªowo to jeden lub wi¦cej znaków, z których pierwszy
jest liter¡ i który nie zawiera odst¦pów i innych znaków
specjalnych. Zapisujemy to tak: [a-zA-Z][a-zA-Z0-9]* (gwiazdka
oznacza tu zero lub wi¦cej powtórze«.
Metaj¦zyki
ex
Idea programu jest nast¦puj¡ca:
%%
[0123456789]+
[ a−zA−Z ] [ a−zA−Z0 −9]∗
%%
p r i n t f ( " NUMBER \ n " ) ;
p r i n t f ( "WORD\ n " ) ;
i sprowadza si¦ do nast¦puj¡cego: jak zobaczysz liczb¦
wypisz liczba, jak zobaczysz wyraz wypisz wyraz
A sam program niewiele bardziej skomplikowany:
%{
# include < s t d i o . h>
%}
%%
[0123456789]+
[ a−zA−Z ] [ a−zA−Z0 −9]∗
%%
p r i n t f ( " NUMBER \ n " ) ;
p r i n t f ( "WORD\ n " ) ;
Kompilacja:
f l e x −o t e s t . c t e s t . l
~/ c$ l s −l t e s t . c
−rw−r−−r−− 1 myszka myszka 41749 2008−05−26 15:50 t e s t . c
gcc t e s t . c −o t e s t − l l
Uruchomienie
~/c$ ./test
ala ma 3 koty
WORD
WORD
NUMBER
WORD
Bardziej skomplikowany przykªad: kalkulator
1. Chodzi mi o pokazanie jednie pewnej idei, a nie wnikanie
w gª¦bokie szczegóªy.
2. Kalkulator skªada si¦ z dwu cz¦±ci:
2.1 wprowadzanie danych
2.2 przetwarzanie danych
3. Do zbudowania analizatora danych wykorzystamy program
lex (lub jego darmowy odpowiednik ex)
4. Do zbudowania cz¦±ci przetwarzaj¡cej dane wykorzystamy
program yacc (lub jego darmowy odpowiednik bison)
Kalkulator I
Wprowadzanie danych
/∗ c a l c u l a t o r #1 ∗/
%{
# i n c l u d e " y . tab . h "
# i n c l u d e < s t d l i b . h>
void y y e r r o r ( char ∗ ) ;
%}
%%
[0 −9]+
{
y yl va l = atoi ( yytext ) ;
return INTEGER ;
}
Kalkulator II
Wprowadzanie danych
[ −+\n ]
{ return ∗ y y t e x t ; }
[ \t]
;
.
y y e r r o r ( " Unknown c h a r a c t e r " ) ;
%%
i n t yywrap ( void ) {
return 1 ;
}
/∗ s k i p whitespace ∗/
Kalkulator I
Przetwarzanie
%{
# i n c l u d e < s t d i o . h>
i n t y y l e x ( void ) ;
void y y e r r o r ( char ∗ ) ;
%}
%token INTEGER
%%
program :
program expr ' \ n '
|
{ p r i n t f ( " %d \ n " ,
Kalkulator II
Przetwarzanie
;
expr :
INTEGER
| expr ' + ' expr
| expr '−' expr
;
%%
void y y e r r o r ( char ∗ s ) {
f p r i n t f ( s t d e r r , " %s \ n " , s ) ;
}
{ $$ = $1 + $3 ; }
{ $$ = $1 − $3 ; }
Kalkulator III
Przetwarzanie
i n t main ( void ) {
yyparse ( ) ;
return 0 ;
}
Czterodziaªaniowy kalkulator z nawiasami I
Dane
%{
# include < s t d l i b . h>
# include < s t d i o . h>
# include " c a l c 1 . h "
void y y e r r o r ( char ∗ ) ;
extern i n t y y l v a l ;
%}
%%
[ \ t ]+
;
[0 −9]+
{ y yl va l = atoi ( yytext ) ;
return INTEGER ; }
[ −+∗/]
{ return ∗ y y t e x t ; }
"("
{ return ∗ y y t e x t ; }
Czterodziaªaniowy kalkulator z nawiasami II
Dane
")"
\n
.
{ return ∗ y y t e x t ; }
{ return ∗ y y t e x t ; }
{ char msg [ 2 5 ] ;
s p r i n t f ( msg , " %s <%s > " , " i n v a l i d c h a r a c t e
y y e r r o r ( msg ) ; }
Czterodziaªaniowy kalkulator z nawiasami I
Przetwarzanie
%{
# include < s t d l i b . h>
# include < s t d i o . h>
i n t y y l e x ( void ) ;
# include " c a l c 1 . h "
%}
%token INTEGER
%%
program :
l i n e program
| line
line :
Czterodziaªaniowy kalkulator z nawiasami II
Przetwarzanie
expr ' \ n ' { p r i n t f ( " %d \ n " , $1 ) ; }
| ' \n'
expr :
expr ' + ' mulex { $$ = $1 + $3 ; }
| expr '−' mulex { $$ = $1 − $3 ; }
| mulex { $$ = $1 ; }
mulex :
mulex ' ∗ ' term { $$ = $1 ∗ $3 ; }
| mulex ' / ' term { $$ = $1 / $3 ; }
| term { $$ = $1 ; }
Czterodziaªaniowy kalkulator z nawiasami III
Przetwarzanie
term :
' ( ' expr ' ) ' { $$ = $2 ; }
| INTEGER { $$ = $1 ; }
%%
void y y e r r o r ( char ∗ s )
{
f p r i n t f ( s t d e r r , " %s \ n " , s ) ;
return ;
}
i n t main ( void )
{
/∗ yydebug =1; ∗/
yy parse ( ) ;
Czterodziaªaniowy kalkulator z nawiasami IV
Przetwarzanie
return 0 ;
}
Narzedzia pomocnicze
1. diff program pozwalaj¡cy porównywa¢ dwa pliki ¹ródªowe
2. patch program pozwalaj¡cy na podstawie ró»nic
(raportowanych przez diff) wprowadzi¢ poprawki do plików
¹ródªowych. Pozwala to rozpowszechnia¢ znacznie mniejsze
pliki.
3. rcs, cvs, svn, bazaar, . . .
wersjami.
systemy zarz¡dzania
4. debuger program pozwalaj¡cy uruchamia¢ programy
krok po kroku, sprawdza¢ zawarto±¢ zmiennych,. . .
con gure
I
I
I
I
Pliki dla programu make mog¡ by¢ przygotowywane r¦cznie.
Gdy tworzymy wersj¦ programu która powinna by¢ zbudowana
w (nieomal) dowolnym ±rodowisku, mo»e si¦ okaza¢, »e
budowa programu wymaga speªnienia pewnych dodatkowych
zale»no±ci (które nie musz¡ by¢ speªnione standardowo).
W takim przypadku warto skorzysta¢ z dodatkowych narz¦dzi
pomocniczych. Jednym z nich jest Autotools.
Narz¦dzie to skªada si¦ z szeregu skryptów, które po
uruchomieniu sprawdzaj¡ w jakim ±rodowisku budowane jest
oprogramowanie, staraj¡ si¦ zidenty kowa¢ zale»no±ci od
dodatkowych pakietów oprogramowania (bibliotek) i tworz¡
skrypt (program), który uruchomiony na systemie docelowych
sprawdza czy wszystkie zale»no±ci s¡ speªnione.