Получение базового имени исходного файла во время компиляции

Question

Я использую GCC;__FILE__ возвращает полный путь и имя текущего исходного файла: /path/to/file.cpp.Есть ли способ получить только имя файла? file.cpp (без пути) во время компиляции?Можно ли это сделать портативным способом?Можно ли применить метапрограммирование шаблонов к строкам?

Я использую это в макросе регистрации ошибок.Я действительно не хочу, чтобы полный путь к моему исходному файлу попадал в исполняемый файл.

Answer 1

Если вы используете программу make, у вас должна быть возможность заранее изменить имя файла и передать его как макрос в gcc для использования в вашей программе.

В вашем make-файле измените строку:

file.o: file.c
    gcc -c -o file.o src/file.c

к:

file.o: src/file.c
    gcc "-D__MYFILE__=\"`basename $<`\"" -c -o file.o src/file.c

Это позволит вам использовать __MYFILE__ в вашем коде вместо __FILE__.

Использование базового имени исходного файла ($<) означает, что вы можете использовать его в обобщенных правилах, таких как «.co».

Следующий код иллюстрирует, как это работает.

Файл make-файла:

mainprog: main.o makefile
    gcc -o mainprog main.o

main.o: src/main.c makefile
    gcc "-D__MYFILE__=\"`basename $<`\"" -c -o main.o src/main.c

Файл src/main.c:

#include <stdio.h>

int main (int argc, char *argv[]) {
    printf ("file = %s\n", __MYFILE__);
    return 0;
}

Запускаем из оболочки:

pax@pax-desktop:~$ mainprog
file = main.c
pax@pax-desktop:~$

Обратите внимание на строку «file =", которая содержит только базовое имя файла, а не имя каталога.

Answer 2

Рассмотрим этот простой исходный код:

#include <stdio.h>
int main(void)
{
    puts(__FILE__);
    return(0);
}

В Solaris с GCC 4.3.1, если я скомпилирую это с помощью:

gcc -o x x.c && ./x

вывод «x.c», если я скомпилирую его с помощью:

gcc -o x $PWD/x.c && ./x

затем __FILE__ отображается на полный путь ('/work1/jleffler/tmp/x.c'). Если я скомпилирую это с помощью:

gcc -o x ../tmp/x.c && ./x

затем __FILE__ отображается на '../tmp/x.c'.

Итак, в основном, __FILE__ - это путь к исходному файлу. Если вы строите с именем, которое хотите видеть в объекте, все хорошо.

Если это невозможно (по какой-либо причине), вам придется заняться исправлениями, предложенными другими людьми.

Answer 3

Я не знаю прямого пути. Вы можете использовать:

#line 1 "filename.c"

в верхней части исходного файла для установки значения __FILE__, но я не уверен, что это намного лучше, чем жесткое его кодирование. или просто используя #define для создания собственного макроса.

Другой вариант - передать имя из вашего Makefile, используя -D и $ (базовое имя оболочки $ <)

Изменить. Если вы используете параметр #define или -D, вам следует создать собственное новое имя, а не пытаться переопределять <=>.

Answer 4

Что делает ваш макрос регистрации ошибок? Я бы предположил, что в какой-то момент макрос в конечном итоге вызывает какую-то функцию для ведения журнала, почему бы не вызвать вызываемую функцию, удаляющую компонент пути во время выполнения?

#define LOG(message) _log(__FILE__, message)

void _log(file, message)
{
  #ifndef DEBUG
  strippath(file); // in some suitable way
  #endif

  cerr << "Log: " << file << ": " << message; // or whatever
}

Answer 5

Поскольку вы пометили CMake, вот отличное решение для добавления в ваш CMakeLists.txt: (скопировано с http://www.cmake.org/pipermail/cmake/ 2011-декабрь / 048281.html ). (Примечание: некоторые компиляторы не поддерживают для каждого файла COMPILE_DEFINITIONS! Но он работает с gcc)

set(SRCS a/a.cpp b/b.cpp c/c.cpp d/d.cpp)

foreach(f IN LISTS SRCS)
 get_filename_component(b ${f} NAME)
 set_source_files_properties(${f} PROPERTIES
  COMPILE_DEFINITIONS "MYSRCNAME=${b}")
endforeach()

add_executable(foo ${SRCS})

Примечание. Для моего приложения мне нужно было экранировать строку имени файла, например:

COMPILE_DEFINITIONS "MYSRCNAME=\"${b}\"")

