JerryScript Coding Standards

This text is a brief overview of JerryScript Coding Standards. Each rule starts with a short description followed by several examples. We believe examples are better than long explanations. Please follow these guidelines when you submit a patch for review.

General rules

  • Indentation is two spaces.
  • Tab characters are not allowed.
  • Maximum line length is 120 characters (excluding newline).
  • No trailing white space is allowed.
  • Run tools/run-tests.py --check-vera to check several of the coding conventions automatically.

Comments

Only block comments (/* */) are allowed in JerryScript. Comments should be complete sentences (e.g. start with an upper case letter), except for return value, field and argument descriptions (see the exceptions below). The text part of a comment should focus on explaining why the code is doing something rather than what the code is doing.

  1. +++ Good +++
  1.   /* A perfect comment. */
  3.   /* A perfect multiline
  4.    * comment. Each line should
  5.    * start with an asterisk. */
  1. --- Bad ---
  1.   // Double slash comments are not allowed.
  3.   /* not a complete sentence */
  5.   /* A bad mulitiline
  6.      comment. */

All types, constants and functions require a description in JerryScript. These comments should start with /**. The starting /** and ending */ must be on separate lines.

  1. +++ Good +++
  1. /**
  2.  * A correct description.
  3.  */
  1. --- Bad ---
  1. /** An incorrect description. */

Preprocessor defines

The name of a preprocessor macro must be an uppercase string and these macros must be preceded by a description. Abbreviations are allowed but not preferred in new code.

  1. +++ Good +++
  1. /**
  2.  * Short description about the constant.
  3.  */
  4. #define JERRY_VALUE_SEVEN 7
  6. /**
  7.  * Short description about the macro function.
  8.  */
  9. #define JERRY_ADD_TWO_NUMBERS(arg1, arg2) \
  10.   ((arg1) + (arg2))
  12. /**
  13.  * Although this is correct, a reviewer might request
  14.  * to change NUMS to NUMBERS. Hence it is recommended
  15.  * to use NUMBERS in the first place.
  16.  */
  17. #define JERRY_ADD_TWO_NUMS(arg1, arg2) \
  18.   ((arg1) + (arg2))
  1. --- Bad ---
  1. #define JERRY_CONSTANT_WITHOUT_DESCRIPTION 5
  3. #define JeRrY_mIxEd_CaSe_NaMe "str"

Conditional preprocessor directives

A comment is required after #else and #endif in JerryScript. The defined keyword should be omitted from these comments.

  1. +++ Good +++
  1. #ifdef JERRY_A
  3. #else /* !JERRY_A */
  5. #endif /* JERRY_A */
  7. #ifdef JERRY_A
  8. #if defined JERRY_B && defined JERRY_C && (JERRY_C > 6)
  10. #else /* !(JERRY_B && JERRY_C && (JERRY_C > 6)) */
  12. #endif /* JERRY_B && JERRY_C && (JERRY_C > 6) */
  13. #endif /* JERRY_A */
  1. --- Bad ---
  1. #ifdef JERRY_A
  3. #endif
  5. #ifdef JERRY_A
  7. #endif /* defined JERRY_A */
  9. #ifdef JERRY_B
  10.   /* Missing comment after else. */
  11. #else
  13. #endif /* JERRY_B */

Code blocks

Each code block must be enclosed in curly braces even if it is a single line statement. These braces must be on separate lines. There must be a single space before the opening parenthesis of the expression after if/while/switch keywords.

  1. +++ Good +++
  1. if (value > 6)
  2. {
  3.   function_call ();
  4. }
  6. if (value > 1)
  7. {
  8.   function_call_a ();
  9. }
  10. else
  11. {
  12.   function_call_b ();
  13. }
  15. do
  16. {
  17.   function_call ();
  18.   value++;
  19. }
  20. while (value < 6);
  22. switch (value)
  23. {
  24.   case A:
  25.   {
  26.     /* FALLTHRU comment is allowed if a
  27.      * switch-case is not terminated by
  28.      * break/continue/return. */
  30.     /* FALLTHRU */
  31.   }
  32.   case B:
  33.   case C:
  34.   {
  35.     break;
  36.   }
  37.   case D:
  38.   {
  39.     /* We can use continue if we are in a loop. */
  40.     continue;
  41.   }
  42.   default:
  43.   {
  44.     return;
  45.   }
  46. }
  1. --- Bad ---
  1. if (value > 6)
  2.   function_call_a ();
  3. else
  4.   function_call_b ();
  6. if (value > 6) {
  7.   function_call_a ();
  8. }
  10. if (value > 6) function_call_a ();
  11. else { function_call_b (); }
  13. if
  14. (value > 6)
  15. {
  16. }
  18. switch (value) {
  19.   case 0: break;
  20.   default: {
  21.     return 5;
  22.   }
  23. }
  25. switch (value)
  26. {
  27.   case A:
  28.   {
  29.     if (value > 6)
  30.     {
  31.       CASE B:
  32.       {
  33.         /* This is allowed in C but
  34.          * not in JerryScript. */
  35.         break;
  36.       }
  37.     }
  38.   }
  39. }
  41. do
  42.   value++;
  43. while (value < 5);
  45. do {
  46.   value++;
  47. } while (value < 5);
  49. do
  50. {
  51.   value++;
  52. } while (value < 5);

