La macro __FILE__ muestra la ruta completa

La macro predefinida estándar __FILE__disponible en C muestra la ruta completa al archivo. ¿Hay alguna forma de acortar el camino? Quiero decir en lugar de

/full/path/to/file.c

Veo

to/file.c

o

file.c

Tratar

#include <string.h>

#define __FILENAME__ (strrchr(__FILE__, '/') ? strrchr(__FILE__, '/') + 1 : __FILE__)

Para Windows use '\\' en lugar de '/'.

Aquí hay un consejo si estás usando cmake. De: http://public.kitware.com/pipermail/cmake/2013-January/053117.html

Estoy copiando la sugerencia, así que todo está en esta página:

set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D__FILENAME__='\"$(subst
  ${CMAKE_SOURCE_DIR}/,,$(abspath $<))\"'")

Si está utilizando GNU make, no veo ninguna razón por la que no pueda extender esto a sus propios makefiles. Por ejemplo, puede tener una línea como esta:

CXX_FLAGS+=-D__FILENAME__='\"$(subst $(SOURCE_PREFIX)/,,$(abspath $<))\"'"

¿Dónde $(SOURCE_PREFIX)está el prefijo que desea eliminar?

Luego use __FILENAME__en lugar de __FILE__.

Acabo de pensar en una gran solución para esto que funciona con archivos de origen y de encabezado, es muy eficiente y funciona en tiempo de compilación en todas las plataformas sin extensiones específicas del compilador. Esta solución también conserva la estructura de directorios relativa de su proyecto, para que sepa en qué carpeta se encuentra el archivo, y solo en relación con la raíz de su proyecto.

La idea es obtener el tamaño del directorio de origen con su herramienta de compilación y simplemente agregarlo a la __FILE__macro, eliminando el directorio por completo y solo mostrando el nombre del archivo que comienza en su directorio de origen.

El siguiente ejemplo se implementa usando CMake, pero no hay razón para que no funcione con otras herramientas de compilación, porque el truco es muy simple.

En el archivo CMakeLists.txt, defina una macro que tenga la longitud de la ruta a su proyecto en CMake:

# The additional / is important to remove the last character from the path.
# Note that it does not matter if the OS uses / or \, because we are only
# saving the path size.
string(LENGTH "${CMAKE_SOURCE_DIR}/" SOURCE_PATH_SIZE)
add_definitions("-DSOURCE_PATH_SIZE=${SOURCE_PATH_SIZE}")

En su código fuente, defina una __FILENAME__macro que simplemente agregue el tamaño de la ruta de origen a la __FILE__macro:

#define __FILENAME__ (__FILE__ + SOURCE_PATH_SIZE)

Luego use esta nueva macro en lugar de la __FILE__macro. Esto funciona porque la __FILE__ruta siempre comenzará con la ruta al directorio de origen de CMake. Al eliminarlo de la __FILE__cadena, el preprocesador se encargará de especificar el nombre de archivo correcto y todo será relativo a la raíz de su proyecto CMake.

Si se preocupan por el rendimiento, esto es tan eficiente como el uso __FILE__, porque ambos __FILE__y SOURCE_PATH_SIZEse conocen las constantes de tiempo de compilación, por lo que puede ser optimizado de distancia por el compilador.

El único lugar donde esto podría fallar es si está usando esto en archivos generados y están en una carpeta de compilación fuera del código fuente. Entonces probablemente tendrá que crear otra macro usando la CMAKE_BUILD_DIRvariable en lugar de CMAKE_SOURCE_DIR.

Solución de tiempo puramente de compilación aquí. Se basa en el hecho de que sizeof()un literal de cadena devuelve su longitud + 1.

