c++ - leer - salto de linea en raptor

Saltos de línea en formato Clang

Question

Estoy buscando una configuración de clang-format para evitar que la herramienta elimine los saltos de línea.

Por ejemplo, tengo mi ColumnLimit establecido en 120, y esto es lo que sucede cuando vuelvo a formatear un código de muestra.

Antes de:

#include <vector>
#include <string>

std::vector<std::string> get_vec()
{
   return std::vector<std::string> {
      "this is a test",
      "some of the lines are longer",
      "than other, but I would like",
      "to keep them on separate lines"
   };
}

int main()
{
   auto vec = get_vec();
}

Después:

#include <vector>
#include <string>

std::vector<std::string> get_vec()
{
   return std::vector<std::string>{"this is a test", "some of the lines are longer", "than other, but I would like",
         "to keep them on separate lines"};
}

int main()
{
   auto vec = get_vec();
}

Lo que me gustaría es que la herramienta corte líneas que tienen más de 120 caracteres, pero no decide combinar líneas solo porque tienen menos de 120 caracteres.

¿Hay tal opción? Nada en los documentos me llamó la atención.

Answer 1

Entonces, habiendo metido la pata en el código de formato de clang y hecho algunos parches, aquí está mi granito de arena:

• El formato Clang se basa en,

  • analizar el AST usando libclang , que básicamente elimina todos los espacios en blanco
  • dividiendo la secuencia del token en "líneas desenvueltas" que son como líneas de código "lógico"
  • Aplicar reglas / información de configuración para dividir a veces las "líneas no envueltas" en unidades más pequeñas
  • Escupir todo nuevamente con nuevos espacios en blanco / indentación

  No es fácil hacer que respete el whitepsace original, ese tipo de objeto se lanza al analizar el código por primera vez.

• Puede controlar dónde ubica los saltos de línea, más fácilmente,

  • estableciendo el límite de la columna
  • usando las opciones de "paquete de contenedor"
  • establecer sanciones para varios tipos de rupturas - romper después del tipo de retorno de una función, romper antes del parámetro de la primera llamada, romper una cadena literal, romper un comentario ...
  • colocar comentarios al final de una línea (el formato clang no puede eliminar el comentario y, por lo tanto, debe dividir la línea)
  • utilice las directivas off / on del formato clang

Aquí hay una cosa que podrías intentar:

std::vector<std::string> get_vec()
{
   return std::vector<std::string> {   //
      "this is a test",                //
      "some of the lines are longer",  //
      "than other, but I would like",  //
      "to keep them on separate lines" //
   };
}

La ventaja de esto sobre // clang-format off es que, si más tarde se cambia el ancho de la pestaña o alguna otra opción, esas líneas de código seguirán obteniendo esos cambios de formato, por lo que no es necesario ingresar manualmente al // clang-format off regiones para arreglarlo. Sin embargo, todavía es un truco, YMMV.

En definitiva, clang-format se trata de imponer un formato uniforme sobre una base de código completa, asegurándose de que todos los literales de cadena tengan el mismo estilo en todas partes de su programa. Si desea tener un control de nivel micro sobre las decisiones de salto de línea, eso no está realmente en el espíritu de la herramienta, y tendrá que hacer cosas como desactivarlo.

Esto a veces puede ser frustrante esp. cuando quieres hacer cosas con matrices y alinear columnas o algo así, por ejemplo, aquí hay un código natural de lua C api:

static luaL_Reg const methods[] = {
    {"matches",               &dispatch::intf_match_unit},
    {"to_recall",             &dispatch::intf_put_recall_unit},
    {"to_map",                &dispatch::intf_put_unit},
    {"erase",                 &dispatch::intf_erase_unit},
    {"clone",                 intf_copy_unit},
    {"extract",               &dispatch::intf_extract_unit},
    {"advance",               intf_advance_unit},
};

Cuando el formato clang se ejecuta sobre eso, generalmente no va a alinear la columna de la derecha, va a colocar un número fijo de espacios después de las comas y no hay mucho que puedas hacer al respecto.

O bien, si tiene una matriz de 4 x 4 para usar con OpenGL:

      constexpr float shadow_skew_hardcoded[16] =
        { 1.0f, 0.0f, 0.0f, 0.0f,
          0.5f, 0.5f, 0.0f, 0.0f,
          0.0f, 0.0f, 1.0f, 0.0f,
          0.0f, 0.0f, 0.0f, 1.0f };

Si dejas que el formato clang se ejecute sobre cosas como esta, simplemente las destruirá, y afaik no hay una manera fácil de hacerlo formatearlas, así que solo tienes que recurrir al truco de "comentarios triviales" o usar Desactiva el formato de clang cuando tienes algo como esto. Estas son solo limitaciones intrínsecas de la herramienta. Si no estás feliz de tener que hacer cosas como esa, probablemente no sea la herramienta para ti.

Answer 2

No estoy seguro de que hagas un "clang-format" para hacer exactamente lo que quieres, pero es posible decirle a clang-format que deje solo secciones del código. Utilizo esto exactamente para el tipo de escenario del que estás hablando, bloques de código donde un formato muy particular hace que sea más fácil de leer.

std::vector<std::string> get_vec()
{
   // clang-format off
   return std::vector<std::string> {
      "this is a test",
      "some of the lines are longer",
      "than other, but I would like",
      "to keep them on separate lines"
   };
   // clang-format on
}

Consulte: http://clang.llvm.org/docs/ClangFormatStyleOptions.html#disabling-formatting-on-a-piece-of-code

Answer 3

No vi nada actualmente en la documentation que te permita hacer eso.

Establecer ColumnLimit en 0 aún conservará el ajuste de texto.

clang-format-mp-3.4 test.c -style="{ ColumnLimit: 0 }"

#include <vector>
#include <memory>
#include <string>

int main() {
  std::vector<std::string> vec = {
    "this is a test",
    "with some strings",
    "that I want on separate lines"
  };
}