char *string = "abvgdezhziklmnop";

            setlocale(LC_ALL, "");

            for(;c = *string;string++){
    #ifdef DEBUG
                    printf("%c %d %d\n", *string, *string, c);
    #endif
                    if(isprint(c)) printf("%c - pechatnyj simvol\n", c);
            }
            return 0;
    }

|ta programma neozhidanno pechataet

    % a.out
    v - pechatnyj simvol
    z - pechatnyj simvol

I vse.  V chem delo???
Rassmotrim k primeru simvol 'g'. Ego kod '\307'.  V operatore

    c = *string;

Simvol c poluchaet znachenie -57 (desyatichnoe), kotoroe OTRICATELXNO.  V sistemnom fajle
/usr/include/ctype.h makros <i>isprint</i> opredelen tak:

    #define isprint(c)      ((_ctype + 1)[c] & (_P|_U|_L|_N|_B))

I znachenie c ispol'zuetsya v nashem sluchae kak  otricatel'nyj  indeks  v  massive,  ibo
indeks  privoditsya  k  tipu <i>int</i> (<i>signed</i>). Otkuda teper' izvlekaetsya znachenie flagov -
nam neizvestno; mozhno tol'ko s uverennost'yu skazat', chto NE iz massiva _<i>ctype</i>.




<i>A. Bogatyrev, 1992-95                  - 129 -                              Si v UNIX</i>

Problemu reshaet libo ispol'zovanie

    isprint(c & 0xFF)

libo

    isprint((<i>unsigned char</i>) c)

libo ob®yavlenie v nashem primere

    <i>unsigned</i> char c;

V pervom sluchae my yavno privodim <i>signed</i> k <i>unsigned</i> bitovoj operaciej, obnulyaya  lishnie
bity.   Vo vtorom i tret'em - <i>unsigned char</i> rasshiryaetsya v <i>unsigned int</i>, kotoryj osta-
netsya polozhitel'nym. Veroyatno, vtoroj put' predpochtitel'nee.

<i>3.12.</i>  Itak, snova napomnim, chto russkie bukvy <i>char</i>, a ne <i>unsigned char</i> dayut  otrica-
tel'nye indeksy v massive.

    char c = 'g';
    int x[256];

            ...x[c]...            /* indeks &lt; 0 */
            ...x['g']...

Poetomu bajtovye indeksy dolzhny byt' libo <i>unsigned char</i>, libo <i>& 0xFF</i>.  Kak v  sleduyu-
shchem primere:

    /* Programma preobrazovaniya simvolov v fajle: transliteraciya
                      <i>tr</i> abcd prst  zamenyaet stroki
                      xxxxdbcaxxxx -> xxxxtrspxxxx
       Po motivam knigi M.Dansmura i G.Dejvisa.
    */
    #include &lt;stdio.h>

    #define ASCII 256 /* chislo bukv v alfavite ASCII */
    /* BUFSIZ opredeleno v stdio.h */
    char mt[ ASCII ];       /* tablica perekodirovki */

    /* nachal'naya razmetka tablicy */
    void <i>mtinit</i>(){
            register int i;
            for( i=0; i &lt; ASCII; i++ )
                    mt[i] = (char) i;
    }



















<i>A. Bogatyrev, 1992-95                  - 130 -                              Si v UNIX</i>

    int <i>main</i>(int argc, char *argv[])
    {
            register char *tin, *tout; /* unsigned char */
            char buffer[ BUFSIZ ];

            if( argc != 3 ){
                    fprintf( stderr, "Vyzov: %s chto naCHto\n", argv[0] );
                    return(1);
            }
            tin  = argv[1]; tout = argv[2];

            if( strlen(tin) != strlen(tout)){
                    fprintf( stderr, "stroki raznoj dliny\n" );
                    return(2);
            }

            mtinit();
            do{
                    mt[ (*tin++) & 0xFF ]  = *tout++;
                    /*   *tin - imeet tip char.
                     *   & 0xFF podavlyaet rasshirenie znaka
                     */
            } while( *tin );

            tout = mt;
            while( fgets( buffer, BUFSIZ, stdin ) != NULL ){
                    for( tin = buffer; *tin; tin++ )
                            *tin = tout[ *tin & 0xFF ];
                    fputs( buffer, stdout );
            }
            return(0);
    }


<i>3.13.</i>

    int main(int ac, char *av[]){
            char c = 'g';
            if('a' &lt;= c && c &lt; 256)
                    printf("|to odna bukva.\n");
            return 0;
    }

Uvy, eta programma ne pechataet NICHEGO. Prosto potomu, chto <i>signed char</i> v sravnenii  (v
operatore <i>if</i>) privoditsya k tipu <i>int</i>.  A kak celoe chislo - russkaya bukva otricatel'na.
Snova  resheniem  yavlyaetsya  libo  ispol'zovanie  vezde  (c & 0xFF),  libo   ob®yavlenie
<i>unsigned char</i> c.   V chastnosti, etot primer pokazyvaet, chto NELXZYA prosto tak sravni-
vat' dve peremennye tipa <i>char</i>. Nuzhno prinimat' predohranitel'nye mery  po  podavleniyu
rasshireniya znaka:

    if((ch1 & 0xFF) &lt; (ch2 & 0xFF))...;

Dlya <i>unsigned char</i> takoj problemy ne budet.

<i>3.14.</i>  Pochemu neverno:









<i>A. Bogatyrev, 1992-95                  - 131 -                              Si v UNIX</i>

    #include &lt;stdio.h>
    main(){
            char c;

            while((c = getchar()) != EOF)
                    putchar(c);
    }

Potomu chto c opisano kak <i>char</i>, v to vremya kak <i>EOF</i> - znachenie tipa <i>int</i> ravnoe (-1).
     Russkaya bukva "Bol'shoj tverdyj znak" v kodirovke KOI-8 imeet kod '\377'  (0xFF).
Esli  my podadim na vhod etoj programme etu bukvu, to v sravnenii <i>signed char</i> so zna-
cheniem znakovogo celogo <i>EOF</i>, c budet privedeno tozhe k znakovomu celomu -  rasshireniem
znaka.   0xFF  prevratitsya  v (-1), chto oznachaet, chto postupil simvol <i>EOF</i>. Syurpriz!!!
Posemu dannaya programma budet delat' vid, chto v lyubom fajle s bol'shim russkim tverdym
znakom posle etogo znaka (i vklyuchaya ego) dal'she nichego net. CHto est' dosadnoe zabluzh-
denie.
     Resheniem sluzhit PRAVILXNOE ob®yavlenie <i>int</i> c.