Newlines

A newline in JerryScript is a separator which separates different parts of the source code. Its primary purpose is to improve readability. Unlike other rules developers have some freedom to add newlines to their code. However there are some rules.

  • Only a single newline separator is allowed.
  • Source files must be terminated by a newline.
  • Global declarations must be separated by a newline.
  • Newlines are not allowed after an opening curly brace or before a closing curly brace
  • No newlines are allowed between control statements (if-else, while, for, switch, etc.) and their code blocks.
  • There should be a newline after the variable declarations if they are the first statements of a block.
  1. +++ Good +++
  1. if (a > 5)
  2. {
  3.   /* Newline must be present after the first
  4.    * variable declarations of a code block. */
  5.   int j = a - 1;
  6.   int k = a * 2;
  8.   return j + k;
  9. }
  11. while (a < 5)
  12. {
  13.   a++;
  15.   /* It is recommended to put a newline after
  16.    * intermediate variable declarations. */
  17.   int i = a * 2;
  19.   b = i - 3;
  20. }
  22. /* It is a recommended to put newlines around asserts. */
  23. a = b + 5;
  25. JERRY_ASSERT (a < 20);
  27. c = a + 7;
  29. /* It is a good practice to put a newline after a multiline
  30.  * function call (see Function calls later). */
  31. f (a,
  32.    b,
  33.    c);
  35. a = 6;
  1. --- Bad ---
  1. /* No newlines are allowed after an opening curly
  2.  * brace or before a closing curly brace */
  4. while (a > 0)
  5. {
  7.   a = 6;
  9. }
  11. if (a > 5)
  12. {
  13.   while (b < 6)
  14.   {
  16.     b++;
  17.   }
  19. }
  22. /* Two or more newlines are not allowed. */
  23. a = 6;
  26. b = 7;
  28. /* No newlines are allowed between control staments
  29.  * and their code blocks. */
  31. if (a > 6)
  33. {
  34. }
  36. else
  38. {
  39. }
  41. do
  43. {
  44. }
  46. while (a < 6);

Expressions

Spaces are required around binary operators. No space is needed otherwise.

  1. +++ Good +++
  1. a = b + c;
  2. a = (b + c) << 3;
  3. a = b = c + ~d;
  4. a += ++c + d++;
  5. call_function (a * (b + !!c) - d + (e % f));
  6. if (a)
  7. {
  8. }
  1. --- Bad ---
  1. a=b+c;
  2. a = b+c;
  3. a  +=  c  +  ( d );
  4. /* Introduce temporary variables or macros
  5.  * if the expression is too long. Occures rarely.. */
  6. a = b
  7.   + c;
  8. if ( a + b > 0 )
  9. {
  10. }

Logical operators

All expressions with && and || logical operators must be enclosed in parentheses. A single and multiline form is allowed for these expressions. In the latter case each line must start with the logical operator and each line must be aligned to the column right after the opening parenthesis.

  1. +++ Good +++
  1. /* Single line form. */
  2. a = ((c && d) || (e && f));
  4. a = (c
  5.      && d);
  7. a = (c
  8.      && (d || e)
  9.      && f);
  11. do
  12. {
  13. }
  14. while (a
  15.        && b);
  17. /* This form is rarely used but it is ok. */
  18. if (a
  19.     && (b
  20.         || c
  21.         || d)
  22.     && e)
  23. {
  24. }
  1. --- Bad ---
  1. if (a || b ||
  2.     c)
  3. {
  4. }
  6. /* Parentheses are missing. */
  7. a = b || c;
  9. /* Misaligned &&. */
  10. if (a
  11.   && b)
  12. {
  13. }

Ternary conditional operators

A special form of ternary conditional operators are allowed in JerryScript where the ? and : operators are on separate lines in the same column.

  1. +++ Good +++
  1. a = (b ? c
  2.        : d);
  4. /* Single line form is accepted as well. */
  5. a = (b ? c : d);
  7. /* This form is rarely used but it is ok. */
  8. if (a ? b
  9.       : (c ? d
  10.            : e))
  11. {
  12. }
  1. --- Bad ---
  1. a = b ?
  2.     c : d;
  4. while (a ? b
  5.        : c)
  6. {
  7. }
  9. if (a
  10.     ? b
  11.     : c)
  12. {
  13. }