Answer 6

Возможно, вы сможете сделать это с помощью метапрограммирования шаблонов, но нет встроенного способа сделать это.

РЕДАКТИРОВАТЬ: Хм, коррекция. Согласно одной странице, которую я только что видел , GCC использует путь, указанный для файла. Если ему дадут полное имя, он его вставит; если ему дано только относительное, оно будет только встроено. Я сам не пробовал.

Answer 7

Принимая идею от Glomek, она может быть автоматизирована следующим образом:

Исходный файл x.c

#line 1 MY_FILE_NAME
#include <stdio.h>

int main(void)
{
    puts(__FILE__);
    return(0);
}

Строка компиляции (остерегайтесь одинарных кавычек вне двойных кавычек):

gcc -DMY_FILE_NAME='"abcd.c"' -o x x.c

Вывод «abcd.c».

Answer 8

Вы можете присвоить __FILE__ строке, а затем вызвать _splitpath (), чтобы извлечь из нее фрагменты. Это может быть решение только для Windows / MSVC, честно говоря, я не знаю.

Я знаю, что вы искали решение во время компиляции, и это решение во время выполнения, но я подумал, что поскольку вы используете имя файла для ведения (предположительно во время выполнения) регистрации ошибок, это может быть простой прямой способ чтобы получить то, что вам нужно.

Answer 9

Вы можете взять __FILE__ и лишить части пути, который вам не нужен (программно). Если basedir удовлетворяет ваши потребности, тогда хорошо. В противном случае, получите исходный корень dir из вашей системы сборки, а остальное должно быть выполнимо.

Answer 10

Только что получил ту же проблему; нашел другое разрешение, просто подумал, что поделюсь им:

В заголовочном файле, включенном во все остальные мои файлы:

static char * file_bname = NULL;
#define __STRIPPED_FILE__   (file_bname ?: (file_bname = basename(__FILE__)))

Надеюсь, это будет полезно и кому-то еще:)

Answer 11

Может быть сделано ТОЛЬКО программно.

может быть, это полезно ...

filename = __FILE__
len  = strlen(filename)

char *temp = &filename[len -1]
while(*temp!= filename)
    if(*temp == '\') break;

Answer 12

С cmake это легко.

DefineRelativeFilePaths.cmake

function (cmake_define_relative_file_paths SOURCES)
  foreach (SOURCE IN LISTS SOURCES)
    file (
      RELATIVE_PATH RELATIVE_SOURCE_PATH
      ${PROJECT_SOURCE_DIR} ${SOURCE}
    )

    set_source_files_properties (
      ${SOURCE} PROPERTIES
      COMPILE_DEFINITIONS __RELATIVE_FILE_PATH__="${RELATIVE_SOURCE_PATH}"
    )
  endforeach ()
endfunction ()

Где-то в CMakeLists.txt

set (SOURCES ${SOURCES}
  "${CMAKE_CURRENT_SOURCE_DIR}/common.c"
  "${CMAKE_CURRENT_SOURCE_DIR}/main.c"
)

include (DefineRelativeFilePaths)
cmake_define_relative_file_paths ("${SOURCES}")

cmake .. && make clean && make VERBOSE=1

cc ... -D__RELATIVE_FILE_PATH__="src/main.c" ... -c src/main.c

Вот и все.Теперь вы можете создавать красивые сообщения журнала.

#define ..._LOG_HEADER(target) \
  fprintf(target, "%s %s:%u - ", __func__, __RELATIVE_FILE_PATH__, __LINE__);

func src/main.c:22 — моя ошибка

PS Лучше уточнить в config.h.in -> config.h

#ifndef __RELATIVE_FILE_PATH__
#define __RELATIVE_FILE_PATH__ __FILE__
#endif

Таким образом, ваш линтер не хочет выдавать дождь ошибок.

Answer 13

Вы можете использовать:

bool IsDebugBuild()
{
    return !NDEBUG;
}

Или вы можете использовать NDEBUG в вашем макросе для включения / выключения этих путей к файлам.