<i>3.15.</i>  Izuchite povedenie programmy

    #define TYPE char

    void f(TYPE c){
            if(c == 'j') printf("|to bukva j\n");
            printf("c=%c c=\\%03o c=%03d c=0x%0X\n", c, c, c, c);
    }

    int main(){
            f('g'); f('j');
            f('z'); f('Z');
            return 0;
    }

kogda TYPE opredeleno kak <i>char</i>, <i>unsigned char</i>, <i>int</i>.  Ob®yasnite  povedenie.  Vydachi  v
etih treh sluchayah takovy (int == 32 bita):

    c=g c=\37777777707 c=-57 c=0xFFFFFFC7
    |to bukva j
    c=j c=\37777777712 c=-54 c=0xFFFFFFCA
    c=z c=\172 c=122 c=0x7A
    c=Z c=\132 c=090 c=0x5A

    c=g c=\307 c=199 c=0xC7
    c=j c=\312 c=202 c=0xCA
    c=z c=\172 c=122 c=0x7A
    c=Z c=\132 c=090 c=0x5A

    i snova kak 1 sluchaj.

Rassmotrite al'ternativu

            if(c == (unsigned char) 'j') printf("|to bukva j\n");

gde predpolagaetsya, chto znak u russkih bukv i u c NE rasshiryaetsya.   V  dannom  sluchae
fraza  '|to bukva j' ne pechataetsya ni s tipom <i>char</i>, ni s tipom <i>int</i>, poskol'ku v srav-
nenii c privoditsya k tipu <i>signed int</i> rasshireniem znakovogo bita  (kotoryj  raven  1).
Sleva poluchaetsya otricatel'noe chislo!
     V takih sluchayah vnov' sleduet pisat'

            if((unsigned char)c == (unsigned char)'j') printf("|to bukva j\n");




<i>A. Bogatyrev, 1992-95                  - 132 -                              Si v UNIX</i>

<i>3.16.</i>  Obychno voznikayut problemy pri napisanii funkcij s peremennym  chislom  argumen-
tov.   V yazyke Si eta problema reshaetsya ispol'zovaniem makrosov <i>va</i>_<i>args</i>, ne zavisyashchih
ot soglashenij o vyzovah funkcij na dannoj mashine, i ispol'zuyushchih eti  makrosy  speci-
al'nyh   funkcij.   Est'  dva  stilya  oformleniya  takih  programm:  s  ispol'zovaniem
&lt;varargs.h> i &lt;stdarg.h>.  Pervyj byl prodemonstrirovan v  pervoj  glave  na  primere
funkcii <i>poly</i>().  Dlya illyustracii vtorogo privedem primer funkcii trassirovki, zapisy-
vayushchej sobshchenie v fajl:

    #include &lt;stdio.h>
    #include &lt;stdarg.h>
    void <i>trace</i>(char *fmt, <i>...</i>) {
        <i>va</i>_<i>list</i> args;
        static FILE *fp = NULL;

        if(fp == NULL){
           if((fp = fopen("TRACE", "w")) == NULL) return;
        }
        <i>va</i>_<i>start</i>(args, fmt);
        /* vtoroj argument: arg-t posle kotorogo
         * v zagolovke funkcii idet <i>...</i> */
        <i>vfprintf</i>(fp, fmt, args); /* bibliotechnaya f-ciya */
        fflush(fp);     /* vytolknut' soobshchenie v fajl */
        <i>va</i>_<i>end</i>(args);
    }


    main(){ trace( "%s\n", "Go home.");
            trace( "%d %d\n", 12, 34);
    }

Simvol `...' (troetochie) v zagolovke funkcii oboznachaet peremennyj (vozmozhno  pustoj)
spisok  argumentov.  On  dolzhen  byt'  samym poslednim, sleduya za vsemi obyazatel'nymi
argumentami funkcii.
     Makros <i>va</i>_<i>arg</i>(args,type), izvlekayushchij iz  peremennogo  spiska  argumentov  `<i>...</i>'
