aboutsummaryrefslogtreecommitdiff
path: root/it_IT.ISO8859-15/books/unix-introduction/shell-programming/chapter.xml
blob: bcfa02ae7ecc224837fb6229ff8c18dcf13bc6c9 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
1519
1520
1521
1522
1523
1524
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
1550
1551
1552
1553
1554
1555
1556
1557
1558
1559
1560
1561
1562
1563
1564
1565
1566
1567
1568
1569
1570
1571
1572
1573
1574
1575
1576
1577
1578
1579
1580
1581
1582
1583
1584
1585
1586
1587
1588
1589
1590
1591
1592
1593
1594
1595
1596
1597
1598
1599
1600
1601
1602
1603
1604
1605
1606
1607
1608
1609
1610
1611
1612
1613
1614
1615
1616
1617
1618
1619
1620
1621
1622
1623
1624
1625
1626
1627
1628
1629
1630
1631
1632
1633
1634
1635
1636
1637
1638
1639
1640
1641
1642
1643
1644
1645
1646
1647
1648
1649
1650
1651
1652
1653
1654
1655
1656
1657
1658
1659
1660
1661
1662
1663
1664
1665
1666
1667
1668
1669
1670
1671
1672
1673
1674
1675
1676
1677
1678
1679
1680
1681
1682
1683
1684
1685
1686
1687
1688
1689
1690
1691
1692
1693
1694
<?xml version="1.0" encoding="iso-8859-15" standalone="no"?>
<!--
     The FreeBSD Italian Documentation Project

     $FreeBSD$
-->

<chapter id="shell-programming">
  <title>Programmazione di shell</title>

  <sect1 id="shell-programming-scripts">
    <title>Script di shell</title>

    <para>Si possono scrivere programmi di shell creando script contenenti
      alcuni comandi di shell.  La prima linea dello script deve iniziare con
      #!, che indica al kernel che lo script  direttamente eseguibile.
      Si fa immediatamente seguire a quel simbolo il nome della shell
      o del programma da eseguire (gli spazi sono permessi), usando un path name
      assoluto.  Generalmente si possono avere fino a 32 caratteri, forse di
      pi su alcuni sistemi e si pu includere qualche opzione.
      Quindi per inizializzare uno script per la shell Bourne la prima linea
      dovr essere:</para>

    <programlisting>#! /bin/sh</programlisting>

    <para>e per la shell C:</para>

    <programlisting>#! /bin/csh -f</programlisting>

    <para>dove l'opzione <option>-f</option> indica che la shell non deve
      leggere il file <filename>.cshrc</filename>.  Alcuni spazi bianchi
      seguenti il magico simbolo, #!, sono opzionali.</para>

    <para>Inoltre si deve specificare che lo script  eseguibile,
      settando gli opportuni bit sul file con il comando &man.chmod.1;,
      esempio:</para>

    <screen>&prompt.user; <userinput>chmod +x <replaceable>shell_script</replaceable></userinput></screen>

    <para>All'interno degli script il simbolo # indica un commento da quel punto
      fino alle fine della linea; #!  un caso speciale se trovato come
      primo carattere del file.</para>
  </sect1>

  <sect1 id="shell-programming-sett-param-val">
    <title>Settare i valori dei parametri</title>

    <para>I valori di un parametro, ad esempio <literal>param</literal>, sono
      assegnati cos:</para>

    <informaltable frame="none">
      <tgroup cols="2">
        <colspec colwidth="1.5in"/>

        <thead>
          <row>
            <entry>Shell Bourne</entry>

            <entry>Shell C</entry>
          </row>
        </thead>

        <tbody>
          <row>
            <entry><command>param=<replaceable>valore</replaceable></command></entry>

            <entry><command>set param =
                <replaceable>valore</replaceable></command></entry>
          </row>
        </tbody>
      </tgroup>
    </informaltable>

    <para>dove <replaceable>valore</replaceable>  una valida stringa che
      pu essere chiusa tra caratteri di quoting singoli
      ('<replaceable>valore</replaceable>') o doppi
      ("<replaceable>valore</replaceable>") per permettere alcuni spazi bianchi
      all'interno del valore della stringa.  Quando viene racchiusa con dei
      caratteri backquote (`<replaceable>valore</replaceable>`) la stringa viene
      prima valutata dalla shell e viene sostituita con il risultato ottenuto
      dalla valutazione.  Questo viene spesso usato per eseguire un comando,
      sostituendo l'output del comando a <replaceable>valore</replaceable>,
      esempio:</para>

      <screen>$ <userinput>day=`date +%a`</userinput></screen>

      <screen>$ <userinput>echo $day</userinput>
