Lines Matching +full:un +full:-
1 .. include:: ../disclaimer-ita.rst
3 :Original: :ref:`Documentation/process/coding-style.rst <codingstyle>`
11 Questo è un breve documento che descrive lo stile di codice preferito per
19 di codifica GNU e di NON leggerla. Bruciatela, è un grande gesto simbolico.
24 ---------------
29 pi-greco a 3.
31 Motivazione: l'idea dell'indentazione è di definire chiaramente dove un blocco
36 Ora, alcuni rivendicano che un'indentazione da 8 caratteri sposta il codice
49 i ``case``. Un esempio.:
51 .. code-block:: c
73 .. code-block:: c
80 .. code-block:: c
87 .. code-block:: c
102 Procuratevi un buon editor di testo e non lasciate spazi bianchi alla fine
107 -----------------------------------
130 ---------------------------------------------
132 Un altro problema che s'affronta sempre quando si parla di stile in C è
135 una strategia di posizionamento o un'altra; ma il modo qui preferito,
140 .. code-block:: c
149 .. code-block:: c
165 .. code-block:: c
179 espressione, in pratica ``while`` nell'espressione do-while, oppure ``else``
180 nell'espressione if-else, come questo:
182 .. code-block:: c
185 body of do-loop
190 .. code-block:: c
210 .. code-block:: c
217 .. code-block:: none
224 Questo non vale nel caso in cui solo un ramo dell'espressione if-else
228 .. code-block:: c
237 Inoltre, usate le graffe se un ciclo contiene più di una semplice istruzione:
239 .. code-block:: c
263 .. code-block:: c
268 Non aggiungete spazi attorno (dentro) ad un'espressione fra parentesi. Questo
271 .. code-block:: c
276 Quando dichiarate un puntatore ad una variabile o una funzione che ritorna un
280 .. code-block:: c
290 = + - < > * / % | & ^ <= >= == != ? :
294 & * + - ~ ! sizeof typeof alignof __attribute__ defined
298 ++ --
302 ++ --
305 ``->``.
321 -----------------
323 C è un linguaggio spartano, e così dovrebbero esserlo i vostri nomi. Al
324 contrario dei programmatori Modula-2 o Pascal, i programmatori C non usano
325 nomi graziosi come ThisVariableIsATemporaryCounter. Un programmatore C
330 descrittivi per variabili globali sono un dovere. Chiamare una funzione
331 globale ``pippo`` è un insulto.
339 ungherese) è stupido - il compilatore conosce comunque il tipo e
343 un qualsiasi contatore di ciclo, probabilmente sarà chiamato ``i``.
346 variabile che viene usata per salvare temporaneamente un valore.
349 avete un altro problema che è chiamato sindrome dello squilibrio dell'ormone
353 --------------------------------
358 .. code-block:: c
365 .. code-block:: c
393 Ancora - dev'esserci una **ragione** per farlo. Se qualcosa è
412 con segno, identici ai tipi standard, sono permessi- tuttavia, non sono
423 non usare MAI MAI un typedef a meno che non rientri in una delle regole
426 In generale, un puntatore, o una struttura a cui si ha accesso diretto in
427 modo ragionevole, non dovrebbero **mai** essere definite con un typedef.
430 -----------
438 una funzione che è concettualmente semplice ma che è implementata come un
439 lunga (ma semplice) sequenza di caso-istruzione, dove avete molte piccole cose
447 prestazioni, e probabilmente farà un lavoro migliore di quanto avreste potuto
450 Un'altra misura delle funzioni sono il numero di variabili locali. Non
451 dovrebbero eccedere le 5-10, oppure state sbagliando qualcosa. Ripensate la
452 funzione, e dividetela in pezzettini. Generalmente, un cervello umano può
461 .. code-block:: c
474 perché è un modo semplice per aggiungere informazioni importanti per il
480 …nzione mantenete `l'ordine degli elementi <https://lore.kernel.org/mm-commits/CAHk-=wiOCLRny5aifWN…
487 L'ordine suggerito per gli elementi di un prototipo di funzione è il seguente:
489 - classe d'archiviazione (in questo caso ``static __always_inline``. Da notare
490 che ``__always_inline`` è tecnicamente un attributo ma che viene trattato come
492 - attributi della classe di archiviazione (in questo caso ``__init``, in altre
494 - il tipo di ritorno (in questo caso, ``void *``)
495 - attributi per il valore di ritorno (in questo caso, ``__must_check``)
496 - il nome della funzione (in questo caso, ``action``)
497 - i parametri della funzione(in questo caso,
500 - attributi dei parametri (in questo caso, ``__printf(4, 5)``)
501 - attributi per il comportamento della funzione (in questo caso, ``__malloc_``)
516 ------------------------------------------
525 Assegnate un nome all'etichetta di modo che suggerisca cosa fa la goto o
526 perché esiste. Un esempio di un buon nome potrebbe essere ``out_free_buffer:``
527 se la goto libera (free) un ``buffer``. Evitate l'uso di nomi GW-BASIC come
533 - i salti incondizionati sono più facili da capire e seguire
534 - l'annidamento si riduce
535 - si evita di dimenticare, per errore, di aggiornare un singolo punto d'uscita
536 - aiuta il compilatore ad ottimizzare il codice ridondante ;)
538 .. code-block:: c
547 return -ENOMEM;
562 Un baco abbastanza comune di cui bisogna prendere nota è il ``one err bugs``
565 .. code-block:: c
568 kfree(foo->bar);
576 .. code-block:: c
579 kfree(foo->bar);
589 -----------
592 spiegare COME funziona il vostro codice in un commento: è molto meglio
599 tornare al punto 6 per un momento. Potete mettere dei piccoli commenti per
600 annotare o avvisare il lettore circa un qualcosa di particolarmente arguto
606 formato kernel-doc. Per maggiori dettagli, leggete i file in
607 :ref::ref:`Documentation/translations/it_IT/doc-guide/ <it_doc_guide>` e in
608 ``script/kernel-doc``.
610 Lo stile preferito per i commenti più lunghi (multi-riga) è:
612 .. code-block:: c
615 * This is the preferred style for multi-line
620 * with beginning and ending almost-blank lines.
624 più lunghi (multi-riga) è leggermente diverso.
626 .. code-block:: c
632 * but there is no initial almost-blank line.
636 derivati. A questo scopo, dichiarate un dato per riga (niente virgole
637 per una dichiarazione multipla). Questo vi lascerà spazio per un piccolo
641 9) Avete fatto un pasticcio
642 ---------------------------
648 premere tasti a caso - un numero infinito di scimmie che scrivono in
649 GNU emacs non faranno mai un buon programma).
655 .. code-block:: none
657 (defun c-lineup-arglist-tabs-only (ignored)
659 (let* ((anchor (c-langelem-pos c-syntactic-element))
660 (column (c-langelem-2nd-pos c-syntactic-element))
661 (offset (- (1+ column) anchor))
662 (steps (floor offset c-basic-offset)))
664 c-basic-offset)))
666 (dir-locals-set-class-variables
667 'linux-kernel
668 '((c-mode . (
669 (c-basic-offset . 8)
670 (c-label-minimum-indentation . 0)
671 (c-offsets-alist . (
672 (arglist-close . c-lineup-arglist-tabs-only)
673 (arglist-cont-nonempty .
674 (c-lineup-gcc-asm-reg c-lineup-arglist-tabs-only))
675 (arglist-intro . +)
676 (brace-list-intro . +)
677 (c . c-lineup-C-comments)
678 (case-label . 0)
679 (comment-intro . c-lineup-comment)
680 (cpp-define-intro . +)
681 (cpp-macro . -1000)
682 (cpp-macro-cont . +)
683 (defun-block-intro . +)
684 (else-clause . 0)
685 (func-decl-cont . +)
687 (inher-cont . c-lineup-multi-inher)
688 (knr-argdecl-intro . 0)
689 (label . -1000)
691 (statement-block-intro . +)
692 (statement-case-intro . +)
693 (statement-cont . +)
696 (indent-tabs-mode . t)
697 (show-trailing-whitespace . t)
700 (dir-locals-set-directory-class
701 (expand-file-name "~/src/linux-trees")
702 'linux-kernel)
705 si trovano nella cartella ``~/src/linux-trees``.
715 ``-kr -i8`` (che significa ``K&R, 8 caratteri di indentazione``), o utilizzate
718 ``indent`` ha un sacco di opzioni, e specialmente quando si tratta di
719 riformattare i commenti dovreste dare un'occhiata alle pagine man.
720 Ma ricordatevi: ``indent`` non è un correttore per una cattiva programmazione.
722 Da notare che potete utilizzare anche ``clang-format`` per aiutarvi con queste
729 :ref:`Documentation/translations/it_IT/process/clang-format.rst <it_clangformat>`.
733 ----------------------------------
736 sorgenti, l'indentazione è un po' differente. Le linee dopo un ``config``
737 sono indentate con un tab, mentre il testo descrittivo è indentato di
746 logging of avc messages output). Does not do system-call
759 il documento Documentation/kbuild/kconfig-language.rst
763 ------------------
767 avere un contatore di riferimenti. Nel kernel non esiste un
769 e inefficienti), questo significa che **dovete** assolutamente avere un
772 Avere un contatore di riferimenti significa che potete evitare la
774 in parallelo - e non doversi preoccupare di una struttura dati che
776 o stava facendo altro per un attimo.
789 Un esempio di questo tipo di conteggio dei riferimenti multi-livello può
794 Ricordatevi: se un altro thread può trovare la vostra struttura dati, e non
795 avete un contatore di riferimenti per essa, quasi certamente avete un baco.
798 ---------------------------
803 .. code-block:: c
815 Le macro che contengono più istruzioni dovrebbero essere sempre chiuse in un
816 blocco do - while:
818 .. code-block:: c
830 .. code-block:: c
835 return -EBUGGERED; \
842 2) le macro che dipendono dall'uso di una variabile locale con un nome magico:
844 .. code-block:: c
851 3) le macro con argomenti che sono utilizzati come l-values; questo potrebbe
859 .. code-block:: c
867 .. code-block:: c
876 ret è un nome comune per una variabile locale - __foo_ret difficilmente
884 --------------------------------------
886 Agli sviluppatori del kernel piace essere visti come dotti. Tenete un occhio
891 I messaggi del kernel non devono terminare con un punto fermo.
903 Tirar fuori un buon messaggio di debug può essere una vera sfida; e quando
912 -DDEBUG nei corrispettivi Makefile, e in altri casi aggiungono #define DEBUG
913 in specifici file. Infine, quando un messaggio di debug dev'essere stampato
918 ---------------------
923 :ref:`Documentation/translations/it_IT/core-api/memory-allocation.rst <it_memory_allocation>`
927 .. code-block:: c
935 Il valore di ritorno è un puntatore void, effettuare un cast su di esso è
936 ridondante. La conversione fra un puntatore void e un qualsiasi altro tipo
939 Il modo preferito per assegnare un vettore è il seguente:
941 .. code-block:: c
945 Il modo preferito per assegnare un vettore a zero è il seguente:
947 .. code-block:: c
957 questi allocatori ritornano un puntatore NULL.
960 -------------------
966 inline porta ad avere un kernel più grande, che si traduce in un sistema nel
969 pagina di cache. Pensateci un attimo; una fallimento nella cache causa una
977 manutenzione del codice per rimuovere gli inline quando compare un secondo
982 -------------------------------------------
986 Questo valore può essere rappresentato come un codice di errore intero
987 (-Exxx = fallimento, 0 = successo) oppure un booleano di successo
988 (0 = fallimento, non-zero = successo).
990 Mischiare questi due tipi di rappresentazioni è un terreno fertile per
996 Se il nome di una funzione è un'azione o un comando imperativo,
997 essa dovrebbe ritornare un codice di errore intero. Se il nome
998 è un predicato, la funzione dovrebbe ritornare un booleano di
1001 Per esempio, ``add work`` è un comando, e la funzione add_work() ritorna 0
1002 in caso di successo o -EBUSY in caso di fallimento. Allo stesso modo,
1003 ``PCI device present`` è un predicato, e la funzione pci_dev_present() ritorna
1013 soggette a questa regola. Solitamente si indicano gli errori ritornando un
1014 qualche valore fuori dai limiti. Un tipico esempio è quello delle funzioni
1015 che ritornano un puntatore; queste utilizzano NULL o ERR_PTR come meccanismo
1019 -----------------
1022 Un valore bool può assumere solo i valori 0 o 1, e implicitamente o
1024 falso (*false*). Quando si usa un tipo bool il costrutto !! non sarà più
1041 in un intero usando campi da 1 bit, oppure usate un tipo dalla larghezza fissa,
1045 raggruppati in un singolo argomento a bit denominato 'flags'; spesso 'flags' è
1046 un'alternativa molto più leggibile se si hanno valori costanti per true/false.
1048 Detto ciò, un uso parsimonioso di bool nelle strutture dati e negli argomenti
1052 ---------------------------------------
1054 Il file di intestazione include/linux/kernel.h contiene un certo numero
1056 Per esempio, se dovete calcolare la lunghezza di un vettore, sfruttate la
1059 .. code-block:: c
1063 Analogamente, se dovete calcolare la dimensione di un qualche campo di una
1066 .. code-block:: c
1068 #define sizeof_field(t, f) (sizeof(((t*)0)->f))
1070 Ci sono anche le macro min() e max() che, se vi serve, effettuano un controllo
1076 -----------------------------------------------------------
1082 .. code-block:: c
1084 -*- mode: c -*-
1088 .. code-block:: c
1092 compile-command: "gcc -DMAGIC_DEBUG_FLAG foo.c"
1098 .. code-block:: c
1110 -------------------
1112 Nel codice specifico per un'architettura, potreste aver bisogno di codice
1136 .. code-block:: c
1143 ---------------------------------
1154 porzioni d'espressioni. Piuttosto che mettere una ifdef in un'espressione,
1168 .. code-block:: c
1174 Il compilatore valuterà la condizione come costante (constant-fold), e quindi
1175 includerà o escluderà il blocco di codice come se fosse in un #ifdef, quindi
1182 Alla fine di un blocco corposo di #if o #ifdef (più di alcune linee),
1183 mettete un commento sulla stessa riga di #endif, annotando la condizione
1186 .. code-block:: c
1193 ------------------------
1198 ISBN 0-13-110362-8 (paperback), 0-13-110370-9 (hardback).
1202 Addison-Wesley, Inc., 1999.
1203 ISBN 0-201-61586-X.
1205 Manuali GNU - nei casi in cui sono compatibili con K&R e questo documento -
1210 URL: https://www.open-std.org/JTC1/SC22/WG14/