ocherednoe  znachenie tipa type, odinakov v oboeh modelyah.  Funkciya <i>vfprintf</i> mozhet byt'
napisana cherez funkciyu <i>vsprintf</i> (v dejstvitel'nosti obe funkcii - standartnye):

    int <i>vfprintf</i>(FILE *fp, const char *fmt, <i>va</i>_<i>list</i> args){
        /*static*/ char buffer[1024]; int res;
        res = <i>vsprintf</i>(buffer, fmt, args);
        <i>fputs</i>(buffer, fp); return res;
    }

Funkciya <i>vsprintf</i>(str,fmt,args); analogichna funkcii <i>sprintf</i>(str,fmt,...) -  zapisyvaet
preobrazovannuyu po formatu stroku v bajtovyj massiv str, no ispol'zuetsya v kontekste,
podobnom privedennomu.  V konec sformirovannoj stroki <i>sprintf</i> zapisyvaet '\0'.

<i>3.17.</i>  Napishite funkciyu <i>printf</i>, ponimayushchuyu formaty <i>%c</i> (bukva), <i>%d</i> (celoe), <i>%o</i>  (vos'-
merichnoe),  <i>%x</i>  (shestnadcaterichnoe),  <i>%b</i>  (dvoichnoe),  <i>%r</i> (rimskoe), <i>%s</i> (stroka), <i>%ld</i>
(dlinnoe celoe).  Otvet smotri v prilozhenii.

<i>3.18.</i>  Dlya togo, chtoby odin i tot zhe ishodnyj tekst programmy translirovalsya na  raz-
nyh  mashinah  (v raznyh sistemah), prihoditsya vydelyat' v programme sistemno-zavisimye
chasti.  Takie chasti dolzhny po-raznomu vyglyadet' na raznyh mashinah, poetomu ih  oform-
lyayut v vide tak nazyvaemyh "uslovno kompiliruemyh" chastej:

    <i>#ifdef</i> XX
            ... variant1
    <i>#else</i>
            ... variant2
    <i>#endif</i>



<i>A. Bogatyrev, 1992-95                  - 133 -                              Si v UNIX</i>

|ta direktiva preprocessora vedet sebya sleduyushchim obrazom: esli makros s imenem XX byl
opredelen
    <i>#define</i> XX
to v programmu podstavlyaetsya variant1, esli zhe net - variant2. Operator <i>#else</i> ne obya-
zatelen  - pri ego otsutstvii variant2 pust. Sushchestvuet takzhe operator <i>#ifndef</i>, koto-
ryj podstavlyaet variant1 esli makros XX <i>ne</i> opredelen.  Est' eshche i  operator  <i>#elif</i>  -
else if:

    <i>#ifdef</i> makro1
      ...
    <i>#elif</i>  makro2
      ...
    <i>#else</i>
      ...
    <i>#endif</i>

Opredelit' makros mozhno ne tol'ko pri pomoshchi <i>#define</i>, no i pri pomoshchi klyucha  kompilya-
tora, tak

    <i>cc -D</i>XX file.c ...

sootvetstvuet vklyucheniyu v nachalo fajla file.c direktivy

    <i>#define</i> XX

A dlya programmy

    main(){
    #ifdef XX
            printf( "XX = %d\n", XX);
    #else
            printf( "XX undefined\n");
    #endif
    }

klyuch

    <i>cc -D</i>"XX=2" file.c ...

ekvivalenten zadaniyu direktivy

    <i>#define</i> XX 2

CHto budet, esli sovsem ne zadat' klyuch <i>-D</i> v dannom primere?
     |tot priem ispol'zuetsya v chastnosti v teh sluchayah,  kogda  kakie-to  standartnye
tipy ili funkcii v dannoj sisteme nosyat drugie nazvaniya:

    <i>cc -D</i>void=int ...
    <i>cc -D</i>strchr=index ...

V nekotoryh sistemah kompilyator avtomaticheski  opredelyaet  special'nye  makrosy:  tak
kompilyatory v <i>UNIX</i> neyavno podstavlyayut odin iz klyuchej (ili neskol'ko srazu):

            <i>-D</i>M_UNIX
            <i>-D</i>M_XENIX
            <i>-D</i>unix
            <i>-D</i>M_SYSV
            <i>-D</i>__SVR4
            <i>-D</i>USG
            ... byvayut i drugie




<i>A. Bogatyrev, 1992-95                  - 134 -                              Si v UNIX</i>

|to pozvolyaet programme "uznat'", chto ee kompiliruyut dlya sistemy  <i>UNIX</i>.   Bolee  pod-
robno pro eto napisano v dokumentacii po komande <i>cc</i>.

<i>3.19.</i>  Operator <i>#ifdef</i> primenyaetsya v include-fajlah, chtoby isklyuchit' povtornoe  vklyu-
chenie odnogo i togo zhe fajla.  Pust' fajly aa.h i bb.h soderzhat

           aa.h                        bb.h
    #include "cc.h"                 #include "cc.h"
    typedef unsigned long ulong;    typedef int cnt_t;

A fajly cc.h i 00.c soderzhat

           cc.h                        00.c
           ...                      #include "aa.h"
    struct II { int x, y; };        #include "bb.h"
           ...                      main(){ ... }

V etom sluchae tekst fajla cc.h budet vstavlen v 00.c <i>dvazhdy</i>: iz aa.h i iz  bb.h.  Pri
kompilyacii  00.c  kompilyator  soobshchit "Pereopredelenie struktury II".  CHtoby include-
fajl ne podstavlyalsya eshche raz, esli on uzhe odnazhdy  byl  vklyuchen,  priduman  sleduyushchij
priem - sleduet oformlyat' fajly vklyuchenij tak:

    /* fajl   cc.h */
    #ifndef  _CC_H
    # define _CC_H  /* opredelyaetsya pri pervom vklyuchenii */
            ...
            struct II { int x, y; };
            ...
    #endif /* _CC_H */

Vtoroe i posleduyushchie vklyucheniya takogo fajla budut podstavlyat'  pustoe  mesto,  chto  i
trebuetsya.    Dlya   fajla   &lt;sys/types.h>   bylo   by  ispol'zovano  makroopredelenie
_<i>SYS</i>_<i>TYPES</i>_<i>H</i>.

<i>3.20.</i>  Lyuboj makros mozhno otmenit', napisav direktivu

        <i>#undef</i> imyaMakro

Primer:

    #include &lt;stdio.h>
    <i>#undef</i> M_UNIX
    <i>#undef</i> M_SYSV
    main() {
            putchar('!');
    <i>#undef</i>  putchar
    <i>#define</i> putchar(c) printf( "Bukva '%c'\n", c);
            putchar('?');

    <i>#if</i> defined(M_UNIX) || defined(M_SYSV)
    /* ili prosto <i>#if</i> M_UNIX */
            printf("|to UNIX\n");
    <i>#else</i>
            printf("|to ne UNIX\n");
    <i>#endif</i> /* UNIX */
    }

Obychno <i>#undef</i> ispol'zuetsya imenno dlya pereopredeleniya makrosa,  kak  <i>putchar</i>  v  etom
primere (delo v tom, chto <i>putchar</i> - eto makros iz &lt;stdio.h>).
     Direktiva <i>#if</i>, ispol'zovannaya nami,  yavlyaetsya  rasshireniem  operatora  <i>#ifdef</i>  i
podstavlyaet tekst esli vypolneno ukazannoe uslovie:



<i>A. Bogatyrev, 1992-95                  - 135 -                              Si v UNIX</i>

    <i>#if</i>  defined(MACRO)  /* ravno <i>#ifdef</i>(MACRO)  */
    <i>#if</i> !defined(MACRO)  /* ravno <i>#ifndef</i>(MACRO) */
    <i>#if</i> VALUE > 15       /* esli celaya konstanta
                            <i>#define</i> VALUE 25
                            bol'she 15 (==, !=, &lt;=, ...) */
    <i>#if</i> COND1 || COND2   /* esli verno lyuboe iz uslovij */
    <i>#if</i> COND1 && COND2   /* esli verny oba usloviya      */

Direktiva <i>#if</i> dopuskaet ispol'zovanie v kachestve argumenta dovol'no  slozhnyh  vyrazhe-
nij, vrode

    <i>#if</i> !defined(M1) && (defined(M2) || defined(M3))


<i>3.21.</i>  Uslovnaya kompilyaciya mozhet ispol'zovat'sya dlya trassirovki programm:

    #ifdef DEBUG
    # define DEBUGF(body)   \
    {                       \
            body;           \
    }
    #else
    # define DEBUGF(body)
    #endif

    int f(int x){   return x*x; }
    int main(int ac, char *av[]){
            int x = 21;
            DEBUGF(x = f(x); printf("%s equals to %d\n", "x", x));
            printf("x=%d\n", x);
    }

Pri kompilyacii

    <i>cc -DDEBUG</i> file.c

v vyhodnom potoke programmy budet prisutstvovat' otladochnaya vydacha.   Pri  kompilyacii
bez <i>-D</i>DEBUG etoj vydachi ne budet.

<i>3.22.</i>  V yazyke <i>C++</i> (razvitie yazyka <i>Si</i>) slova <i>class</i>, <i>delete</i>,  <i>friend</i>,  <i>new</i>,  <i>operator</i>,
<i>overload</i>,  <i>template</i>,  <i>public</i>, <i>private</i>, <i>protected</i>, <i>this</i>, <i>virtual</i> yavlyayutsya zarezerviro-
vannymi (klyuchevymi).  |to mozhet vyzvat' nebol'shuyu problemu pri perenose teksta  prog-
rammy na <i>Si</i> v sistemu programmirovaniya <i>C++</i>, naprimer:

    #include &lt;termio.h>
      ...
    int fd_tty = 2;   /* stderr */
    struct <i>termio</i> old, new;
    <i>ioctl</i> (fd_tty, TCGETA, &old);
    new = old;
    new.c_lflag |= ECHO | ICANON;
    <i>ioctl</i> (fd_tty, TCSETAW, &new);
      ...

Stroki, soderzhashchie imya peremennoj (ili funkcii) <i>new</i>, okazhutsya  nepravil'nymi  v  <i>C++</i>.
Proshche vsego eta problema reshaetsya pereimenovaniem peremennoj (ili funkcii).  CHtoby ne
proizvodit' pravki vo vsem tekste, dostatochno pereopredelit' imya pri pomoshchi direktivy
<i>define</i>:






<i>A. Bogatyrev, 1992-95                  - 136 -                              Si v UNIX</i>

    #define <i>new    new</i>_<i>modes</i>
      ... staryj tekst ...
    #undef <i>new</i>

Pri perenose programmy na <i>Si</i> v <i>C++</i> sleduet takzhe uchest', chto v <i>C++</i> dlya kazhdoj funkcii
dolzhen  byt'  zadan prototip, prezhde chem eta funkciya budet ispol'zovana (<i>Si</i> pozvolyaet
opuskat' prototipy dlya mnogih funkcij, osobenno vozvrashchayushchih znacheniya tipov  <i>int</i>  ili
<i>void</i>).
























































<i>A. Bogatyrev, 1992-95                  - 137 -                              Si v UNIX</i>

        4.  Rabota s fajlami.
     Fajly predstavlyayut soboj oblasti pamyati na vneshnem nositele (kak pravilo magnit-
nom diske), prednaznachennye dlya:
-    hraneniya dannyh, prevoshodyashchih po ob®emu pamyat' komp'yutera (men'she,  razumeetsya,
     tozhe mozhno);
-    dolgovremennogo hraneniya informacii (ona sohranyaetsya pri vyklyuchenii mashiny).

V <i>UNIX</i> i v <i>MS DOS</i> fajly ne imeyut  predopredelennoj  struktury  i  predstavlyayut  soboj
prosto  linejnye  massivy  bajt.   Esli vy hotite zadat' nekotoruyu strukturu hranimoj
informacii - vy dolzhny pozabotit'sya ob etom v svoej programme sami.  Fajly otlichayutsya
ot obychnyh massivov tem, chto
-    oni mogut izmenyat' svoj razmer;
-    obrashchenie k elementam etih massivov proizvoditsya ne pri pomoshchi operacii indeksa-
     cii [], a pri pomoshchi special'nyh sistemnyh vyzovov i funkcij;
-    dostup k elementam fajla proishodit v tak  nazyvaemoj  "pozicii  chteniya/zapisi",
     kotoraya  avtomaticheski prodvigaetsya pri operaciyah chteniya/zapisi, t.e. fajl pros-
     matrivaetsya posledovatel'no.  Est', pravda, funkcii dlya proizvol'nogo  izmeneniya
     etoj pozicii.

Fajly imeyut imena i organizovany v ierarhicheskuyu drevovidnuyu strukturu iz katalogov i
prostyh  fajlov.  Ob  etom i o sisteme imenovaniya fajlov prochitajte v dokumentacii po
<i>UNIX</i>.

<i>4.1.</i>  Dlya raboty s kakim-libo fajlom nasha programma dolzhna otkryt' etot fajl -  usta-
novit'  svyaz'  mezhdu  imenem  fajla i nekotoroj peremennoj v programme.  Pri otkrytii
fajla v yadre operacionnoj sistemy vydelyaetsya  "svyazuyushchaya"  struktura  <i>file</i>  "otkrytyj
fajl", soderzhashchaya:
f_offset:
     ukazatel' pozicii chteniya/zapisi, kotoryj v dal'nejshem my  budem  oboznachat'  kak
     RWptr.  |to  <i>long</i>-chislo,  ravnoe  rasstoyaniyu v bajtah ot nachala fajla do pozicii
     chteniya/zapisi;
f_flag:
     rezhimy otkrytiya fajla: chtenie, zapis', chtenie i zapis', nekotorye dopolnitel'nye
     flagi;
f_inode:
     raspolozhenie fajla na diske (v <i>UNIX</i> - v vide ssylki na <i>I-uzel</i> fajla<i>|</i>-);
i koe-chto eshche.
     U kazhdogo processa imeetsya tablica otkrytyh im fajlov -  eto  massiv  ssylok  na
upomyanutye  "svyazuyushchie"  struktury<i>|</i>=.   Pri  otkrytii  fajla  v  etoj  tablice  ishchetsya
____________________
   <i>|</i>- <i>I-uzel</i> (I-node, indeksnyj uzel) - svoeobraznyj "pasport", kotoryj est' u kazhdogo
fajla (v tom chisle i kataloga). V nem soderzhatsya:

      - dlina fajla                  <i>long</i>   di_size;
      - nomer vladel'ca fajla        <i>int</i>    di_uid;
      - kody dostupa i tip fajla     <i>ushort</i> di_mode;
      - vremya sozdaniya i poslednej modifikacii
                    <i>time</i>_<i>t</i> di_ctime, di_mtime;
      - nachalo tablicy blokov fajla  <i>char</i>   di_addr[...];
      - kolichestvo imen fajla        <i>short</i>  di_nlink;
      i.t.p.

Soderzhimoe nekotoryh polej etogo pasporta mozhno uznat'  vyzovom  <i>stat</i>().  Vse  I-uzly
sobrany  v  edinuyu  oblast' v nachale fajlovoj sistemy - tak nazyvaemyj <i>I-fajl</i>. Vse I-
uzly pronumerovany, nachinaya s nomera 1.  Kornevoj katalog (fajl  s  imenem  "<i>/</i>")  kak
pravilo imeet I-uzel nomer 2.
   <i>|</i>= U kazhdogo processa v <i>UNIX</i> takzhe est' svoj "pasport".  CHast' etogo pasporta naho-
ditsya v tablice processov v yadre OS, a chast' - "prikleena" k samomu processu,  odnako
ne  dostupna  iz programmy neposredstvenno.  |ta vtoraya chast' pasporta nosit nazvanie
"<i>u-area</i>" ili struktura <i>user</i>. V nee, v chastnosti, vhodyat  tablica  otkrytyh  processom
fajlov



<i>A. Bogatyrev, 1992-95                  - 138 -                              Si v UNIX</i>

svobodnaya yachejka, v nee zanositsya ssylka na  strukturu  "otkrytyj  fajl"  v  yadre,  i
INDEKS  etoj  yachejki vydaetsya v vashu programmu v vide celogo chisla -  tak nazyvaemogo
"deskriptora fajla".
     Pri zakrytii fajla svyaznaya struktura v yadre unichtozhaetsya, yachejka v tablice  schi-
taetsya svobodnoj, t.e. svyaz' programmy i fajla razryvaetsya.
     Deskriptory yavlyayutsya lokal'nymi dlya kazhdoj programmy.  T.e. esli  dve  programmy
otkryli  odin  i tot zhe fajl - deskriptory etogo fajla v kazhdoj iz nih ne obyazatel'no
sovpadut (hotya i mogut).  Obratno: odinakovye deskriptory (nomera) v raznyh  program-
mah  ne  obyazatel'no  oboznachayut odin i tot zhe fajl.  Sleduet uchest' i eshche odnu veshch':
neskol'ko ili odin processov mogut otkryt' odin i tot zhe fajl odnovremenno  neskol'ko
raz.   Pri  etom  budet  sozdano neskol'ko "svyazuyushchih" struktur (po odnoj dlya kazhdogo
otkrytiya); kazhdaya iz nih budet imet' SVOJ ukazatel' chteniya/zapisi.  Vozmozhna i situa-
ciya,  kogda neskol'ko deskriptorov ssylayutsya k odnoj strukture - smotri nizhe opisanie
vyzova <i>dup2</i>.

     fd   u_ofile[]          <i>struct file</i>
      0   ##                 -------------
      1---##---------------->| f_flag    |
      2   ##                 | f_count=3 |
      3---##---------------->| f_inode---------*
     ...  ## *-------------->| f_offset  |     |
    process1 |               ------!------     |
             |                     !           V
      0   ## |  <i>struct file</i>        !   <i>struct inode</i>
      1   ## |  -------------      !   -------------
      2---##-*  | f_flag    |      !   | i_count=2 |
      3---##--->| f_count=1 |      !   | i_addr[]----*
     ...  ##    | f_inode----------!-->|    ...    | | adresa
    process2    | f_offset  |      !   ------------- | blokov
                -------!-----      *=========*       | fajla
                       !                     !       V
            0          !   ukazateli R/W     !   i_size-1
            @@@@@@@@@@@!@@@@@@@@@@@@@@@@@@@@@!@@@@@@
                           fajl na diske


    /* otkryt' fajl */
    int fd = <i>open</i>(char imya_fajla[], int kak_otkryt');
            ...  /* kakie-to operacii s fajlom */
    <i>close</i>(fd);  /* zakryt' */

Parametr kak_otkryt':

    #include &lt;fcntl.h>
    <i>O</i>_<i>RDONLY</i>  - tol'ko dlya chteniya.
    <i>O</i>_<i>WRONLY</i>  - tol'ko dlya zapisi.
    <i>O</i>_<i>RDWR</i>    - dlya chteniya i zapisi.
    <i>O</i>_<i>APPEND</i>  - inogda ispol'zuetsya vmeste s
    otkrytiem dlya zapisi, "dobavlenie" v fajl:
        <i>O</i>_<i>WRONLY</i>|<i>O</i>_<i>APPEND</i>, <i>O</i>_<i>RDWR</i>|<i>O</i>_<i>APPEND</i>


Esli fajl eshche ne sushchestvoval, to ego  nel'zya  otkryt':  <i>open</i>  vernet  znachenie  (-1),
____________________
     struct <i>file</i> *u_ofile[NOFILE];
ssylka na I-uzel tekushchego kataloga
     struct <i>inode</i> *u_cdir;
a takzhe ssylka na chast' pasporta v tablice processov
     struct <i>proc</i> *u_procp;





<i>A. Bogatyrev, 1992-95                  - 139 -                              Si v UNIX</i>

signaliziruyushchee ob oshibke.  V etom sluchae fajl nado sozdat':

    int fd = <i>creat</i>(char imya_fajla[], int kody_dostupa);

Deskriptor fd budet otkryt dlya zapisi v etot novyj pustoj fajl.   Esli  zhe  fajl  uzhe
sushchestvoval,  <i>creat</i>  opustoshaet ego, t.e.  unichtozhaet ego prezhnee soderzhimoe i delaet
ego dlinu ravnoj 0L bajt.  Kody_dostupa zadayut prava pol'zovatelej na dostup k fajlu.
|to chislo zadaet bitovuyu shkalu iz 9i bit, sootvetstvuyushchih stroke

    bity:   876 543 210
            <i>rwx rwx rwx</i>
    <i>r</i> - mozhno chitat' fajl
    <i>w</i> - mozhno zapisyvat' v fajl
    <i>x</i> - mozhno vypolnyat' programmu iz etogo fajla

Pervaya gruppa - eta prava vladel'ca fajla, vtoraya - chlenov ego gruppy, tretyaya -  vseh
prochih.  |ti kody dlya vladel'ca fajla imeyut eshche i mnemonicheskie imena (ispol'zuemye v
vyzove <i>stat</i>):

    #include &lt;sys/stat.h>  /* Tam opredeleno: */
    #define <i>S</i>_<i>IREAD</i>           0400
    #define <i>S</i>_<i>IWRITE</i>          0200
    #define <i>S</i>_<i>IEXEC</i>           0100

Podrobnosti - v rukovodstvah po sisteme <i>UNIX</i>.  Otmetim v chastnosti, chto <i>open</i>()  mozhet
vernut'   kod   oshibki   fd &lt; 0   ne  tol'ko  v  sluchae,  kogda  fajl  ne  sushchestvuet
(errno==<i>ENOENT</i>), no i v sluchae, kogda vam ne razreshen sootvetstvuyushchij dostup k  etomu
fajlu  (errno==<i>EACCES</i>; pro peremennuyu koda oshibki errno sm. v glave "Vzaimodejstvie s
<i>UNIX</i>").
     Vyzov <i>creat</i> - eto prosto raznovidnost' vyzova <i>open</i> v forme

    fd = <i>open</i>( imya_fajla,
               <i>O</i>_<i>WRONLY</i>|<i>O</i>_<i>TRUNC</i>|<i>O</i>_<i>CREAT</i>, kody_dostupa);

<i>O</i>_<i>TRUNC</i>
     oznachaet, chto esli fajl uzhe sushchestvuet, to on dolzhen byt' opustoshen  pri  otkry-
     tii. Kody dostupa i vladelec ne izmenyayutsya.
<i>O</i>_<i>CREAT</i>
     oznachaet, chto fajl dolzhen byt' sozdan, esli ego ne bylo (bez etogo flaga fajl ne
     sozdastsya,  a <i>open</i> vernet fd &lt; 0).  |tot flag trebuet zadaniya tret'ego argumenta
     kody_dostupa<i>|</i>-.  Esli fajl uzhe sushchestvuet - etot flag ne imeet nikakogo  effekta,
     no zato vstupaet v dejstvie <i>O</i>_<i>TRUNC</i>.
     Sushchestvuet takzhe flag
<i>O</i>_<i>EXCL</i>
     kotoryj mozhet ispol'zovat'sya sovmestno s <i>O</i>_<i>CREAT</i>.   On  delaet  sleduyushchee:  esli
     fajl  uzhe  sushchestvuet,  <i>open</i>  vernet  kod  oshibki (errno==<i>EEXIST</i>).  Esli fajl ne
____________________
   <i>|</i>- Zametim, chto na samom dele kody dostupa u novogo fajla budut ravny
     di_mode = (kody_dostupa & ~u_cmask) | <i>IFREG</i>;
(dlya kataloga vmesto <i>IFREG</i> budet <i>IFDIR</i>), gde maska u_cmask zadaetsya sistemnym vyzovom
     <i>umask</i>(u_cmask);
(vyzov vydaet prezhnee znachenie maski) i v dal'nejshem nasleduetsya vsemi potomkami dan-
nogo processa (ona hranitsya v <i>u-area</i> processa).  |ta maska pozvolyaet zapretit' dostup
k opredelennym operaciyam dlya vseh sozdavaemyh nami fajlov, nesmotrya na yavno  zadannye
kody dostupa, naprimer
     <i>umask</i>(0077); /* ???------ */
delaet znachashchimi tol'ko pervye 3 bita kodov dostupa (dlya vladel'ca fajla).  Ostal'nye
bity budut ravny nulyu.
     Vse eto otnositsya i k sozdaniyu katalogov vyzovom <i>mkdir</i>.





