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:: c
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:: elisp
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>`.
731 Se utilizzate un programma compatibile con EditorConfig, allora alcune
737 ----------------------------------
740 sorgenti, l'indentazione è un po' differente. Le linee dopo un ``config``
741 sono indentate con un tab, mentre il testo descrittivo è indentato di
750 logging of avc messages output). Does not do system-call
763 il documento Documentation/kbuild/kconfig-language.rst
767 ------------------
771 avere un contatore di riferimenti. Nel kernel non esiste un
773 e inefficienti), questo significa che **dovete** assolutamente avere un
776 Avere un contatore di riferimenti significa che potete evitare la
778 in parallelo - e non doversi preoccupare di una struttura dati che
780 o stava facendo altro per un attimo.
793 Un esempio di questo tipo di conteggio dei riferimenti multi-livello può
798 Ricordatevi: se un altro thread può trovare la vostra struttura dati, e non
799 avete un contatore di riferimenti per essa, quasi certamente avete un baco.
802 ---------------------------
807 .. code-block:: c
819 Le macro che contengono più istruzioni dovrebbero essere sempre chiuse in un
820 blocco do - while:
822 .. code-block:: c
834 .. code-block:: c
839 return -EBUGGERED; \
846 2) le macro che dipendono dall'uso di una variabile locale con un nome magico:
848 .. code-block:: c
855 3) le macro con argomenti che sono utilizzati come l-values; questo potrebbe
863 .. code-block:: c
871 .. code-block:: c
880 ret è un nome comune per una variabile locale - __foo_ret difficilmente
888 --------------------------------------
890 Agli sviluppatori del kernel piace essere visti come dotti. Tenete un occhio
895 I messaggi del kernel non devono terminare con un punto fermo.
909 Tirar fuori un buon messaggio di debug può essere una vera sfida; e quando
918 -DDEBUG nei corrispettivi Makefile, e in altri casi aggiungono #define DEBUG
919 in specifici file. Infine, quando un messaggio di debug dev'essere stampato
924 ---------------------
929 :ref:`Documentation/translations/it_IT/core-api/memory-allocation.rst <it_memory_allocation>`
933 .. code-block:: c
941 Il valore di ritorno è un puntatore void, effettuare un cast su di esso è
942 ridondante. La conversione fra un puntatore void e un qualsiasi altro tipo
945 Il modo preferito per assegnare un vettore è il seguente:
947 .. code-block:: c
951 Il modo preferito per assegnare un vettore a zero è il seguente:
953 .. code-block:: c
963 questi allocatori ritornano un puntatore NULL.
966 -------------------
972 inline porta ad avere un kernel più grande, che si traduce in un sistema nel
975 pagina di cache. Pensateci un attimo; una fallimento nella cache causa una
983 manutenzione del codice per rimuovere gli inline quando compare un secondo
988 -------------------------------------------
992 Questo valore può essere rappresentato come un codice di errore intero
993 (-Exxx = fallimento, 0 = successo) oppure un booleano di successo
994 (0 = fallimento, non-zero = successo).
996 Mischiare questi due tipi di rappresentazioni è un terreno fertile per
1002 Se il nome di una funzione è un'azione o un comando imperativo,
1003 essa dovrebbe ritornare un codice di errore intero. Se il nome
1004 è un predicato, la funzione dovrebbe ritornare un booleano di
1007 Per esempio, ``add work`` è un comando, e la funzione add_work() ritorna 0
1008 in caso di successo o -EBUSY in caso di fallimento. Allo stesso modo,
1009 ``PCI device present`` è un predicato, e la funzione pci_dev_present() ritorna
1019 soggette a questa regola. Solitamente si indicano gli errori ritornando un
1020 qualche valore fuori dai limiti. Un tipico esempio è quello delle funzioni
1021 che ritornano un puntatore; queste utilizzano NULL o ERR_PTR come meccanismo
1025 -----------------
1028 Un valore bool può assumere solo i valori 0 o 1, e implicitamente o
1030 falso (*false*). Quando si usa un tipo bool il costrutto !! non sarà più
1047 in un intero usando campi da 1 bit, oppure usate un tipo dalla larghezza fissa,
1051 raggruppati in un singolo argomento a bit denominato 'flags'; spesso 'flags' è
1052 un'alternativa molto più leggibile se si hanno valori costanti per true/false.
1054 Detto ciò, un uso parsimonioso di bool nelle strutture dati e negli argomenti
1058 ---------------------------------------
1060 Il file di intestazione include/linux/kernel.h contiene un certo numero
1062 Per esempio, se dovete calcolare la lunghezza di un vettore, sfruttate la
1065 .. code-block:: c
1069 Analogamente, se dovete calcolare la dimensione di un qualche campo di una
1072 .. code-block:: c
1074 #define sizeof_field(t, f) (sizeof(((t*)0)->f))
1076 Ci sono anche le macro min() e max() che, se vi serve, effettuano un controllo
1082 -----------------------------------------------------------
1088 .. code-block:: c
1090 -*- mode: c -*-
1094 .. code-block:: c
1098 compile-command: "gcc -DMAGIC_DEBUG_FLAG foo.c"
1104 .. code-block:: c
1116 -------------------
1118 Nel codice specifico per un'architettura, potreste aver bisogno di codice
1142 .. code-block:: c
1149 ---------------------------------
1160 porzioni d'espressioni. Piuttosto che mettere una ifdef in un'espressione,
1174 .. code-block:: c
1180 Il compilatore valuterà la condizione come costante (constant-fold), e quindi
1181 includerà o escluderà il blocco di codice come se fosse in un #ifdef, quindi
1188 Alla fine di un blocco corposo di #if o #ifdef (più di alcune linee),
1189 mettete un commento sulla stessa riga di #endif, annotando la condizione
1192 .. code-block:: c
1199 ------------------------
1204 ISBN 0-13-110362-8 (paperback), 0-13-110370-9 (hardback).
1208 Addison-Wesley, Inc., 1999.
1209 ISBN 0-201-61586-X.
1211 Manuali GNU - nei casi in cui sono compatibili con K&R e questo documento -
1216 URL: https://www.open-std.org/JTC1/SC22/WG14/