Wed</screen>

    <para>Dopo che il valore del parametro  stato assegnato, si accede
      al valore corrente del parametro usando la notazione
      <literal>$param</literal> o <literal>${param}</literal>.</para>
  </sect1>

  <sect1 id="shell-programming-quoting">
    <title>Quoting</title>

    <para>Le stringhe possono essere quotate per controllare il modo in cui la
      shell interpreta alcuni parametri o variabili all'interno della stringa.
      Per delimitare le stringhe si possono usare i caratteri di quoting singoli
      (') o doppi (").  I caratteri di quoting doppi definiscono la stringa e
      permettono la sostituzione di variabile.  I carattere di quoting singoli
      definiscono la stringa ma impediscono la sostituzione di variabile.
      Un backslash (\) prima di un carattere viene posto per effettuare un
      escape su di esso, specificando che il sistema deve considerare il
      carattere letteralmente, senza assegnarli alcun significato speciale.
      Queste tecniche di quoting possono essere usate per separare una variabile
      da una stringa fissa.  Come esempio si consideri la variabile
      <literal>var</literal>, a cui  stata assegnata il valore
      <literal>bat</literal>, e la stringa costante <literal>man</literal>.  Se
      si vuole combinare queste stringhe per ottenere come risultato la stringa
      <literal>batman</literal> si pu sperimentare:</para>

    <para><literal>$varman</literal></para>

    <para>ma questo non funzioner, poich la shell tenta di
      valutare una variabile chiamata <literal>varman</literal>, che non esiste.
      Per ottenere il risultato desiderato si ha la necessit di separare
      le stringhe tramite quoting o di isolare la variabile con delle parentesi
      graffe ({}), in questo modo:</para>

    <informaltable frame="none">
      <tgroup cols="2">
        <colspec colwidth="1.5in"/>

        <tbody>
          <row>
            <entry><literal>"$var"man</literal></entry>

            <entry>- quoting sulla variabile</entry>
          </row>

          <row>
            <entry><literal>$var""man</literal></entry>

            <entry>- separazione di parametri</entry>
          </row>

          <row>
            <entry><literal>$var"man"</literal></entry>

            <entry>- quoting sulla costante</entry>
          </row>

          <row>
            <entry><literal>$var''man</literal></entry>

            <entry>- separazione di parametri</entry>
          </row>

          <row>
            <entry><literal>$var'man'</literal></entry>

            <entry>- quoting sulla costante</entry>
          </row>

          <row>
            <entry><literal>$var\man</literal></entry>

            <entry>- separazione di parametri</entry>
          </row>

          <row>
            <entry><literal>${var}man</literal></entry>

            <entry>- si isola la variabile</entry>
          </row>
        </tbody>
      </tgroup>
    </informaltable>

    <para>Queste funzionano tutte poich ", ', \, { e } non sono validi
      caratteri per un nome di variabile.</para>

    <para>Non si pu usare</para>

    <para><literal>'$var'man</literal></para>

    <para><literal>\$varman</literal></para>

    <para>poich impediscono che la sostituzione della variabile
      prenda posto.</para>

    <para>Quando si usano le parentesi graffe, queste devono circondare
      solamente la variabile, senza includere il $, altrimenti saranno incluse
      come parte del risultato della stringa, esempio:</para>

    <screen>&prompt.user; <userinput>echo {$var}man</userinput>
{bat}man</screen>
  </sect1>

  <sect1 id="shell-programming-var">
    <title>Variabili</title>

    <para>Alcune variabili sono automaticamente inizializzate all'avvio della
      shell.  Queste variabili permettono di riferirsi agli argomenti su linea
      di comando.</para>

    <para>Queste <emphasis>variabili di shell</emphasis> sono:</para>

    <table frame="all" id="shell-programming-table-shell-var">
      <title>Variabili di shell</title>

      <tgroup cols="4">
        <colspec colwidth="1in"/>

        <colspec colwidth="5in"/>

        <colspec colwidth="0.3in"/>

        <colspec colwidth="0.3in"/>

        <thead>
          <row>
            <entry align="center">Variabile</entry>

            <entry align="center">Uso</entry>

            <entry align="center">sh</entry>

            <entry align="center">csh</entry>
          </row>
        </thead>

        <tbody>
          <row>
            <entry><literal>$#</literal></entry>

            <entry>numero di argomenti su linea di comando</entry>

            <entry align="center">x</entry>

            <entry align="center"></entry>
          </row>

          <row>
            <entry><literal>$-</literal></entry>

            <entry>opzioni fornite alla shell</entry>

            <entry align="center">x</entry>

            <entry align="center"></entry>
          </row>

          <row>
            <entry><literal>$?</literal></entry>

            <entry>valore di uscita dell'ultimo comando eseguito</entry>

            <entry align="center">x</entry>

            <entry align="center"></entry>
          </row>

          <row>
            <entry><literal>$$</literal></entry>

            <entry>numero id del processo corrente</entry>

            <entry align="center">x</entry>

            <entry align="center">x</entry>
          </row>

          <row>
            <entry><literal>$!</literal></entry>

            <entry>numero di processo dell'ultimo comando messo in
              background</entry>

            <entry align="center">x</entry>

            <entry align="center"></entry>
          </row>

          <row>
            <entry><literal>$<replaceable>n</replaceable></literal></entry>

            <entry>argomento su linea di comando, dove
              <replaceable>n</replaceable> varia tra 1 e 9, leggendo da sinistra
              a destra</entry>

            <entry align="center">x</entry>

            <entry align="center">x</entry>
          </row>

          <row>
            <entry><literal>$0</literal></entry>

            <entry>il nome della shell corrente o del programma corrente</entry>

            <entry align="center">x</entry>

            <entry align="center">x</entry>
          </row>

          <row>
            <entry><literal>$*</literal></entry>

            <entry>tutti gli argomenti su linea di comando ("$1 $2 ...
              $9")</entry>

            <entry align="center">x</entry>

            <entry align="center">x</entry>
          </row>

          <row>
            <entry><literal>$@</literal></entry>

            <entry>tutti gli argomenti su linea di comando, ciascuno quotato
              separatamente ("$1" "$2" ... "$9")</entry>

            <entry align="center">x</entry>

            <entry align="center"></entry>
          </row>

          <row>
            <entry><literal>$argv[<replaceable>n</replaceable>]</literal></entry>

            <entry>seleziona l'<replaceable>n-esima</replaceable> parola dalla
              lista di input</entry>

            <entry align="center"></entry>

            <entry align="center">x</entry>
          </row>

          <row>
            <entry><literal>${argv[<replaceable>n</replaceable>]}</literal></entry>

            <entry>come sopra</entry>

            <entry align="center"></entry>

            <entry align="center">x</entry>
          </row>

          <row>
            <entry><literal>$#argv</literal></entry>

            <entry>riporta il numero di parole della lista di input</entry>

            <entry align="center"></entry>

            <entry align="center">x</entry>
          </row>
        </tbody>
      </tgroup>
    </table>

    <para>L'uso di queste variabili pu essere illustrato con alcuni
      semplici script.  Per la shell Bourne lo script potrebbe essere:</para>

    <programlisting>#!/bin/sh
echo "$#:" $#
echo '$#:' $#
echo '$-:' $-
echo '$?:' $?
echo '$$:' $$
echo '$!:' $!
echo '$3:' $3
echo '$0:' $0
echo '$*:' $*
echo '$@:' $@</programlisting>

    <para>Quando viene eseguito con alcuni argomenti, mostra i valori delle
      variabili di shell, esempio:</para>

    <screen>$ <userinput>./variables.sh one two three four five</userinput>
5: 5
$#: 5
$-:
$?: 0
$$: 12417
$!:
$3: three
$0: ./variables.sh
$*: one two three four five
$@: one two three four five</screen>

    <para>Come si pu notare, si ha la necessit di usare un
      carattere di quoting singolo per impedire alla shell di assegnare
      significati speciali a $.  Il carattere di quoting doppio, come nella
      prima struttura <command>echo</command>, permette di rimpiazzare il nome
      della variabile con il suo valore.</para>

    <para>Similmente, per le variabili della shell C si possono illustrare le
      sostituzioni di variabili tramite il seguente script:</para>

    <programlisting>#!/bin/csh -f
echo '$$:' $$
echo '$3:' $3
echo '$0:' $0
echo '$*:' $*
echo '$argv[2]:' $argv[2]
echo '${argv[4]}:' ${argv[4]}
echo '$#argv:' $#argv</programlisting>

    <para>che quando eseguito con alcuni argomenti mostra il risultato
      seguente:</para>

    <screen>&prompt.user; <userinput>./variables.csh one two three four five
</userinput>
$$: 12419
$3: three
$0: ./variables.csh
$*: one two three four five
$argv[2]: two
${argv[4]}: four
$#argv: 5</screen>
  </sect1>

  <sect1 id="shell-programming-param-sost">
    <title>Sostituzione di parametri</title>

    <para>Si pu riferirsi ai parametri in modo astratto e sostituire i
      loro valori in base a delle condizioni, usando gli operatori definiti qui
      sotto.  Ancora una volta si possono usare le parentesi graffe ({}) per
      isolare la variabile e il suo operatore.</para>

    <informaltable frame="none">
      <tgroup cols="2">
        <colspec colwidth="2in"/>

        <tbody>
          <row>
            <entry><literal>$<replaceable>parametro</replaceable></literal></entry>

            <entry>sostituisce questa stringa con il valore di
              <replaceable>parametro</replaceable></entry>
          </row>

          <row>
            <entry><literal>${<replaceable>parametro</replaceable>}</literal></entry>

            <entry>come sopra.  Le parentesi sono d'aiuto se non c'
              separazione tra questo parametro e una stringa adiacente.</entry>
          </row>

          <row>
            <entry><literal>$<replaceable>parametro</replaceable>=</literal></entry>

            <entry>setta <replaceable>parametro</replaceable> a
              <emphasis>null</emphasis>.</entry>
          </row>

          <row>
            <entry><literal>${<replaceable>parametro</replaceable>-<replaceable>default</replaceable>}</literal></entry>

            <entry>se <replaceable>parametro</replaceable> non  settato
              allora si usa <replaceable>default</replaceable> come valore.
              <replaceable>parametro</replaceable> non viene resettato.</entry>
          </row>

          <row>
            <entry><literal>${<replaceable>parametro</replaceable>=<replaceable>default</replaceable>}</literal></entry>

            <entry>se <replaceable>parametro</replaceable> non  settato
              allora lo si setta a <replaceable>default</replaceable> e si usa
              il nuovo valore</entry>
          </row>

          <row>
            <entry><literal>${<replaceable>parametro</replaceable>+<replaceable>nuovo_valore</replaceable>}</literal></entry>

            <entry>se <replaceable>parametro</replaceable>  settato
              allora si usa <replaceable>nuovo_valore</replaceable> altrimenti
              non si usa nulla.  <replaceable>parametro</replaceable> non viene
              resettato.</entry>
          </row>

          <row>
            <entry><literal>${<replaceable>parametro</replaceable>?<replaceable>messaggio</replaceable>}</literal></entry>

            <entry>se <replaceable>parametro</replaceable> non  settato
              allora si visualizza il messaggio.  Se
              <replaceable>parametro</replaceable>  settato allora si
              usa il valore corrente.</entry>
          </row>
        </tbody>
      </tgroup>
    </informaltable>

    <para>Non ci sono spazi nei precedenti operatori.  Se un due punti (:) viene
      inserito prima di  -, =, + o ? allora si effettua prima un test per vedere
      se il parametro ha un settaggio <emphasis>non-nullo</emphasis>.</para>

    <para>La shell C ha alcuni modi aggiuntivi per la sostituzione di
      parametri:</para>

    <informaltable frame="none">
      <tgroup cols="2">
        <colspec colwidth="1.5in"/>

        <tbody>
          <row>
            <entry><literal>$lista[<replaceable>n</replaceable>]</literal></entry>

            <entry>seleziona l'<replaceable>n-esima</replaceable> parola dalla
              lista</entry>
          </row>

          <row>
            <entry><literal>${lista[<replaceable>n</replaceable>]}</literal></entry>

            <entry>come sopra</entry>
          </row>

          <row>
            <entry><literal>$#lista</literal></entry>

            <entry>riporta il numero di parole in lista</entry>
          </row>

          <row>
            <entry><literal>$?<replaceable>parametro</replaceable></literal></entry>

            <entry>ritorna 1 se il parametro  settato, 0
              altrimenti</entry>
          </row>

          <row>
            <entry><literal>${?<replaceable>parametro</replaceable>}</literal></entry>

            <entry>come sopra</entry>
          </row>

          <row>
            <entry><literal>$&lt;</literal></entry>

            <entry>legge una linea da &man.stdin.4;</entry>
          </row>
        </tbody>
      </tgroup>
    </informaltable>

    <para>Inoltre la shell C definisce l'array
      <literal>$argv[<replaceable>n</replaceable>]</literal> per
      contenere gli <replaceable>n</replaceable> argomenti della linea di
      comando e <literal>$#argv</literal> per il numero di argomenti, come
      specificato in <link linkend="shell-programming-table-shell-var">Tabella
        9.1</link>.</para>

    <para>Per illustrare alcune di queste caratteristiche si user il
      seguente script di prova:</para>

    <programlisting>#!/bin/sh
param0=$0
test -n "$1" && param1=$1
test -n "$2" && param2=$2
test -n "$3" && param3=$3
echo 0: $param0
echo "1: ${param1-1}: \c" ;echo $param1
echo "2: ${param2=2}: \c" ;echo $param2
echo "3: ${param3+3}: \c" ;echo $param3</programlisting>

    <para>Inizialmente nello script si verifica con &man.test.1; se la
      variabile esiste; in tal caso si setta il parametro al suo valore.
      Dopo si riportano i valori, effettuando le sostituzioni.</para>

    <para>Nella prima esecuzione dello script non vengono forniti
      argomenti:</para>

    <screen>$ <userinput>./parameter.sh</userinput>
0: ./parameter.sh       # trova sempre $0
1: 1:                   # sostituisce  1, ma non assegna questo valore
2: 2: 2                 # sostituisce 2 e assegna questo valore
3: :                    # non sostituisce</screen>

    <para>In questa seconda esecuzione dello script si forniscono alcuni
      argomenti:</para>

    <screen>$ <userinput>./parameter one two three</userinput>
0: ./parameter.sh       # trova sempre $0
1: one: one             # non sostituisce, ha gi un valore
2: two: two             # non sostituisce, ha gi un valore
3: 3: three             # sostituisce 3 ma non assegna questo valore</screen>
  </sect1>

  <sect1 id="shell-programming-here-doc">
    <title>Here document</title>

    <para>Un <emphasis>here document</emphasis>  una forma di quoting
      che permette alle variabili di shell di essere sostituite.   una
      forma speciale di redirezione che inizia con una linea contenente
      solamente <emphasis>&lt;&lt;<replaceable>PAROLA</replaceable></emphasis>
      e finisce con una linea contenete solamente
      <emphasis><replaceable>PAROLA</replaceable></emphasis>.  Nella shell
      Bourne si pu impedire la sostituzione di shell effettuando un
      escape su <emphasis><replaceable>PAROLA</replaceable></emphasis>, mettendo
      un \ davanti a <emphasis><replaceable>PAROLA</replaceable></emphasis>
      sulla linea di redirezione, esempio
      <emphasis>&lt;&lt;\<replaceable>PAROLA</replaceable></emphasis>, ma non
      sulla linea finale.  Per avere lo stesso effetto con la shell C si mette
      il \ davanti a <emphasis><replaceable>PAROLA</replaceable></emphasis> in
      entrambi i posti.</para>

    <para>Gli script che seguono illustrano questo meccanismo:</para>

    <informaltable frame="none">
      <tgroup cols="2">
        <colspec colwidth="3.3in"/>

        <tbody>
          <row>
            <entry>per la <emphasis>shell Bourne</emphasis>:</entry>

            <entry>e per la <emphasis>shell C:</emphasis></entry>
          </row>
        </tbody>
      </tgroup>
    </informaltable>

    <programlisting>#!/bin/sh                               #!/bin/csh -f
fa=fa                                   set fa = fa
non=""                                  set non = ""
cat &lt;&lt; EOF                              cat &lt;&lt; EOF
Questo here document                    Questo here document
$non $fa                                $non $fa
sostituzione di variabile               sostituzione di variabile
EOF                                     EOF
cat &lt;&lt; \EOF                             cat &lt;&lt; \EOF
Questo here document                    Questo here document
$non $fa                                $non $fa
sostituzione di variabile               sostituzione di variabile
EOF                                     \EOF</programlisting>

    <para>Entrambi gli output producono:</para>

    <screen>Questo here document
fa
sostituzione di variabile
Questo here document
$non $fa
sostituzione di variabile</screen>

    <para>Nella parte superiore dell'esempio le variabili di shell
      <literal>$non</literal> e <literal>$fa</literal> sono sostituite.
      Nella parte inferiore queste variabili vengono trattate come delle
      semplici stringhe di testo senza effettuare la sostituzione.</para>
  </sect1>

  <sect1 id="shell-programming-int-input">
    <title>Input interattivo</title>

    <para>Gli script di shell possono accettare input interattivo per
      inizializzare parametri all'interno dello script stesso.</para>

    <sect2 id="shell-programming-int-input-sh">
      <title>Sh</title>

      <para>&man.sh.1; utilizza il comando built-in <command>read</command> per
        leggere una linea di input, esempio:</para>

      <para><command>read param</command></para>

      <para>Questo pu essere illustrato con un semplice script:</para>

      <programlisting>#!/bin/sh
echo "Inserisci una frase \c"   # /bin/echo che richiede "\c" per
                                # impedire un newline
read param
echo param=$param</programlisting>

      <para>Quando questo script viene eseguito, viene richiesto l'input, che
        viene poi mostrato nel risultato:</para>

      <screen>$ <userinput>./read.sh</userinput>
<prompt>Inserisci una frase</prompt> <userinput>hello frank</userinput>  # E' stato digitato hello frank &lt;return&gt;
param=hello frank</screen>
    </sect2>

    <sect2 id="shell-programming-int-input-csh">
      <title>Csh</title>

      <para>&man.csh.1; usa il simbolo <literal>$&lt;</literal> per leggere una
        linea da &man.stdin.4;, esempio:</para>

      <para><command>set param = $<</command></para>

      <para>Gli spazi bianchi intorno al segno di uguale sono importanti.
        Il seguente script illustra come usarlo:</para>

      <programlisting>#!/bin/csh -f
  echo -n "Inserisci una frase"    # Questo echo built-in richiede -n
                                    # per impedire un newline
  set param = $&lt;
  echo param=$param</programlisting>

      <para>Quindi chiede l'input e lo mostra nel risultato:</para>

      <screen>&prompt.user; <userinput>./read.csh</userinput>
<prompt>Inserisci una frase</prompt> <userinput>hello frank</userinput> # E' stato digitato hello frank &lt;return&gt;
param=hello frank</screen>
    </sect2>
  </sect1>

  <sect1 id="shell-programming-functions">
    <title>Funzioni</title>

    <para>La shell Bourne permette di definire funzioni.  Queste sono molto
      simili agli alias della shell C, ma permettono pi
      flessibilit.  Una funzione ha la forma:</para>

    <para><command><replaceable>funzione</replaceable> () {
        <replaceable>comando</replaceable>; }</command></para>

    <para>dove lo spazio dopo { e il punto e virgola (;) sono obbligatori;
      il punto e virgola pu essere omesso facendo precedere a } un
      newline.  Spazi e newline aggiuntivi sono permessi.
      Alcuni esempi di funzioni possono essere visti nel semplice file
      <filename>.profile</filename> discusso nei primi capitoli, dove si avevano
      delle funzioni per <command>ls</command> e <command>ll</command>:</para>

    <para><command>ls() { /bin/ls -sbF "$@";}</command></para>

    <para><command>ll() { ls -al "$@";}</command></para>

    <para>La prima funzione ridefinisce &man.ls.1; affinch le opzioni
      <option>-sbF</option> siano sempre fornite dal comando standard
      <command>/bin/ls</command> e in modo da agire in base all'input fornito,
      <literal>$@</literal>.  La seconda di queste funzioni prende il valore
      corrente di <command>ls</command> (la funzione precedente) e aggiunge le
      opzioni <option>-al</option>.</para>

    <para>Le funzioni sono molto utili negli script di shell.  Il seguente
      script  una versione semplificata di uno script utilizzato per
      effettuare automaticamente il backup su nastro delle partizioni di
      sistema.</para>

    <programlisting>#!/bin/sh
# Script cron per un completo backup del sistema
HOST=`/bin/uname -n`
admin=frank
Mt=/bin/mt
Dump=/usr/sbin/ufsdump
Mail=/bin/mailx
device=/dev/rmt/0n
Rewind="$Mt -f $device rewind"
Offline="$Mt -f $device rewoffl"
# Failure - exit
failure () {
  $Mail -s "Backup fallito - $HOST" $admin << EOF_failure
  $HOST
  Script cron backup fallito. A quanto pare non c' il nastro nel dispositivo.
  EOF_failure
  exit 1
 }
# Dump failure - exit
dumpfail () {
  $Mail -s "Backup fallito - $HOST" $admin << EOF_dumpfail
  $HOST
  Script cron backup fallito. A quanto pare non c' il nastro nel dispositivo.
  EOF_dumpfail
  exit 1
 }
# Success
success () {
  $Mail -s "Backup completato con successo - $HOST" $admin << EOF_success
  $HOST
  Script cron backup apparentemente riuscito. Il file /etc/dumpdates :
  `/bin/cat /etc/dumpdates`
  EOF_success
  }
# Conferma nastro nel device
$Rewind || failure
$Dump 0uf $device / || dumpfail
$Dump 0uf $device /usr || dumpfail
$Dump 0uf $device /home || dumpfail
$Dump 0uf $device /var || dumpfail
($Dump 0uf $device /var/spool/mail || dumpfail) && success
$Offline</programlisting>

    <para>Questo script illustra alcuni argomenti che sono stati trattati in
      questo documento.  Lo script inizia settando i valori di alcuni parametri.
      <literal>HOST</literal> viene inizializzato dall'output di un comando,
      <literal>admin</literal>  l'amministratore di sistema,
      <literal>Mt</literal>, <literal>Dump</literal> e <literal>Mail</literal>
      sono nomi di programmi, <literal>device</literal>  il dispositivo
      speciale usato per accedere al nastro, <literal>Rewind</literal> e
      <literal>Offline</literal> contengono i comandi rispettivamente per
      riavvolgere e scaricare il nastro usando il riferimento
      <literal>Mt</literal> e le necessarie opzioni.  Vengono definite
      tre funzioni: <command>failure</command>, <command>dumpfail</command> e
      <command>success</command>.  Tutte le funzioni in questo script utilizzano
      la forma <emphasis>here document</emphasis> per realizzare il contenuto
      della funzione stessa.  Si introducono ora gli operatori logici
      <emphasis>OR</emphasis> (<emphasis>||</emphasis>) e
      <emphasis>AND</emphasis> (<emphasis>&&</emphasis>); ciascuno 
      posizionato tra una coppia di comandi.  Per l'operatore
      <emphasis>OR</emphasis>, il secondo comando viene eseguito solamente se
      il primo comando non  stato completato con successo.  Per
      l'operatore <emphasis>AND</emphasis>, il secondo comando viene
      eseguito solamente se il primo comando  stato completato con
      successo.</para>

    <para>Lo scopo principale dello script  realizzare i comandi
      <command>Dump</command>, ad esempio copiando i file system specificati.
      Prima si tenta di eseguire il riavvolgimento del nastro.  Se questo
      fallisce, <literal>|| failure</literal>, si esegue la funzione
      <command>failure</command> e si esce dal programma.  Se invece questo ha
      successo si procede con il backup a turno di ogni partizione, ogni volta
      verificando che questa operazione sia completamente riuscita
      (<literal>|| dumpfail</literal>).  Se questa operazione non viene eseguita
      completamente con successo si esegue la procedura
      <command>dumpfail</command> e si esce.  Se l'ultimo backup ha successo si
      procede con la funzione <command>success</command> (<literal>(...) &&
      success</literal>).  In fine si riavvolge il nastro e lo si manda fuori
      linea affinch altri utenti non possano accidentalmente scriverci
      sopra.</para>
  </sect1>

  <sect1 id="shell-programming-control-comm">
    <title>Comandi di controllo</title>

    <sect2 id="shell-programming-control-comm-if">
      <title>Condizionale if</title>

      <para>L'espressione condizionale <command>if</command> 
        disponibile in entrambe le shell, ma con una diversa sintassi.</para>

      <sect3 id="shell-programming-control-comm-if-sh">
        <title>Sh</title>

        <programlisting><command>if</command> <replaceable>condizione1</replaceable>
<command>then</command>
        lista di comandi se <replaceable>condizione1</replaceable>  vera (true)
[<command>elif</command> <replaceable>condizione2</replaceable>
        <command>then</command> lista di comandi se <replaceable>condizione2</replaceable>  vera (true)]
[<command>else</command>
        lista di comandi se <replaceable>condizione1</replaceable>  falsa (false)]
<command>fi</command></programlisting>

        <para>Le condizioni sono sottoposte usualmente al comando &man.test.1; o
          <command>[]</command> (Vedere la <link
            linkend="shell-programming-control-comm-test">sezione 9.9.6</link>).
          L'<command>if</command> e <command>then</command> devono essere
          separati con un newline o un punto e virgola (;).</para>

        <programlisting>#!/bin/sh
if [ $# -ge 2 ]
then
  echo $2
elif [ $# -eq 1 ]; then
  echo $1
else
  echo Nessun input
fi</programlisting>

        <para>Sono richiesti degli spazi nel formato della condizione di
          &man.test.1;, uno dopo <command>[</command> e uno prima di
          <command>]</command>.  Questo script potrebbe comportarsi in modo
          differente a seconda che ci siano zero, uno o pi argomenti su
          linea di comando.  Iniziando con nessun argomento:</para>

        <screen>$ <userinput>./if.sh</userinput>
Nessun input</screen>

        <para>Ora con un argomento:</para>

        <screen>$ <userinput>./if.sh one</userinput>
one</screen>

        <para>E ora con due argomenti:</para>

        <screen>$ <userinput>./if.sh one two</userinput>
two</screen>
      </sect3>

      <sect3 id="shell-programming-control-comm-if-csh">
        <title>Csh</title>

        <programlisting><command>if</command> (<replaceable>condizione</replaceable>) <command><replaceable>comando</replaceable></command>
   -oppure-
<command>if</command> (<replaceable>condizione1</replaceable>) <command>then</command>
        lista di comandi se <replaceable>condizione1</replaceable>  vera (true)
[<command>else</command> <command>if</command> (<replaceable>condizione2</replaceable>) <command>then</command>
        lista di comandi se <replaceable>condizione2</replaceable>  vera (true)]
[<command>else</command>
        lista di comandi se <replaceable>condizione1</replaceable>  falsa (false)]
<command>endif</command></programlisting>

        <para>L'<command>if</command> e <command>then</command> devono stare
          sulla stessa linea.</para>

        <programlisting>#!/bin/csh -f
if ( $#argv >= 2 ) then
  echo $2
else if ( $#argv == 1 ) then
  echo $1
else
  echo Nessun input
endif</programlisting>

        <para>Di nuovo, questo script potrebbe comportarsi in modo differente a
          seconda che ci siano zero, uno o pi argomenti su linea di
          comando.  Iniziando con nessun argomento:</para>

        <screen>&prompt.user; <userinput>./if.csh</userinput>
Nessun input</screen>

        <para>Ora con un argomento:</para>

        <screen>&prompt.user; <userinput>./if.csh one</userinput>
one</screen>

        <para>E ora con due argomenti:</para>

        <screen>&prompt.user; <userinput>./if.csh one two</userinput>
two</screen>
      </sect3>
    </sect2>

    <sect2 id="shell-programming-control-comm-switch-case">
      <title>Condizionale switch e case</title>

      <para>Per scegliere tra una serie di valori di tipo stringa relativi a un
        parametro si usa <command>case</command> nella shell Bourne e
        <command>switch</command> nella shell C.</para>

      <sect3 id="shell-programming-control-comm-switch-case-sh">
        <title>Sh</title>

        <programlisting><command>case</command> <replaceable>parametro</replaceable> <command>in</command>
        <replaceable>schema1</replaceable>[|<replaceable>schema1a</replaceable>]) <replaceable>lista1 di comandi</replaceable>;;
        <replaceable>schema2</replaceable>) <replaceable>lista2 di comandi</replaceable>
                 <replaceable>lista2a di comandi</replaceable>;;
        <replaceable>schema3</replaceable>) <replaceable>lista3 di comandi</replaceable>;;
        *) ;;
<command>esac</command></programlisting>

        <para>Si possono usare validi nomi di file meta-caratteri all'interno
          dello schema per il confronto.  I ;; concludono ogni scelta e
          possono essere sulla stessa linea della scelta o a seguito di un
          newline, dopo l'ultimo comando per la scelta.  Schemi alternativi
          per la scelta di un particolare caso sono separati da una barra
          verticale |, come nel primo schema dell'esempio precedente.  I simboli
          wild card ,? per indicare un generico carattere e * per far
          corrispondere alcuni caratteri, possono essere usati singolarmente o
          in modo adiacente per completare stringhe.</para>

        <para>Questo semplice esempio illustra come usare l'espressione
          condizionale <command>case</command>.</para>

        <programlisting>#!/bin/sh
case $1 in
        aa|ab) echo A
        ;;
        b?)    echo "B \c"
               echo $1;;
        c*)    echo C;;
        *)     echo D;;