<i>A. Bogatyrev, 1992-95                  - 140 -                              Si v UNIX</i>

     sushchestvoval - srabatyvaet <i>O</i>_<i>CREAT</i> i fajl sozdaetsya.  |to pozvolyaet  predohranit'
     uzhe sushchestvuyushchie fajly ot unichtozheniya.

Fajl udalyaetsya pri pomoshchi

    int <i>unlink</i>(char imya_fajla[]);

U kazhdoj programmy po umolchaniyu otkryty tri pervyh deskriptora, obychno svyazannye

    0 - s klaviaturoj (dlya chteniya)
    1 - s displeem    (vydacha rezul'tatov)
    2 - s displeem    (vydacha soobshchenij ob oshibkah)

Esli pri vyzove <i>close</i>(fd) deskriptor fd ne sootvetstvuet otkrytomu fajlu (ne byl otk-
ryt) - nichego ne proishodit.
     CHasto ispol'zuetsya takaya metafora:  esli  predstavlyat'  sebe  fajly  kak  knizhki
(tol'ko  chtenie)  i bloknoty (chtenie i zapis'), stoyashchie na polke, to otkrytie fajla -
eto vybor bloknota po zaglaviyu na ego oblozhke i otkrytie  oblozhki  (na  pervoj  stra-
nice).   Teper' mozhno chitat' zapisi, dopisyvat', vycherkivat' i pravit' zapisi v sere-
dine, listat' knizhku!  Stranicy mozhno sopostavit' blokam fajla (sm. nizhe), a  "polku"
s knizhkami - katalogu.

<i>4.2.</i>  Napishite programmu, kotoraya kopiruet soderzhimoe odnogo fajla v  drugoj  (novyj)
fajl.   Pri etom ispol'zujte sistemnye vyzovy chteniya i zapisi <i>read</i> i <i>write</i>.  |ti sis-
vyzovy peresylayut massivy bajt iz pamyati v fajl i naoborot. No lyubuyu peremennuyu mozhno
rassmatrivat' kak massiv bajt, esli zabyt' o strukture dannyh v peremennoj!
     CHitajte i zapisyvajte fajly bol'shimi kuskami, kratnymi 512 bajtam. |to  umen'shit
chislo obrashchenij k disku.  Shema:

    char buffer[512]; int n; int fd_inp, fd_outp;
            ...
    while((n = <i>read</i> (fd_inp,  buffer, sizeof buffer)) > 0)
               <i>write</i>(fd_outp, buffer, n);

Privedem neskol'ko primerov ispol'zovaniya <i>write</i>:

    char c = 'a';
    int  i = 13, j = 15;
    char s[20] = "foobar";
    char p[]   = "FOOBAR";
    struct { int x, y; } a = { 666, 999 };
    /* sozdaem fajl s dostupom    rw-r--r-- */
    int fd = <i>creat</i>("aFile", 0644);
    <i>write</i>(fd, &c, 1);
    <i>write</i>(fd, &i, sizeof i);  <i>write</i>(fd, &j, sizeof(int));
    <i>write</i>(fd, s,  <i>strlen</i>(s)); <i>write</i>(fd, &a, sizeof a);
    <i>write</i>(fd, p,  sizeof(p) - 1);
    <i>close</i>(fd);

Obratite vnimanie na takie momenty:
-    Pri ispol'zovanii <i>write</i>() i <i>read</i>() nado peredavat'  ADRES  dannogo,  kotoroe  my
     hotim zapisat' v fajl (mesta, kuda my hotim prochitat' dannye iz fajla).