#define STRIPPATH(s)\
    (sizeof(s) > 2 && (s)[sizeof(s)-2] == '/' ? (s) + sizeof(s) - 1 : \
    sizeof(s) > 3 && (s)[sizeof(s)-3] == '/' ? (s) + sizeof(s) - 2 : \
    sizeof(s) > 4 && (s)[sizeof(s)-4] == '/' ? (s) + sizeof(s) - 3 : \
    sizeof(s) > 5 && (s)[sizeof(s)-5] == '/' ? (s) + sizeof(s) - 4 : \
    sizeof(s) > 6 && (s)[sizeof(s)-6] == '/' ? (s) + sizeof(s) - 5 : \
    sizeof(s) > 7 && (s)[sizeof(s)-7] == '/' ? (s) + sizeof(s) - 6 : \
    sizeof(s) > 8 && (s)[sizeof(s)-8] == '/' ? (s) + sizeof(s) - 7 : \
    sizeof(s) > 9 && (s)[sizeof(s)-9] == '/' ? (s) + sizeof(s) - 8 : \
    sizeof(s) > 10 && (s)[sizeof(s)-10] == '/' ? (s) + sizeof(s) - 9 : \
    sizeof(s) > 11 && (s)[sizeof(s)-11] == '/' ? (s) + sizeof(s) - 10 : (s))

#define __JUSTFILE__ STRIPPATH(__FILE__)

Siéntase libre de extender la cascada de operador condicional al nombre de archivo sensible máximo en el proyecto. La longitud de la ruta no importa, siempre que verifique lo suficientemente lejos del final de la cadena.

Veré si puedo obtener una macro similar sin longitud codificada con recursión de macro ...

Al menos para gcc, el valor de __FILE__es la ruta del archivo como se especifica en la línea de comando del compilador . Si compila file.casí:

gcc -c /full/path/to/file.c

el __FILE__se expandirá a "/full/path/to/file.c". Si en cambio haces esto:

cd /full/path/to
gcc -c file.c

luego __FILE__se expandirá a solo "file.c".

Esto puede o no ser práctico.

El estándar C no requiere este comportamiento. Todo lo que dice __FILE__es que se expande a "El supuesto nombre del archivo fuente actual (una cadena de caracteres literal)".

Una alternativa es usar la #linedirectiva. Anula el número de línea actual y, opcionalmente, el nombre del archivo de origen. Si desea anular el nombre del archivo pero dejar solo el número de línea, use la __LINE__macro.

Por ejemplo, puede agregar esto cerca de la parte superior de file.c:

#line __LINE__ "file.c"

El único problema con esto es que asigna el número de línea especificado a la siguiente línea, y el primer argumento #linetiene que ser una secuencia de dígitos para que no pueda hacer algo como

#line (__LINE__-1) "file.c"  // This is invalid

Asegurar que el nombre del archivo en la #linedirectiva coincida con el nombre real del archivo se deja como ejercicio.

Al menos para gcc, esto también afectará el nombre del archivo informado en los mensajes de diagnóstico.

Un poco tarde para la fiesta, pero para GCC eche un vistazo a la -ffile-prefix-map=old=newopción:

Al compilar archivos que residen en el directorio anterior , registre cualquier referencia a ellos en el resultado de la compilación como si los archivos residieran en el directorio nuevo . Especificar esta opción es equivalente a especificar todas las -f*-prefix-mapopciones individuales . Esto se puede usar para hacer compilaciones reproducibles que son independientes de la ubicación. Ver también -fmacro-prefix-mapy -fdebug-prefix-map.

Entonces, para mis compilaciones de Jenkins, agregaré -ffile-prefix-map=${WORKSPACE}/=/y otra para eliminar el prefijo de instalación del paquete de desarrollo local.

NOTA Desafortunadamente, la -ffile-prefix-mapopción solo está disponible en GCC 8 en adelante, ya -fmacro-prefix-mapque creo que hace la __FILE__parte. Para, digamos, GCC 5, solo tenemos -fdebug-prefix-maplo que no (parece) afectar __FILE__.

• C ++ 11

• msvc2015u3, gcc5.4, clang3.8.0

  template <typename T, size_t S>
  inline constexpr size_t get_file_name_offset(const T (& str)[S], size_t i = S - 1)
  {
      return (str[i] == '/' || str[i] == '\\') ? i + 1 : (i > 0 ? get_file_name_offset(str, i - 1) : 0);
  }
  
  template <typename T>
  inline constexpr size_t get_file_name_offset(T (& str)[1])
  {
      return 0;
  }

  '

  int main()
  {
       printf("%s\n", &__FILE__[get_file_name_offset(__FILE__)]);
  }

El código genera una compensación de tiempo de compilación cuando:

• gcc: al menos gcc6.1 + -O1