esac</programlisting>

        <para>Quindi quando si esegue lo script con l'argomento posto sulla
          colonna di sinistra, lo script risponde come sulla colonna di
          destra:</para>

        <informaltable frame="none">
          <tgroup cols="2">
            <colspec colwidth="0.5in"/>

            <tbody>
              <row>
                <entry>aa</entry>

                <entry>A</entry>
              </row>

              <row>
                <entry>ab</entry>

                <entry>A</entry>
              </row>

              <row>
                <entry>ac</entry>

                <entry>D</entry>
              </row>

              <row>
                <entry>bb</entry>

                <entry>B bb</entry>
              </row>

              <row>
                <entry>bbb</entry>

                <entry>D</entry>
              </row>

              <row>
                <entry>c</entry>

                <entry>C</entry>
              </row>

              <row>
                <entry>cc</entry>

                <entry>C</entry>
              </row>

              <row>
                <entry>fff</entry>

                <entry>D</entry>
              </row>
            </tbody>
          </tgroup>
        </informaltable>
      </sect3>

      <sect3 id="shell-programming-control-comm-switch-case-csh">
        <title>Csh</title>

        <programlisting><command>switch</command> (<replaceable>parametro</replaceable>)
<command>case</command> <replaceable>schema1</replaceable>:
        <replaceable>lista1 di comandi</replaceable>
        [<command>breaksw</command>]