-    Operacii <i>read</i> i <i>write</i> vozvrashchayut chislo dejstvitel'no prochitannyh/zapisannyh bajt
     (pri  zapisi  ono  mozhet  byt'  men'she ukazannogo nami, esli na diske ne hvataet
     mesta; pri chtenii - esli ot pozicii chteniya  do  konca  fajla  soderzhitsya  men'she
     informacii, chem my zatrebovali).
-    Operacii <i>read</i>/<i>write</i> prodvigayut ukazatel' chteniya/zapisi

         RWptr += prochitannoe_ili_zapisannoe_chislo_bajt;

     Pri otkrytii fajla ukazatel' stoit na nachale fajla: RWptr=0.   Pri  zapisi  fajl



<i>A. Bogatyrev, 1992-95                  - 141 -                              Si v UNIX</i>

     esli nado avtomaticheski uvelichivaet svoj razmer.  Pri chtenii - esli my dostignem
     konca fajla, to <i>read</i> budet vozvrashchat' "prochitano 0 bajt" (t.e. pri chtenii ukaza-
     tel' chteniya ne mozhet stat' bol'she razmera fajla).
-    Argument skol'koBajt imeet tip <i>unsigned</i>, a ne prosto <i>int</i>:

    int n = <i>read</i> (int fd, char *adres, unsigned skol'koBajt);
    int n = <i>write</i>(int fd, char *adres, unsigned skol'koBajt);

Privedem uproshchennye shemy logiki etih sisvyzovov, kogda oni rabotayut s obychnym disko-
vym  fajlom (v <i>UNIX</i> ustrojstva tozhe vyglyadyat dlya programm kak fajly, no inogda s oso-
bymi svojstvami):

<i>4.2.1.  m = write(fd, addr, n);</i>

    esli( FAJL[fd] ne otkryt na zapis') to vernut' (-1);
    esli(n == 0) to vernut' 0;
    esli( FAJL[fd] otkryt na zapis' s flagom <i>O</i>_<i>APPEND</i> ) to
      RWptr = dlina_fajla; /* t.e. vstat' na konec fajla */
    esli( RWptr > dlina_fajla ) to
      zapolnit' nulyami bajty fajla v intervale
      FAJL[fd][ dlina_fajla..RWptr-1 ] = '\0';
    skopirovat' bajty iz pamyati processa v fajl
      FAJL[fd][ RWptr..RWptr+n-1 ] = addr[ 0..n-1 ];
      otvodya na diske novye bloki, esli nado
    RWptr += n;
    esli( RWptr > dlina_fajla ) to
          dlina_fajla = RWptr;
    vernut' n;


<i>4.2.2.  m = read(fd, addr, n);</i>

    esli( FAJL[fd] ne otkryt na chtenie) to vernut' (-1);
    esli( RWptr >= dlina_fajla ) to vernut' 0;
    m = MIN( n, dlina_fajla - RWptr );
    skopirovat' bajty iz fajla v pamyat' processa
      addr[ 0..m-1 ] = FAJL[fd][ RWptr..RWptr+m-1 ];
    RWptr += m;
    vernut' m;


<i>4.3.</i>  Najdite oshibki v fragmente programmy:

    #define STDOUT 1  /* deskriptor standartnogo vyvoda */
    int i;
    static char s[20] = "hi\n";
    char c = '\n';
    struct a{ int x,y; char ss[5]; } po;

    <i>scanf</i>( "%d%d%d%s%s", i, po.x, po.y, s, po.ss);
    <i>write</i>( STDOUT, s, <i>strlen</i>(s));
    <i>write</i>( STDOUT, c, 1 );       /* zapisat' 1 bajt */

Otvet: v funkcii <i>scanf</i> pered argumentom i dolzhna stoyat' operaciya "adres", to est' <i>&</i>i.
Analogichno pro <i>&</i>po.x i <i>&</i>po.y.  Zametim, chto s - eto massiv, t.e.  s i tak est' adres,
poetomu pered s operaciya <i>&</i> ne nuzhna; analogichno pro po.ss - zdes' <i>&</i> ne trebuetsya.
     V sistemnom vyzove <i>write</i> vtoroj argument dolzhen byt' adresom dannogo, kotoroe my
hotim zapisat' v fajl.  Poetomu my dolzhny byli napisat' <i>&</i>c (vo vtorom vyzove <i>write</i>).
     Oshibka v <i>scanf</i> - ukazanie  znacheniya  peremennoj  vmesto  ee  adresa  -  yavlyaetsya
dovol'no rasprostranennoj i ne mozhet byt' obnaruzhena kompilyatorom (dazhe pri ispol'zo-
vanii prototipa funkcii <i>scanf</i>(char *fmt, <i>...</i>), tak kak <i>scanf</i> - funkciya  s  peremennym



<i>A. Bogatyrev, 1992-95                  - 142 -                              Si v UNIX</i>

chislom argumentov zaranee ne opredelennyh tipov). Prihoditsya polagat'sya isklyuchitel'no
na sobstvennuyu vnimatel'nost'!

<i>4.4.</i>  Kak po deskriptoru fajla uznat', otkryt on na chtenie, zapis', chtenie  i  zapis'
odnovremenno? Vot dva varianta resheniya:

    #include &lt;fcntl.h>
    #include &lt;stdio.h>
    #include &lt;sys/param.h> /* tam opredeleno NOFILE */
    #include &lt;errno.h>

    char *<i>typeOfOpen</i>(fd){
      int flags;
      if((flags=<i>fcntl</i> (fd, <i>F</i>_<i>GETFL</i>, NULL)) &lt; 0 )
        return NULL;  /* fd veroyatno ne otkryt */
      flags &= <i>O</i>_<i>RDONLY</i> | <i>O</i>_<i>WRONLY</i> | <i>O</i>_<i>RDWR</i>;
      switch(flags){
      case <i>O</i>_<i>RDONLY</i>:  return "r";
      case <i>O</i>_<i>WRONLY</i>:  return "w";
      case <i>O</i>_<i>RDWR</i>:    return "r+w";
      default:        return NULL;
      }
    }

    char *<i>type2OfOpen</i>(fd){
      extern errno; /* sm. glavu "sistemnye vyzovy" */
      int r=1, w=1;
      errno = 0; <i>read</i>(fd, NULL, 0);
      if( errno == <i>EBADF</i> ) r = 0;
      errno = 0; <i>write</i>(fd, NULL, 0);
      if( errno == <i>EBADF</i> ) w = 0;
      return (w && r) ? "r+w" :
              w       ? "w"   :
              r       ? "r"   :
                        "closed";
    }

    main(){
      int i; char *s, *p;
      for(i=0; i &lt; <i>NOFILE</i>; i++ ){
         s = <i>typeOfOpen</i>(i); p = <i>type2OfOpen</i>(i);
        printf("%d:%s %s\n", i, s? s: "closed", p);
      }
    }

Konstanta <i>NOFILE</i> oznachaet maksimal'noe chislo odnovremenno otkrytyh fajlov dlya  odnogo
processa  (eto razmer tablicy otkrytyh processom fajlov, tablicy deskriptorov).  Izu-
chite opisanie sistemnogo vyzova <i>fcntl</i> (file control).

<i>4.5.</i>  Napishite funkciyu rename() dlya pereimenovaniya fajla.  Ukazanie: ispol'zujte sis-
temnye vyzovy <i>link</i>() i <i>unlink</i>().  Otvet:













<i>A. Bogatyrev, 1992-95                  - 143 -                              Si v UNIX</i>

       <i>rename</i>( from, to )
         char *from,     /* staroe imya */
              *to;       /* novoe imya  */
       {
           <i>unlink</i>( to );   /* udalit' fajl to    */
           if( <i>link</i>( from, to ) &lt; 0 ) /* svyazat' */
               return (-1);
           <i>unlink</i>( from ); /* steret' staroe imya */
           return 0;       /* OK */
       }

Vyzov
     <i>link</i>(sushchestvuyushchee_imya, novoe_imya);
sozdaet fajlu al'ternativnoe imya - v <i>UNIX</i> fajl mozhet imet' neskol'ko imen: tak kazhdyj
katalog  imeet  kakoe-to  imya  v roditel'skom kataloge, a takzhe imya "." v sebe samom.
Katalog zhe, soderzhashchij podkatalogi, imeet nekotoroe imya v  svoem  roditel'skom  kata-
loge, imya "." v sebe samom, i po odnomu imeni ".." v kazhdom iz svoih podkatalogov.
     |tot vyzov budet neudachen, esli fajl novoe_imya uzhe sushchestvuet; a takzhe  esli  my
popytaemsya sozdat' al'ternativnoe imya v drugoj fajlovoj sisteme.  Vyzov
     <i>unlink</i>(imya_fajla)
udalyaet imya fajla. Esli fajl bol'she ne imeet imen - on unichtozhaetsya. Zdes' est'  odna
tonkost': rassmotrim fragment

    int fd;
    <i>close</i>(<i>creat</i>("/tmp/xyz", 0644)); /*Sozdat' pustoj fajl*/
    fd = <i>open</i>("/tmp/xyz", <i>O</i>_<i>RDWR</i>);
    <i>unlink</i>("/tmp/xyz");
            ...
    <i>close</i>(fd);

Pervyj operator sozdaet pustoj fajl.   Zatem  my  otkryvaem  fajl  i  unichtozhaem  ego
edinstvennoe  imya.  No poskol'ku est' programma, otkryvshaya etot fajl, on ne udalyaetsya
nemedlenno!  Programma dalee rabotaet s bezymyannym fajlom pri pomoshchi deskriptora  fd.
Kak  tol'ko  fajl  zakryvaetsya  -  on budet unichtozhen sistemoj (kak ne imeyushchij imen).
Takoj tryuk ispol'zuetsya dlya sozdaniya vremennyh rabochih fajlov.
     Fajl mozhno udalit' iz kataloga tol'ko v tom sluchae, esli  dannyj  katalog  imeet
dlya vas kod dostupa "zapis'".  Kody dostupa samogo fajla pri udalenii ne igrayut roli.
     V sovremennyh versiyah <i>UNIX</i> est' sistemnyj vyzov <i>rename</i>,  kotoryj  delaet  to  zhe
samoe, chto i napisannaya nami odnoimennaya funkciya.

<i>4.6.</i>  Sushchestvovanie al'ternativnyh imen u fajla pozvolyaet nam reshit' nekotorye  prob-
lemy,  kotorye  mogut  vozniknut'  pri  ispol'zovanii chuzhoj programmy, ot kotoroj net
ishodnogo teksta (kotoruyu nel'zya popravit'). Pust' programma vydaet nekotoruyu  infor-
maciyu  v fajl zz.out (i eto imya zhestko zafiksirovano v nej, i ne zadaetsya cherez argu-
menty programmy):

    /* |ta programma kompiliruetsya v <i>a.out</i> */
    main(){
        int fd = <i>creat</i>("zz.out", 0644);
        <i>write</i>(fd, "It's me\n", 8);
    }

My zhe hotim poluchit' vyvod na terminal, a ne v fajl. Ochevidno, my dolzhny sdelat' fajl
zz.out sinonimom ustrojstva <i>/dev/tty</i> (sm. konec etoj glavy). |to mozhno sdelat' koman-
doj <i>ln</i>:

    $ <i>rm</i> zz.out ; <i>ln</i> /dev/tty zz.out
    $ <i>a.out</i>
    $ <i>rm</i> zz.out

ili programmno:



<i>A. Bogatyrev, 1992-95                  - 144 -                              Si v UNIX</i>

    /* |ta programma kompiliruetsya v <i>start</i> */
    /* i vyzyvaetsya  vmesto <i>a.out</i>          */
    #include &lt;stdio.h>
    main(){
       <i>unlink</i>("zz.out");
       <i>link</i>("/dev/tty", "zz.out");
         if( !<i>fork</i>()){ <i>execl</i>("a.out", NULL); }
         else <i>wait</i>(NULL);
       <i>unlink</i>("zz.out");
    }

(pro <i>fork</i>, <i>exec</i>, <i>wait</i> smotri v glave pro <i>UNIX</i>).
     Eshche odin primer: programma <i>a.out</i> zhelaet zapustit' programmu /usr/bin/vi  (smotri
pro funkciyu <i>system</i>() snosku cherez neskol'ko stranic):

    main(){
       ... <i>system</i>("/usr/bin/vi xx.c"); ...
    }

Na vashej zhe mashine redaktor <i>vi</i> pomeshchen v /usr/local/bin/vi.  Togda vy prosto sozdaete
al'ternativnoe imya etomu redaktoru:

    $ <i>ln</i> /usr/local/bin/vi /usr/bin/vi

Pomnite, chto al'ternativnoe imya fajlu mozhno sozdat' lish' v toj zhe  fajlovoj  sisteme,
gde soderzhitsya ishodnoe imya. V semejstve <i>BSD |</i>- eto ogranichenie mozhno  obojti,  sozdav
"simvol'nuyu ssylku" vyzovom

    <i>symlink</i>(link_to_filename,link_file_name_to_be_created);

Simvol'naya ssylka - eto fajl, soderzhashchij imya drugogo fajla (ili  kataloga).   Sistema
ne  proizvodit  avtomaticheskij podschet chisla takih ssylok, poetomu vozmozhny "visyachie"
ssylki - ukazyvayushchie na uzhe udalennyj fajl.  Prochest' soderzhimoe  fajla-ssylki  mozhno
sistemnym vyzovom

    char linkbuf[ MAXPATHLEN + 1]; /* kuda pomestit' otvet */
    int len = <i>readlink</i>(pathname, linkbuf, sizeof linkbuf);
    linkbuf[len] = '\0';

Sistemnyj vyzov <i>stat</i> avtomaticheski razymenovyvaet simvol'nye ssylki i vydaet informa-
ciyu  pro  ukazuemyj fajl. Sistemnyj vyzov <i>lstat</i> (analog <i>stat</i> za isklyucheniem nazvaniya)
vydaet informaciyu pro samu ssylku (tip fajla <i>S</i>_<i>IFLNK</i>).   Kody  dostupa  k  ssylke  ne
imeyut  nikakogo  znacheniya dlya sistemy, sushchestvenny tol'ko kody dostupa samogo ukazue-
mogo fajla.
     Eshche raz: simvol'nye ssylki udobny dlya ukazaniya  fajlov  i  katalogov  na  drugom
diske.   Pust'  u  vas  ne pomeshchaetsya na disk katalog /opt/wawa. Vy mozhete razmestit'
katalog wawa na diske USR: /usr/wawa. Posle chego sozdat' simvol'nuyu ssylku iz /opt:

            <i>ln -s</i> /usr/wawa /opt/wawa

chtoby programmy videli etot katalog pod ego prezhnim imenem /opt/wawa.
     Eshche raz:
<i>hard link</i>
     - to, chto sozdaetsya sistemnym vyzovom <i>link</i>, imeet tot zhe I-node (i