• msvc: poner el resultado en la variable constexpr:

    constexpr auto file = &__FILE__[get_file_name_offset(__FILE__)];
    printf("%s\n", file);

• clang: persiste en la evaluación del tiempo de no compilación

Hay un truco para forzar que los 3 compiladores compilen la evaluación del tiempo incluso en la configuración de depuración con optimización deshabilitada:

    namespace utility {

        template <typename T, T v>
        struct const_expr_value
        {
            static constexpr const T value = v;
        };

    }

    #define UTILITY_CONST_EXPR_VALUE(exp) ::utility::const_expr_value<decltype(exp), exp>::value

    int main()
    {
         printf("%s\n", &__FILE__[UTILITY_CONST_EXPR_VALUE(get_file_name_offset(__FILE__))]);
    }

https://godbolt.org/z/u6s8j3

En VC, cuando se usa /FC, se __FILE__expande a la ruta completa, sin la /FCopción __FILE__expande el nombre del archivo. ref: aquí

No hay forma de compilar el tiempo para hacer esto. Obviamente, puede hacerlo en tiempo de ejecución utilizando el tiempo de ejecución C, como han demostrado algunas de las otras respuestas, pero en el momento de la compilación, cuando el preprocesador entra en funcionamiento, no tiene suerte.

Use la función basename () o, si está en Windows, _splitpath () .

#include <libgen.h>

#define PRINTFILE() { char buf[] = __FILE__; printf("Filename:  %s\n", basename(buf)); }

Prueba también man 3 basenameen una concha.

Si está utilizando el CMAKEcompilador GNU, esta globaldefinición funciona bien:

set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D__MY_FILE__='\"$(notdir $(abspath $<))\"'")

He usado la misma solución con la respuesta de @Patrick durante años.

Tiene un pequeño problema cuando la ruta completa contiene enlace de símbolo.

Mejor solucion.

set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-builtin-macro-redefined -D'__FILE__=\"$(subst $(realpath ${CMAKE_SOURCE_DIR})/,,$(abspath $<))\"'")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-builtin-macro-redefined -D'__FILE__=\"$(subst $(realpath ${CMAKE_SOURCE_DIR})/,,$(abspath $<))\"'")

¿Por qué debería usar esto?

• -Wno-builtin-macro-redefinedpara silenciar las advertencias del compilador para redefinir la __FILE__macro.

  Para aquellos compiladores que no admiten esto, consulte el modo Robusto a continuación.

• Eliminar la ruta del proyecto de la ruta del archivo es su requisito real . No querrá perder el tiempo para averiguar dónde hay un header.harchivo, src/foo/header.ho src/bar/header.h.

• Deberíamos quitar la __FILE__macro en el cmakearchivo de configuración.

  Esta macro se usa en la mayoría de los códigos existentes. Simplemente redefinirlo puede liberarlo.

  Los compiladores como gccpredefinen esta macro a partir de los argumentos de la línea de comandos. Y la ruta completa se escribe en makefiles generada por cmake.

• CMAKE_*_FLAGSSe requiere código duro .

  Hay algunos comandos para agregar opciones o definiciones del compilador en alguna versión más reciente, como add_definitions()y add_compile_definitions(). Estos comandos analizarán las funciones substde creación como antes se aplican a los archivos de origen. Eso no es lo que queremos.

Manera robusta para -Wno-builtin-macro-redefined.

include(CheckCCompilerFlag)
check_c_compiler_flag(-Wno-builtin-macro-redefined SUPPORT_C_WNO_BUILTIN_MACRO_REDEFINED)
if (SUPPORT_C_WNO_BUILTIN_MACRO_REDEFINED)
    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-builtin-macro-redefined")
endif (SUPPORT_C_WNO_BUILTIN_MACRO_REDEFINED)
include(CheckCXXCompilerFlag)
check_cxx_compiler_flag(-Wno-builtin-macro-redefined SUPPORT_CXX_WNO_BUILTIN_MACRO_REDEFINED)
if (SUPPORT_CXX_WNO_BUILTIN_MACRO_REDEFINED)
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-builtin-macro-redefined")
endif (SUPPORT_CXX_WNO_BUILTIN_MACRO_REDEFINED)

Recuerde eliminar esta opción del compilador de la set(*_FLAGS ... -D__FILE__=...)línea.

