Справочник по Vim: Отступы в программах на языке C и других текстах

>N

Количество пробелов, добавляемых для "обычного отступа". Используется после строки, которая должна увеличить отступ (строки, которые начинаются с "if", открывающая фигурная скобка и т.д.). По умолчанию: величина, равная значению 'shiftwidth'.

cino=           cino=>2           cino=>2s
  if (cond)       if (cond)         if (cond)
  {               {                 {
      foo;          foo;                    foo;
  }               }                 }

eN

Добавить N к существующему отступу внутри фигурных скобок, если открывающая скобка находится в конце строки (а точнее, не является первым символом строки). Этим можно пользоваться для того, чтобы отступ, который используется после '{' в начале строки, отличался от отступа, который используется после '{' в конце строки. По умолчанию: 0.

cino=              cino=e2           cino=e-2
  if (cond) {        if (cond) {       if (cond) {
      foo;                 foo;          foo;
  }                  }                 }
  else               else              else
  {                  {                 {
      bar;               bar;              bar;
  }                  }                 }

 nN

Добавить N к существующему отступу для выражений после "if", "while" и т.д., если строка НЕ находится внутри фигурных скобок. Это полезно, когда требуется, чтобы строка, перед которой нет '{' имела отступ, отличный от строки, перед которой '{' есть. По умолчанию: 0.

cino=           cino=n2          cino=n-2
  if (cond)       if (cond)        if (cond)
      foo;              foo;         foo;
  else            else             else
  {               {                {
      bar;            bar;             bar;
  }               }                }

 fN

Поместить первую открывающую фигурную скобку функции или другого блока в колонку N. Это относится только к открывающей скобке, которая не находится внутри других скобок и которая находится в начале строки. То, что следует за открывающей фигурной скобкой, размещается относительно неё. По умолчанию: 0.

