Présentation globale

• L'indentation sera celle obtenue avec Emacs (avec la configuration dans /u/a1/.env/.Emacs)

            int     example_align(char *str)
            {
              int   i;
            
              for (i = 0; i < 4; ++i)
                if (i > 2)
                  return 1;
              return 0;
            }
            

• On passe toujours à la ligne après {, } ou une structure de contrôle. On indente une première fois pour les accolades, puis une seconde pour leur contenu.

            if (cp) return cp;            => Incorrect
            
            if (cp) {return cp;}          => Incorrect
            
            if (cp)                         => Correct
            {
              return cp;
            }
            
            if (cp)                         => Correct
              {
                return cp;
              }
            

• On sautera une ligne entre la déclaration de variable et les instructions.

            int     example_foo(char c)
            {
              int   i;
            
              for (i = 0; i < 42; ++i)
                ;
            
              return i;
            }
            

• Une ligne ne doit pas excéder 79 caractères.
• On fera attention à avoir des fonctions courtes et claires, de 25 lignes maximum (entre les 2 accolades de la fonction, les lignes vides comptent).
• Il vous est interdit d'avoir plus de 10 fonctions par fichier dont 5 maximum peuvent être exportées (non déclarées static).
• Il ne doit pas y avoir de commentaires dans les fonctions. S'il y a besoin de commentaires ils doivent se trouver avant la fonction et être rédigés en anglais.

            /*
            ** this function is useless
            */
            void    example_foo(void)
            {
              return;
            }
            

• Les commentaires sont commencés et terminés par une ligne seule. Toutes les lignes intermédiaires s'alignent sur elle, et commencent par **.

            /*
            ** Comment      => Correct
            */
            
            /*
             * Comment      => Incorrect
             */
            

• La déclaration d'arguments se fera dans le style ISO/ANSI C.

            void    example_func(struct s_list *p1, struct s_tree *p2)
            {
            }
            

  et si cela dépasse les 79 colonnes:

            void    example_func(struct s_list             *p1,
                                 struct s_tree             *p2,
                                 struct s_double_list      *p3)
            {
            }
            

  en respectant l'alignement par tabulations (avec M-i dans Emacs).

• Cas des fonctions ne prenant pas d'argument:

            void            example_foo()           => Incorrect
            {
            }
            
            void            example_foo(void)       => Correct
            {
            }