Function calls

There must be a space after the function name. Each argument must be in the same or separated lines. In the former case there must be a space before the next argument and in the latter case all arguments must be aligned to the same column.

  1. +++ Good +++
  1. function_a ();
  2. function_b (a);
  3. function_c (a, b, c);
  5. function_c (a,
  6.             b,
  7.             c);
  9. function_c (a,
  10.             b,
  11.             function_c (a,
  12.                         b,
  13.                         c);
  1. --- Bad ---
  1. /* No space before the opening parenthesis. */
  2. function_f();
  4. function_f (
  5. );
  7. function_g(a);
  9. function_g
  10.   (a
  11.   );
  13. /* Two arguments on the same line. */
  14. function_h (a, b,
  15.             c);
  17. function_h (a,
  18.             b, c);
  20. /* Misaligned arguments. */
  21. function_h (a,
  22.      b,
  23.      c);

Variable declarations

JerryScript is a pure C99 codebase so variable declarations can be anywhere in the code including inside for-loops. It is recommended to declare a variable before the first use.

  1. +++ Good +++
  1. for (int i = 0; i < 10; i++)
  2. {
  3.   int j = i + 1;
  4.   while (j < 10)
  5.   {
  6.     ++j;
  7.   }
  8. }
  10. /* Multiline form of for loops. */
  11. for (int i = 0;
  12.      i < 10;
  13.      i++)
  14. {
  15. }

Type casting

There must be a space after the closing parenthesis of the type cast. Type casting has no multiline form in JerryScript.

  1. +++ Good +++
  1. int a = (int) double_variable;
  3. int a = (int) (long) (float) double_variable;
  1. --- Bad ---
  1. /* Wrong spaces. */
  2. int a = ( int )double_variable;
  4. /* No multiline form. */
  5. int a = (int)
  6.         double_variable;

Pointers and asterisk character

Each pointer in JerryScript must be a lowercase string which is ending with a _p suffix. Furthermore there must be a space before the asterisk character.

  1. +++ Good +++
  1.   int *int_p;
  3.   /* No need to add multiple _p-s for multiple indirections.
  4.    * It is recommended to avoid these constructs using typedef
  5.    * declarations. A reviewer might request such a change. */
  6.   int ***int_p;
  8.   /* This rule applies for type casting as well. */
  9.   char = *(char *) type_p;
  1. --- Bad ---
  1.   /* No _p after the name. */
  2.   int *ptr;
  4.   /* Wrong asterisk position. */
  5.   int* ptr_p;
  7.   char_p = * (char*)type_p;

Types

Each type in JerryScript must be a lowercase string which ends with a _t suffix. Furthermore each type declaration must be preceded by a short description of the type and each field must have a short description as well.

  1. +++ Good +++
  1. /**
  2.  * Short description of the following structure.
  3.  */
  4. typedef struct
  5. {
  6.   /* Field descriptions do not start with capital letters
  7.    * and there is no full stop at the end. */
  8.   field1_t field1; /**< description of field 1 */
  9.   field2_t field2; /**< description of field 2 */
  11.   field_n_t field_n; /**< description of field n */
  12. } structure_name_t;
  14. /**
  15.  * Another integer type.
  16.  */
  17. typedef int jerry_int;
  1. --- Bad ---
  1. typedef struct
  2. {
  3.   field_t field_without_description;
  4. } structure_without_description_t;
  6. typedef struct { int a; } single_line_struct;
  8. typedef
  9. union {
  10. }
  11. wrong_newlines_t;
  13. /*
  14.   * Bad comment format.
  15.    */
  16. typedef
  17. char wrong_newlines_again_t;

Function declarations

Function declarations in JerryScript are verbose but this format reduces the maintenance cost and allows faster understanding of the code.

  1. +++ Good +++
  1. /**
  2.  * Short overview about the purpose of this function.
  3.  *
  4.  * A more detailed explanation if needed.
  5.  *
  6.  * Note:
  7.  *   Extra notes if needed.
  8.  *
  9.  * @return short description about the value
  10.  *         returned by the function
  11.  */
  12. return_value_type_t
  13. function_name (argument1, /**< description of argument1 */
  14.                argument2, /**< description of argument2 */
  15.                ...
  16.                argument_n, /**< description of argument n */
  17. {
  19.   /* Function body. */
  21. } /* function_name */
  1. --- Bad ---
  1. static int
  2. print (char *text) /**< description of text argument */
  3. {
  4.   /* Missing comment before the function. */
  5. } /* print */
  7. /**
  8.  * Prints the text received by the function.
  9.  *
  10.  * @return number of characters printed by the function
  11.  */
  12. int print(char *text)
  13. {
  14.   /* No description of text argument. */
  15.   /* Missing comment at the end of the function. */
  16. }