cino=           cino=f.5s          cino=f1s
  func()          func()             func()
  {                 {                    {
      int foo;          int foo;             int foo;

 {N

Размещать открывающие фигурные скобки на N символов от существующего отступа.
Это относится только к открывающим скобкам, которые находятся внутри других фигурных скобок. По умолчанию: 0.

cino=            cino={.5s         cino={1s
  if (cond)        if (cond)         if (cond)
  {                  {                   {
      foo;             foo;              foo;

 }N

Размещать закрывающие фигурные скобки на N символов от соответствующей открывающей скобки. По умолчанию: 0.

cino=             cino={2,}-0.5s      cino=}2
  if (cond)         if (cond)           if (cond)
  {                   {                 {
      foo;              foo;                foo;
  }                 }                     }

 ^N

Добавить N к существующему отступу внутри фигурных скобок, если открывающая фигурная скобка находится в колонке 0. Благодаря этой возможности можно задать специальный отступ для всего тела функции (некоторым нравится, чтобы это было отрицательное число). По умолчанию: 0.

cino=               cino=^-2          cino=^-s
  func()              func()            func()
  {                   {                 {
      if (cond)         if (cond)       if (cond)
      {                 {               {
          a = b;            a = b;          a = b;
      }                 }               }
  }                   }                 }

Помещать метки case на N символов от отступа switch(). По умолчанию: значение 'shiftwidth'.

cino=               cino=:0
  switch (x)          switch(x)
  {                   {
      case 1:         case 1:
          a = b;          a = b;
      default:        default:
  }                   }

N

Помещать выражения, встречающиеся после метки case, на N символов от отступа метки. По умолчанию: значение 'shiftwidth'.

cino=                cino==10
  case 11:             case 11:  a = a + 1;
      a = a + 1;                 b = b + 1;

lN

Если N != 0, то Vim будет выравнивать строку по метке case вместо выражения, следующего после неё в той же строке.

cino=                     cino=l1
  switch (a) {              switch (a) {
      case 1: {                 case 1: {
                  break;            break;
              }                 }

bN

Если N != 0, то Vim будет выравнивать последний "break" по метке case, так чтобы case..break выглядели одним блоком. (по умолчанию: 0).

cino=                 cino=b1
  switch (x)            switch(x)
  {                     {
      case 1:               case 1:
          a = b;                a = b;
          break;            break;

      default:              default:
          a = 0;                a = 0;
          break;            break;
  }                      }

gN

Помещать декларации области видимости C++ на N символов от отступа блока, в котором они находятся. По умолчанию: значение 'shiftwidth'.

Декларация области видимости это "public:", "protected:" или "private:".

cino=                cino=g0
  {                    {
      public:          public:
          a = b;           a = b;
      private:         private:
  }                    }

hN

Помещать выражения, встречающиеся после декларации области видимости C++ на N символов от отступа метки. По умолчанию: значение 'shiftwidth'.

cino=                cino=h10
  public:              public:   a = a + 1;
      a = a + 1;                 b = b + 1;

pN

Объявления параметров функций в стиле K&R будут смещены на N символов от поля. По умолчанию: 'shiftwidth'.

cino=              cino=p0           cino=p2s
  func(a, b)         func(a, b)        func(a, b)
      int a;         int a;                    int a;
      char b;        char b;                   char b;

 tN

Смещать объявление типа возвращаемого значения функции на N символов от поля. По умолчанию: 'shiftwidth'.

cino=            cino=t0          cino=t7
      int          int                     int
  func()           func()           func()

 iN

Смещать объявления базовых классов C++ и инициализацию конструкторов, если они начинаются на новой строке (в противном случае они выравниваются по правой стороне ':'). (по умолчанию: 'shiftwidth').

cino=                     cino=i0
  class MyClass :           class MyClass :
      public BaseClass      public BaseClass
  {}                        {}
  MyClass::MyClass() :      MyClass::MyClass() :
      BaseClass(3)          BaseClass(3)
  {}                        {}

+N

Смещать продолжающуюся строку (строку, которая переходит на следующую) на N дополнительных символов. По умолчанию: 'shiftwidth'.

cino=              cino=+10
  a = b + 9 *        a = b + 9 *
      c;                       c;

cN

Смещать строки комментария после начала комментария, если при этом отсутствует какой либо другой текст для выравнивания, на N символов от начала комментария (по умолчанию: 3). См. также |форматирование-комментарии|.

cino=                cino=c5
  /*                   /*
     текст.                 текст.
   */                   */

CN

Если N не равен 0, то смещать строки комментария на число символов, указанных с помощью флага c (см. выше), даже если после начала комментария имеется какой-либо другой текст. По умолчанию: 0.

cino=c0           cino=c0,C1
  /********         /********
    текст.          текст.
  ********/         ********/

(В этом примере используется ":set comments& comments-=s1:/* comments^=s0:/*")

/N

Дополнительно смещать строки комментария на N символов. По умолчанию: 0.

cino=                  cino=/4
  a = b;                 a = b;
  /* комментарий */          /* комментарий */
  c = d;                 c = d;

(N

В незакрытых круглых скобках добавить отступ в N символов от строки с незакрытыми круглыми скобками. Для каждой незакрытой круглой скобки добавляется 'shiftwidth' символов. Если N равно 0 или незакрытые скобки являются первым непробельным символом в строке, то выравнивать к следующему непробельному символу после незакрытой скобки. По умолчанию: значение опции 'shiftwidth' * 2.

cino=                   cino=(0
  if (c1 && (c2 ||        if (c1 && (c2 ||
               c3))                  c3))
      foo;                    foo;
  if (c1 &&               if (c1 &&
          (c2 || c3))         (c2 || c3))
     {                       {

uN

То же, что и (N, но на один уровень глубже. По умолчанию: значение опции 'shiftwidth'.

cino=                    cino=u2
  if (c123456789           if (c123456789
          && (c22345               && (c22345
              || c3))                || c3))

UN

При N не равном 0, не игнорировать отступы, указанные в ( или u, в тех случаях, когда незакрытые скобки являются первым непробельным символом в строке. По умолчанию: 0.

cino= or cino=(s      cino=(s,U1
  c = c1 &&             c = c1 &&
      (                     (
       c2 ||                    c2 ||
       c3                       c3
      ) && c4;              ) && c4;

wN

В незакрытых скобках, если N не равно 0 и при этом используется, соответственно, "(0" или "u0", либо если используется "U0" и незакрытая скобка является первым непробельным символом в строке, то выравнивать по символу, следующему сразу после незакрытой скобки, вместо выравнивания по первому непробельному символу. По умолчанию: 0.

cino=(0                    cino=(0,w1
  if (   c1                  if (   c1
         && (   c2               && (   c2
                || c3))              || c3))
      foo;                       foo;

WN

В незакрытых скобках, если N не равно 0 и при этом используется, соответственно, "(0" или "u0", если незакрытая скобка является последним непробельным символом на своей строке и она не является закрывающей скобкой, выполнять сдвиг следующей строки на N символов относительно внешнего контекста (т.е. начала строки или следующей незакрытой скобки). (По умолчанию: 0).

cino=(0                   cino=(0,W4
  a_long_line(              a_long_line(
              argument,         argument,
              argument);        argument);
  a_short_line(argument,    a_short_line(argument,
               argument);                argument);

mN

Если N не равен нулю, то выравнивать строку, начинающуюся с закрывающей скобки с первым символом строки с соответствующей открывающей скобкой. По умолчанию: 0.

cino=(s               cino=(s,m1
  c = c1 && (           c = c1 && (
      c2 ||                 c2 ||
      c3                    c3
      ) && c4;          ) && c4;
  if (                  if (
      c1 && c2              c1 && c2
     )                  )
      foo;                  foo;

jN

Выравнивать анонимные классы в коде на языке Java правильно. Значение 'N' в данный момент не используется, но должно быть не равным 0 (например, 'j1'). 'j1' позволяет, к примеру, правильно расставить отступы в нижеследующем фрагменте кода:

object.add(new ChangeListener() {
    public void stateChanged(ChangeEvent e) {
        do_something();
    }
});

)N