Una ligera variación de lo que propuso @ red1ynx sería crear la siguiente macro:

#define SET_THIS_FILE_NAME() \
    static const char* const THIS_FILE_NAME = \
        strrchr(__FILE__, '/') ? strrchr(__FILE__, '/') + 1 : __FILE__;

En cada uno de sus archivos .c (pp) agregue:

SET_THIS_FILE_NAME();

Entonces puede referirse en THIS_FILE_NAMElugar de __FILE__:

printf("%s\n", THIS_FILE_NAME);

Esto significa que la construcción se realiza una vez por archivo .c (pp) en lugar de cada vez que se hace referencia a la macro.

Se limita a su uso solo desde archivos .c (pp) y sería inutilizable desde archivos de encabezado.

Hice una macro __FILENAME__que evita cortar el camino completo cada vez. El problema es mantener el nombre del archivo resultante en una variable local cpp.

Se puede hacer fácilmente definiendo una variable global estática en el archivo .h . Esta definición proporciona variables separadas e independientes en cada archivo .cpp que incluye el .h . Para ser a prueba de subprocesos múltiples, vale la pena hacer que las variables también se enhebren localmente (TLS).

Una variable almacena el nombre del archivo (reducido). Otro tiene el valor no cortado que __FILE__dio. El archivo h:

static __declspec( thread ) const char* fileAndThreadLocal_strFilePath = NULL;
static __declspec( thread ) const char* fileAndThreadLocal_strFileName = NULL;

La macro misma llama al método con toda la lógica:

#define __FILENAME__ \
    GetSourceFileName(__FILE__, fileAndThreadLocal_strFilePath, fileAndThreadLocal_strFileName)

Y la función se implementa de esta manera:

const char* GetSourceFileName(const char* strFilePath, 
                              const char*& rstrFilePathHolder, 
                              const char*& rstrFileNameHolder)
{
    if(strFilePath != rstrFilePathHolder)
    {
        // 
        // This if works in 2 cases: 
        // - when first time called in the cpp (ordinary case) or
        // - when the macro __FILENAME__ is used in both h and cpp files 
        //   and so the method is consequentially called 
        //     once with strFilePath == "UserPath/HeaderFileThatUsesMyMACRO.h" and 
        //     once with strFilePath == "UserPath/CPPFileThatUsesMyMACRO.cpp"
        //
        rstrFileNameHolder = removePath(strFilePath);
        rstrFilePathHolder = strFilePath;
    }
    return rstrFileNameHolder;
}

RemovePath () se puede implementar de diferentes maneras, pero lo rápido y simple parece ser con strrchr:

const char* removePath(const char* path)
{
    const char* pDelimeter = strrchr (path, '\\');
    if (pDelimeter)
        path = pDelimeter+1;

    pDelimeter = strrchr (path, '/');
    if (pDelimeter)
        path = pDelimeter+1;

    return path;
}

El compilador reciente de Clang tiene una __FILE_NAME__macro (ver aquí ).

solo espero mejorar un poco la macro ARCHIVO:

#define FILE (strrchr(__FILE__, '/') ? strrchr(__FILE__, '/') + 1 : strrchr(__FILE__, '\\') ? strrchr(__FILE__, '\\') + 1 : __FILE__)

esto atrapa / y \, como Czarek Tomczak solicitó, y esto funciona muy bien en mi entorno mixto.

Tratar

#pragma push_macro("__FILE__")
#define __FILE__ "foobar.c"

después de las declaraciones de inclusión en su archivo fuente y agregue

#pragma pop_macro("__FILE__")

al final de su archivo fuente.