<command>case</command> <replaceable>schema2</replaceable>:
        <replaceable>lista2 di comandi</replaceable>
        [<command>breaksw</command>]
<command>default</command>:
        lista di comandi per il comportamento di default
        [<command>breaksw</command>]
<command>endsw</command></programlisting>

        <para><command>breaksw</command>  opzionale e pu essere
          usato per interrompere lo switch dopo che si  verificata una
          corrispondenza del valore di tipo stringa del parametro confrontato.
          <command>Switch</command> non accetta | nella lista degli schemi, ma
          permette di unire insieme diverse strutture <command>case</command>
          per fornire un simile risultato.  Il seguente script di shell C ha lo
          stesso comportamento dell'esempio precedente, riferito al
          <command>case</command> della shell Bourne.</para>

        <programlisting>#!/bin/csh -f
switch ($1)
        case aa:
        case ab:
                echo A
                breaksw
        case b?:
                echo -n "B "
                echo $1
                breaksw
        case c*:
                echo C
                breaksw
        default:
                echo D
endsw</programlisting>
      </sect3>
    </sect2>

    <sect2 id="shell-programming-control-comm-for-foreach">
      <title>for e foreach</title>

      <para>Per effettuare un ciclo tra una lista di valori di tipo
        stringa si possono usare i comandi <command>for</command> e
        <command>foreach</command>.</para>

      <sect3 id="shell-programming-control-comm-for-foreach-sh">
        <title>Sh</title>

        <programlisting><command>for</command> <replaceable>variabile</replaceable> [<command>in</command> <replaceable>lista_di_valori</replaceable>]
<command>do</command>
        <replaceable>lista di comandi</replaceable>
<command>done</command></programlisting>

        <para>La <replaceable>lista_di_valori</replaceable>  opzionale,
          presupponendo <literal>$@</literal> se nulla viene specificato.  Ogni
          valore in questa lista viene sostituito sequenzialmente in
          <replaceable>variabile</replaceable> fino a quando la lista risulta
          vuota.  Possono essere usati wild card, che vengono applicati ai
          nomi dei file nella directory corrente.  Di seguito si illustra il
          ciclo <command>for</command> che copia tutti i file che finiscono con
          <filename>.old</filename> negli stessi nomi che finiscono per
          con <filename>.new</filename>.  In questi esempi l'utility
          &man.basename.1; estrae la parte base del nome affinch
          si possa modificarne l'estensione.</para>

        <programlisting>#!/bin/sh
for file in *.old
do
        newf=`basename $file .old`
        cp $file $newf.new
done</programlisting>
      </sect3>

      <sect3 id="shell-programming-control-comm-for-foreach-csh">
        <title>Csh</title>

        <programlisting><command>foreach</command> <replaceable>variabile</replaceable> (<replaceable>lista_di_valori</replaceable>)
        <replaceable>lista di comandi</replaceable>
<command>end</command></programlisting>

        <para>L'equivalente script in shell C per copiare tutti i file con
          estensione <filename>.old</filename> negli stessi file con estensione
          <filename>.new</filename> :</para>

        <programlisting>#!/bin/csh -f