Aquí hay una función portátil que funciona tanto para Linux (ruta '/') como para Windows (combinación de '\' y '/').
Compila con gcc, clang y vs.

#include <string.h>
#include <stdio.h>

const char* GetFileName(const char *path)
{
    const char *name = NULL, *tmp = NULL;
    if (path && *path) {
        name = strrchr(path, '/');
        tmp = strrchr(path, '\\');
        if (tmp) {
             return name && name > tmp ? name + 1 : tmp + 1;
        }
    }
    return name ? name + 1 : path;
}

int main() {
    const char *name = NULL, *path = NULL;

    path = __FILE__;
    name = GetFileName(path);
    printf("path: %s, filename: %s\n", path, name);

    path ="/tmp/device.log";
    name = GetFileName(path);
    printf("path: %s, filename: %s\n", path, name);

    path = "C:\\Downloads\\crisis.avi";
    name = GetFileName(path);
    printf("path: %s, filename: %s\n", path, name);

    path = "C:\\Downloads/nda.pdf";
    name = GetFileName(path);
    printf("path: %s, filename: %s\n", path, name);

    path = "C:/Downloads\\word.doc";
    name = GetFileName(path);
    printf("path: %s, filename: %s\n", path, name);

    path = NULL;
    name = GetFileName(NULL);
    printf("path: %s, filename: %s\n", path, name);

    path = "";
    name = GetFileName("");
    printf("path: %s, filename: %s\n", path, name);

    return 0;
}

Salida estándar:

path: test.c, filename: test.c
path: /tmp/device.log, filename: device.log
path: C:\Downloads\crisis.avi, filename: crisis.avi
path: C:\Downloads/nda.pdf, filename: nda.pdf
path: C:/Downloads\word.doc, filename: word.doc
path: (null), filename: (null)
path: , filename: 

Aquí está la solución que utiliza el cálculo en tiempo de compilación:

constexpr auto* getFileName(const char* const path)
{
    const auto* startPosition = path;
    for (const auto* currentCharacter = path;*currentCharacter != '\0'; ++currentCharacter)
    {
        if (*currentCharacter == '\\' || *currentCharacter == '/')
        {
            startPosition = currentCharacter;
        }
    }

    if (startPosition != path)
    {
        ++startPosition;
    }

    return startPosition;
}

std::cout << getFileName(__FILE__);

Si terminó en esta página buscando una manera de eliminar la ruta de origen absoluta que apunta a una ubicación de compilación fea del binario que está enviando, a continuación podría satisfacer sus necesidades.

Aunque esto no produce exactamente la respuesta que el autor ha expresado su deseo, ya que supone el uso de CMake , se acerca bastante. Es una pena que esto no haya sido mencionado anteriormente por nadie, ya que me habría ahorrado mucho tiempo.

OPTION(CMAKE_USE_RELATIVE_PATHS "If true, cmake will use relative paths" ON)

Establecer la variable anterior ONgenerará un comando de compilación en el formato:

cd /ugly/absolute/path/to/project/build/src && 
    gcc <.. other flags ..> -c ../../src/path/to/source.c

Como resultado, la __FILE__macro se resolverá a../../src/path/to/source.c

CMake documentación

Sin embargo, tenga cuidado con la advertencia en la página de documentación:

Use rutas relativas (¡Puede que no funcione!).

No se garantiza que funcione en todos los casos, pero funcionó en el mío - CMake 3.13 + gcc 4.5

Dado que está utilizando GCC, puede aprovechar las ventajas de

__BASE_FILE__Esta macro se expande al nombre del archivo de entrada principal, en forma de una constante de cadena C. Este es el archivo fuente que se especificó en la línea de comando del preprocesador o compilador de C

y luego controle cómo desea mostrar el nombre del archivo cambiando la representación del archivo fuente (ruta completa / ruta relativa / nombre base) en el momento de la compilación.

Aquí hay una solución que funciona para entornos que no tienen la biblioteca de cadenas (kernel de Linux, sistemas integrados, etc.):

#define FILENAME ({ \
    const char* filename_start = __FILE__; \
    const char* filename = filename_start; \
    while(*filename != '\0') \
        filename++; \
    while((filename != filename_start) && (*(filename - 1) != '/')) \
        filename--; \
    filename; })

Ahora solo use en FILENAMElugar de __FILENAME__. Sí, todavía es una cosa de tiempo de ejecución pero funciona.

#include <algorithm>
#include <string>
using namespace std;
string f( __FILE__ );
f = string( (find(f.rbegin(), f.rend(), '/')+1).base() + 1, f.end() );

// searches for the '/' from the back, transfers the reverse iterator 
// into a forward iterator and constructs a new sting with both

Una respuesta breve y funcional para Windows y * nix:

#define __FILENAME__ std::max<const char*>(__FILE__,\
    std::max(strrchr(__FILE__, '\\')+1, strrchr(__FILE__, '/')+1))