foreach file (*.old)
        set newf = `basename $file .old`
        cp $file $newf.new
end</programlisting>
      </sect3>
    </sect2>

    <sect2 id="shell-programming-control-comm-while">
      <title>while</title>

      <para>Il comando <command>while</command> permette di effettuare il ciclo
        sempre che la condizione sia vera.</para>

      <sect3 id="shell-programming-control-comm-while-sh">
        <title>Sh</title>

        <programlisting><command>while</command> <replaceable>condizione</replaceable>
<command>do</command>
        <replaceable>lista di comandi</replaceable>
        [<command>break</command>]
        [<command>continue</command>]
<command>done</command></programlisting>

        <para>Un semplice script per illustrare il ciclo
          <command>while</command> :</para>

        <programlisting>#!/bin/sh
while [ $# -gt 0 ]
do
        echo $1
        shift
done</programlisting>

        <para>Questo script prende la lista degli argomenti, ne visualizza il
          primo, quindi effettua uno shift nella lista verso sinistra, perdendo
          il primo elemento originale.  Il ciclo viene ripetuto fino a quando
          tutti gli argomenti sono stati spostati fuori dalla lista.</para>

        <screen>$ <userinput>./while.sh one two three</userinput>
one
two
three</screen>
      </sect3>

      <sect3 id="shell-programming-control-comm-while-csh">
        <title>Csh</title>

        <programlisting><command>while</command> (<replaceable>condizione</replaceable>)
        <replaceable>lista di comandi</replaceable>
        [<command>break</command>]
        [<command>continue</command>]
<command>end</command></programlisting>

        <para>Se si vuole che la condizione sia sempre vera si specifica 1
          all'interno del test condizionale.</para>

        <para>Lo script di shell C equivalente a quello precedente
          :</para>

        <programlisting>#!/bin/csh -f
while ($#argv != 0 )
        echo $argv[1]
        shift
end</programlisting>
      </sect3>
    </sect2>

    <sect2 id="shell-programming-control-comm-until">
      <title>until</title>

      <para>Questo costrutto di ciclo  solamente disponibile per la
        shell Bourne.</para>

      <programlisting><command>until</command> <replaceable>condizione</replaceable>
<command>do</command>
        lista di comandi se la condizione  falsa
<command>done</command></programlisting>

      <para>La condizione viene verificata all'inizio di ogni ciclo e il ciclo
        termina quando la condizione  vera.</para>

      <para>Uno script equivalente all'esempio del <command>while</command>
        precedente :</para>

      <programlisting>#!/bin/sh
until [ $# -le 0 ]
do
        echo $1
        shift
done</programlisting>

      <para>Si noti che qui si verifica per <emphasis>minore o
        uguale</emphasis>, piuttosto che per <emphasis>maggiore</emphasis>,
        poich il ciclo <command>until</command> viene abilitato da una
        condizione <emphasis>falsa</emphasis>.</para>

      <para>Sia il ciclo <command>until</command> che il
        <command>while</command> sono solamente eseguiti se la condizione
         soddisfatta.  La condizione viene valutata prima
        dell'esecuzione dei comandi.</para>
    </sect2>

    <sect2 id="shell-programming-control-comm-test">
      <title>test</title>

      <para>Le espressioni condizionali vengono valutate per valori
        <emphasis>veri</emphasis> o <emphasis>falsi</emphasis>.  Questo, di
        solito, viene realizzato con &man.test.1; o equivalentemente con i suoi
        operatori <command>[]</command>.  Se la condizione viene valutata vera,
        viene settato uno stato di uscita zero (<emphasis>TRUE</emphasis>),
        altrimenti viene settato uno stato di uscita non-zero
        (<emphasis>FALSE</emphasis>).  Se non ci sono argomenti viene settato
        uno stato di uscita non-zero.  Gli operatori utilizzati nelle
        espressioni condizionali della shell Bourne sono mostrati qui
        sotto.</para>

      <para>Per i <emphasis>nomi di file</emphasis> le opzioni per
        &man.test.1; sono date con la sintassi seguente:</para>

      <para><option>-<replaceable>opzione</replaceable></option>
        <replaceable>filename</replaceable></para>

      <para>Le opzioni di &man.test.1; disponibili per i
         <emphasis>file</emphasis> includono:</para>

      <informaltable frame="none">
        <tgroup cols="2">
          <colspec colwidth="1in"/>

          <tbody>
            <row>
              <entry><option>-r</option></entry>

              <entry>vero se il file esiste ed  leggibile</entry>
            </row>

            <row>
              <entry><option>-w</option></entry>

              <entry>vero se il file esiste ed  scrivibile</entry>
            </row>

            <row>
              <entry><option>-x</option></entry>

              <entry>vero se il file esiste ed  eseguibile</entry>
            </row>

            <row>
              <entry><option>-f</option></entry>

              <entry>vero se il file esiste ed  un file regolare (o per
                &man.csh.1; esiste e non  una directory)</entry>
            </row>

            <row>
              <entry><option>-d</option></entry>

              <entry>vero se il file esiste ed  una directory</entry>
            </row>

            <row>
              <entry><option>-h</option> o <option>-L</option></entry>

              <entry>vero se il file esiste ed  un link
                simbolico</entry>
            </row>

            <row>
              <entry><option>-c</option></entry>

              <entry>vero se il file esiste ed  un file speciale a
                caratteri (ad esempio un dispositivo al quale si accede un
                carattere alla volta)</entry>
            </row>

            <row>
              <entry><option>-b</option></entry>

              <entry>vero se il file esiste ed  un file speciale a
                blocchi (ad esempio un dispositivo al quale si accede in blocchi
                di dati)</entry>
            </row>

            <row>
              <entry><option>-p</option></entry>

              <entry>vero se il file esiste ed  un file pipe
                (fifo)</entry>
            </row>

            <row>
              <entry><option>-u</option></entry>

              <entry>vero se il file esiste ed  setuid (ad esempio ha il
                bit set-user-id settato a s o S nel terzo bit)</entry>
            </row>

            <row>
              <entry><option>-g</option></entry>

              <entry>vero se il file esiste ed  setgid (ad esempio ha il
                bit set-group-id settato a s o S nel sesto bit)</entry>
            </row>

            <row>
              <entry><option>-k</option></entry>

              <entry>vero se il file esiste e ha lo sticky bit settato (una t
                nel nono bit)</entry>
            </row>

            <row>
              <entry><option>-s</option></entry>

              <entry>vero se il file esiste ed ha una dimensione maggiore di
                zero</entry>
            </row>
          </tbody>
        </tgroup>
      </informaltable>

      <para>C' un test per i <emphasis>descrittori di
        file</emphasis>:</para>

      <informaltable frame="none">
        <tgroup cols="2">
          <colspec colwidth="2in"/>

          <tbody>
            <row>
              <entry><option>-t
                  [<replaceable>descrittore_file</replaceable>]</option></entry>

              <entry>vero se l'aperto descrittore del file specificato (1,
                &man.stdout.4;, di default)  associato ad un
                terminale</entry>
            </row>
          </tbody>
        </tgroup>
      </informaltable>

      <para>Ci sono test per le <emphasis>stringhe</emphasis>:</para>

      <informaltable frame="none">
        <tgroup cols="2">
          <colspec colwidth="2in"/>

          <tbody>
            <row>
              <entry><option>-z
                  <replaceable>stringa</replaceable></option></entry>

              <entry>vero se la lunghezza della stringa  zero</entry>
            </row>

            <row>
              <entry><option>-n
                  <replaceable>stringa</replaceable></option></entry>

              <entry>vero se la lunghezza della stringa non 
                zero</entry>
            </row>

            <row>
              <entry><option><replaceable>stringa1</replaceable> =
                  <replaceable>stringa2</replaceable></option></entry>

              <entry>vero se <replaceable>stringa1</replaceable> 
                identica a <replaceable>stringa2</replaceable></entry>
            </row>

            <row>
              <entry><option><replaceable>stringa1</replaceable> !=
                  <replaceable>stringa2</replaceable></option></entry>

              <entry>vero se <replaceable>stringa1</replaceable> non 
                identica a <replaceable>stringa2</replaceable></entry>
            </row>

            <row>
              <entry><replaceable>stringa</replaceable></entry>

              <entry>vero se la stringa non  nulla</entry>
            </row>
          </tbody>
        </tgroup>
      </informaltable>

      <para>Ci sono dei confronti per gli interi:</para>

      <informaltable frame="none">
        <tgroup cols="2">
          <colspec colwidth="1.5in"/>

          <tbody>
            <row>
              <entry><option><replaceable>n1</replaceable> -eq
                  <replaceable>n2</replaceable></option></entry>

              <entry>vero se gli interi <replaceable>n1</replaceable> e
                <replaceable>n2</replaceable> sono uguali</entry>
            </row>

            <row>
              <entry><option><replaceable>n1</replaceable> -ne
                  <replaceable>n2</replaceable></option></entry>

              <entry>vero se gli interi <replaceable>n1</replaceable> e
                <replaceable>n2</replaceable> non sono uguali</entry>
            </row>

            <row>
              <entry><option><replaceable>n1</replaceable> -gt
                  <replaceable>n2</replaceable></option></entry>

              <entry>vero se l'intero <replaceable>n1</replaceable> 
                maggiore dell'intero <replaceable>n2</replaceable></entry>
            </row>

            <row>
              <entry><option><replaceable>n1</replaceable> -ge
                  <replaceable>n2</replaceable></option></entry>

              <entry>vero se l'intero <replaceable>n1</replaceable> 
                maggiore o uguale dell'intero
                <replaceable>n2</replaceable></entry>
            </row>

            <row>
              <entry><option><replaceable>n1</replaceable> -lt
                  <replaceable>n2</replaceable></option></entry>

              <entry>vero se l'intero <replaceable>n1</replaceable> 
                minore dell'intero <replaceable>n2</replaceable></entry>
            </row>

            <row>
              <entry><option><replaceable>n1</replaceable> -le
                  <replaceable>n2</replaceable></option></entry>

              <entry>vero se l'intero <replaceable>n1</replaceable> 
                minore o uguale dell'intero
                <replaceable>n2</replaceable></entry>
            </row>
          </tbody>
        </tgroup>
      </informaltable>

      <para>Sono disponibili i seguenti <emphasis>operatori
        logici</emphasis>:</para>

      <informaltable frame="none">
        <tgroup cols="2">
          <colspec colwidth="0.5in"/>

          <tbody>
            <row>
              <entry><option>!</option></entry>

              <entry>negazione (unaria)</entry>
            </row>

            <row>
              <entry><option>-a</option></entry>

              <entry>and (binario)</entry>
            </row>

            <row>
              <entry><option>-o</option></entry>

              <entry>or (binario)</entry>
            </row>

            <row>
              <entry><option>()</option></entry>

              <entry>le espressioni all'interno di ( ) vengono raggruppate
                insieme. Pu essere necessario quotare le parentesi ( )
                per impedire alla shell di interpretarle.</entry>
            </row>
          </tbody>
        </tgroup>
      </informaltable>
    </sect2>

    <sect2 id="shell-programming-control-comm-csh-log-rel-op">
      <title>Operatori relazionali e logici della shell C</title>

      <para>La shell C possiede un suo set di operatori logici e relazionali
        built-in.  In ordine decrescente di priorit questi sono:</para>

      <informaltable frame="none">
        <tgroup cols="2">
          <colspec colwidth="1.5in"/>

          <tbody>
            <row>
              <entry><command>(...)</command></entry>

              <entry>raggruppa espressioni con ( )</entry>
            </row>

            <row>
              <entry><command>~</command></entry>

              <entry>inverso (il suo complemento)</entry>
            </row>

            <row>
              <entry><command>!</command></entry>

              <entry>negazione logica</entry>
            </row>

            <row>
              <entry><command>*, /, %</command></entry>

              <entry>moltiplicazione, divisione, modulo</entry>
            </row>

            <row>
              <entry><command>+, -</command></entry>

              <entry>addizione, sottrazione</entry>
            </row>

            <row>
              <entry><command>&lt;&lt;, &gt;&gt;</command></entry>

              <entry>shift a sinistra di bit, shift a destra di bit</entry>
            </row>

            <row>
              <entry><command>&lt;=</command></entry>

              <entry>minore o uguale</entry>
            </row>

            <row>
              <entry><command>&gt;=</command></entry>

              <entry>maggiore o uguale</entry>
            </row>

            <row>
              <entry><command>&lt;</command></entry>

              <entry>minore</entry>
            </row>

            <row>
              <entry><command>&gt;</command></entry>

              <entry>maggiore</entry>
            </row>

            <row>
              <entry><command>= =</command></entry>

              <entry>uguale</entry>
            </row>

            <row>
              <entry><command>!=</command></entry>

              <entry>non uguale</entry>
            </row>

            <row>
              <entry><command>=~</command></entry>

              <entry>uguale a stringa</entry>
            </row>

            <row>
              <entry><command>!~</command></entry>

              <entry>non uguale a stringa</entry>
            </row>

            <row>
              <entry><command>&amp;</command></entry>

              <entry>AND bit</entry>
            </row>

            <row>
              <entry><command>^</command></entry>

              <entry>XOR bit (or esclusivo)</entry>
            </row>

            <row>
              <entry><command>|</command></entry>

              <entry>OR bit</entry>
            </row>

            <row>
              <entry><command>&amp;&amp;</command></entry>

              <entry>AND logico</entry>
            </row>

            <row>
              <entry><command>||</command></entry>

              <entry>OR logico</entry>
            </row>

            <row>
              <entry><command>{<replaceable>comando</replaceable>}</command></entry>

              <entry>vero (1) se il comando termina con uno stato di uscita 0,
                falso (0) altrimenti.</entry>
            </row>
          </tbody>
        </tgroup>
      </informaltable>

      <para>Inoltre la shell C permette richieste sul tipo e sui permessi dei
        file con gli operatori seguenti:</para>

      <informaltable frame="none">
        <tgroup cols="2">
          <colspec colwidth="1in"/>

          <tbody>
            <row>
              <entry><option>-r</option></entry>

              <entry>ritorna vero (1) se il file esiste ed  leggibile,
                altrimenti ritorna falso (0)</entry>
            </row>

            <row>
              <entry><option>-w</option></entry>

              <entry>vero se il file esiste ed  scrivibile</entry>
            </row>

            <row>
              <entry><option>-x</option></entry>

              <entry>vero se il file esiste ed  eseguibile</entry>
            </row>

            <row>
              <entry><option>-f</option></entry>

              <entry>vero se il file esiste e non  una directory</entry>
            </row>

            <row>
              <entry><option>-d</option></entry>

              <entry>vero se il file esiste ed  una directory</entry>
            </row>

            <row>
              <entry><option>-e</option></entry>

              <entry>vero se il file esiste</entry>
            </row>

            <row>
              <entry><option>-o</option></entry>

              <entry>vero se l'utente corrente  il proprietario del
                file</entry>
            </row>

            <row>
              <entry><option>-z</option></entry>

              <entry>vero se il file ha una lunghezza zero (file vuoto)</entry>
            </row>
          </tbody>
        </tgroup>
      </informaltable>
    </sect2>
  </sect1>
</chapter>