clangd & compile_commands.json
Cross-Compile IDE Desteği

00 Cross-compile projelerinde IDE anlayışı neden bozulur

Gömülü Linux geliştirmede yazılan kod host makinede değil, ARM veya RISC-V gibi hedef mimaride çalışır. Bu fark, IDE'nin standart sistem başlıklarını ve araçlarını kullanmasını engeller.

Sorunun anatomisi

Bir gömülü proje tipik olarak şu zincirle derlenir:

  Kaynak kod (.c/.h)
        │
        ▼
  aarch64-linux-gnu-gcc \
    -I /opt/sysroot/usr/include \
    -I /opt/cross-toolchain/aarch64-linux-gnu/include \
    -march=armv8-a -mfpu=neon
        │
        ▼
  ARM64 object dosyaları
    

Ancak IDE (VS Code IntelliSense, CLion vb.) bu komutu bilmez. Bunun yerine kendi varsayımlarını kullanır:

compile_commands.json çözümü

Her kaynak dosya için tam derleme komutunu JSON olarak kaydeden compilation database standardı (LLVM tarafından tanımlanan) bu sorunu kökten çözer. clangd bu veriyi okuyarak her dosyayı tam olarak nasıl derleneceğini öğrenir.

01 compile_commands.json nedir

compile_commands.json, LLVM tarafından standartlaştırılmış JSON Compilation Database formatıdır. Her kaynak dosya için bir kayıt içerir: hangi dizinde, hangi komutla derlendiğini belirtir.

Format tanımı

[
  {
    "directory": "/home/user/myproject/build",
    "command": "aarch64-linux-gnu-gcc
      -DHAVE_CONFIG_H
      -I /home/user/myproject/include
      -I /opt/sysroot-aarch64/usr/include
      -I /opt/sysroot-aarch64/usr/include/glib-2.0
      -march=armv8-a
      -mfpu=neon-fp-armv8
      -O2 -g
      -std=c11
      -Wall -Wextra
      -c /home/user/myproject/src/sensor.c
      -o CMakeFiles/sensor.dir/src/sensor.c.o",
    "file": "/home/user/myproject/src/sensor.c"
  },
  {
    "directory": "/home/user/myproject/build",
    "command": "aarch64-linux-gnu-gcc ...",
    "file": "/home/user/myproject/src/config.c"
  }
]

Üç alan

arguments dizisi formatı (önerilen)

[
  {
    "directory": "/home/user/myproject/build",
    "arguments": [
      "aarch64-linux-gnu-gcc",
      "-DHAVE_CONFIG_H",
      "-I", "/home/user/myproject/include",
      "-I", "/opt/sysroot-aarch64/usr/include",
      "-march=armv8-a",
      "-std=c11",
      "-c", "/home/user/myproject/src/sensor.c",
      "-o", "src/sensor.c.o"
    ],
    "file": "/home/user/myproject/src/sensor.c"
  }
]

clangd'nin dosyayı bulma önceliği

  1. Kaynak dosyanın bulunduğu dizinden yukarı doğru compile_commands.json ara
  2. --compile-commands-dir flag'iyle belirtilen dizin
  3. .clangd dosyasındaki CompileFlags.CompilationDatabase ayarı
  4. Hiçbiri yoksa: varsayılan flag'lerle devam et (genellikle yanlış)
    

02 Bear ile otomatik üretim

Bear (Build EAR), herhangi bir build sisteminin derleme komutlarını izleyerek compile_commands.json üreten evrensel bir araçtır. Meson veya CMake kullanılmayan Makefile projelerinde tercih edilir.

Bear kurulumu

# Debian/Ubuntu
sudo apt-get install bear

# Kaynak koddan derleme (güncel sürüm)
git clone https://github.com/rizsotto/Bear.git
cd Bear
cmake -B build -DCMAKE_INSTALL_PREFIX=/usr/local
cmake --build build -j$(nproc)
sudo cmake --install build

bear --version  # 3.x

Makefile projesiyle kullanım

# Mevcut build komutunun önüne bear ekle
bear -- make -j$(nproc)

# Cross-compile Makefile
bear -- make CROSS_COMPILE=aarch64-linux-gnu- -j$(nproc)

# Temiz build üzerine çalıştır (incremental build eksik dosya üretebilir)
make clean
bear -- make -j$(nproc)

# Üretilen dosyayı kontrol et
cat compile_commands.json | python3 -m json.tool | head -40

CMake build ile bear

># CMake --build ile bear
cmake -B build \
  -DCMAKE_TOOLCHAIN_FILE=aarch64-toolchain.cmake
bear -- cmake --build build -j$(nproc)

Ninja build ile bear

># Ninja için de aynı şekilde çalışır
cd builddir
bear -- ninja -j$(nproc)

bear'ın çalışma prensibi

Bear, LD_PRELOAD ile derleyici çalıştırmalarını yakalar (Bear 3.x'te UNIX soket tabanlı intercept). Her exec() çağrısını izleyerek derleyici adı, argümanlar ve dizin bilgisini kaydeder. Build tamamlandığında bu kayıtları compile_commands.json formatına dönüştürür.

Filtreleme ve temizleme

># Çıktıyı belirli dosyaları dışlayarak üret
bear --filter-out '/tmp/*' --filter-out '*/test_*' \
  -- make -j$(nproc)

# jq ile elle filtreleme
jq '[.[] | select(.file | test("src/"))]' \
  compile_commands.json > compile_commands_filtered.json

Yaygın sorunlar ve çözümler

03 CMake ile compile_commands.json

CMake 2.8.5'ten itibaren compile_commands.json üretimini doğrudan destekler. Cross-compile toolchain dosyasıyla birleşince tam cross-compile farkındalıklı bir compilation database elde edilir.

CMAKE_EXPORT_COMPILE_COMMANDS

># CMake yapılandırmasında aktif et
cmake -B build \
  -DCMAKE_EXPORT_COMPILE_COMMANDS=ON \
  -DCMAKE_TOOLCHAIN_FILE=aarch64-toolchain.cmake

# build/compile_commands.json otomatik üretilir
ls build/compile_commands.json

CMakeLists.txt içinde kalıcı etkinleştirme

cmake_minimum_required(VERSION 3.16)
project(sensor-daemon C)

# IDE desteği için her zaman üret
set(CMAKE_EXPORT_COMPILE_COMMANDS ON CACHE BOOL "" FORCE)

add_executable(sensor-daemon
  src/main.c
  src/sensor_spi.c
  src/sensor_gpio.c
)

Cross-compile toolchain dosyası

# aarch64-toolchain.cmake
set(CMAKE_SYSTEM_NAME Linux)
set(CMAKE_SYSTEM_PROCESSOR aarch64)

set(SYSROOT /opt/sysroot-aarch64)
set(TOOLCHAIN_PREFIX aarch64-linux-gnu)

set(CMAKE_C_COMPILER   ${TOOLCHAIN_PREFIX}-gcc)
set(CMAKE_CXX_COMPILER ${TOOLCHAIN_PREFIX}-g++)
set(CMAKE_AR           ${TOOLCHAIN_PREFIX}-ar)
set(CMAKE_STRIP        ${TOOLCHAIN_PREFIX}-strip)

set(CMAKE_SYSROOT ${SYSROOT})
set(CMAKE_FIND_ROOT_PATH ${SYSROOT})

# Host araçları host'ta, hedef kütüphaneler sysroot'ta ara
set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)

# pkg-config sysroot
set(ENV{PKG_CONFIG_SYSROOT_DIR} ${SYSROOT})
set(ENV{PKG_CONFIG_LIBDIR}
  ${SYSROOT}/usr/lib/pkgconfig:${SYSROOT}/usr/share/pkgconfig)

compile_commands.json proje köküne bağla

># Sembolik link — clangd projenin kökünde arar
ln -sf build/compile_commands.json compile_commands.json

# CMakeLists.txt içinden otomatik oluşturma
if(CMAKE_EXPORT_COMPILE_COMMANDS)
  add_custom_target(link-compile-commands ALL
    COMMAND ${CMAKE_COMMAND} -E create_symlink
      ${CMAKE_BINARY_DIR}/compile_commands.json
      ${CMAKE_SOURCE_DIR}/compile_commands.json
    DEPENDS ${CMAKE_BINARY_DIR}/compile_commands.json
    COMMENT "compile_commands.json proje kokuyle baglaniyor"
  )
endif()

CMake presets ile daha düzenli yapılandırma

>{
  "version": 3,
  "configurePresets": [
    {
      "name": "cross-aarch64",
      "displayName": "ARM64 Cross Compile",
      "generator": "Ninja",
      "binaryDir": "${sourceDir}/build-aarch64",
      "toolchainFile": "${sourceDir}/cmake/aarch64-toolchain.cmake",
      "cacheVariables": {
        "CMAKE_BUILD_TYPE": "RelWithDebInfo",
        "CMAKE_EXPORT_COMPILE_COMMANDS": "ON",
        "CMAKE_INSTALL_PREFIX": "/usr"
      }
    },
    {
      "name": "host-debug",
      "displayName": "Host Debug Build",
      "generator": "Ninja",
      "binaryDir": "${sourceDir}/build-host",
      "cacheVariables": {
        "CMAKE_BUILD_TYPE": "Debug",
        "CMAKE_EXPORT_COMPILE_COMMANDS": "ON"
      }
    }
  ]
}

04 Meson ile compile_commands.json

Meson, compile_commands.json dosyasını her zaman build dizinine otomatik olarak üretir. Ek yapılandırma gerekmez.

Otomatik üretim

># Cross-compile build dizini kur
meson setup builddir-aarch64 \
  --cross-file aarch64-linux-gnu.ini \
  --buildtype debugoptimized

# compile_commands.json hemen kullanılabilir
ls builddir-aarch64/compile_commands.json

# Her ninja çağrısından sonra güncellenir
ninja -C builddir-aarch64

meson introspect ile compilation database

># Derleme komutlarını introspect ile al
meson introspect --targets builddir-aarch64 | \
  jq '.[].target_sources[].parameters'

# Tüm kaynak dosya yolları
meson introspect --targets builddir-aarch64 | \
  jq '.[].target_sources[].sources[]'

Proje köküne bağlantı

># Proje kökünde symlink
ln -sf builddir-aarch64/compile_commands.json compile_commands.json

# clangd sembolik linki takip eder; artık tüm IDE araçları bulabilir
# Birden fazla build dizini varsa hangisini kullanmak istediğine göre seç:
ln -sf builddir-host/compile_commands.json compile_commands.json       # host
# veya
ln -sf builddir-aarch64/compile_commands.json compile_commands.json   # cross

Birden fazla build dizini yönetimi

Aynı projede hem host hem cross build dizini varken clangd'nin doğru olanı kullanması için .clangd dosyasında açıkça belirtmek gerekir:

># .clangd (proje kökü)
CompileFlags:
  CompilationDatabase: builddir-aarch64

Meson build directory değiştirme

># Farklı platformlar için birden fazla dizin kur
meson setup build-host
meson setup build-aarch64 --cross-file aarch64.ini
meson setup build-riscv64 --cross-file riscv64.ini

# Aktif geliştirme için compile_commands.json güncelle
ln -sf build-aarch64/compile_commands.json compile_commands.json

# VS Code'u yeniden başlatmadan clangd'yi yenile
# Komut paleti: "clangd: Restart Language Server"

05 clangd yapılandırması

.clangd dosyası, clangd'nin compile_commands.json'dan aldığı flag'leri nasıl yorumlayacağını ve değiştireceğini belirler. Cross-compile ortamlarda sysroot ve target flag ayarları kritiktir.

Temel .clangd dosyası

># .clangd (proje kökü)
CompileFlags:
  # Derleme veritabanı dizini (compile_commands.json'ın bulunduğu yer)
  CompilationDatabase: builddir-aarch64

  # Flag ekle (compile_commands.json'a ek olarak)
  Add:
    - --target=aarch64-linux-gnu
    - --sysroot=/opt/sysroot-aarch64
    - -isystem/opt/sysroot-aarch64/usr/include

  # Problematik flag'leri kaldır (clang anlamıyor)
  Remove:
    - -march=armv8-a+crc+simd   # clang farklı sözdizimi kullanır
    - -mno-unaligned-access
    - -fno-tree-loop-distribute-patterns

Diagnostics:
  UnusedIncludes: Strict
  ClangTidy:
    Add:
      - readability-*
      - modernize-*
      - bugprone-*
    Remove:
      - readability-magic-numbers
    CheckOptions:
      modernize-use-auto.MinTypeNameLength: 5

Index:
  Background: Build    # Arka planda indeksle

InlayHints:
  Enabled: true
  ParameterNames: true
  DeducedTypes: true

Target triple ayarı

># ARM Cortex-A53 için
CompileFlags:
  Add:
    - --target=aarch64-linux-gnu
    - --sysroot=/opt/sysroot-aarch64

# ARM Cortex-M4 (baremetal) için
CompileFlags:
  Add:
    - --target=arm-none-eabi
    - -mthumb
    - -mcpu=cortex-m4
    - -mfpu=fpv4-sp-d16
    - -mfloat-abi=hard
  Remove:
    - -specs=nano.specs   # clang bilmez

# RISC-V 64-bit için
CompileFlags:
  Add:
    - --target=riscv64-linux-gnu
    - --sysroot=/opt/riscv64-sysroot
    - -march=rv64imafdc
    - -mabi=lp64d

Dosya bazlı yapılandırma

># .clangd — farklı dizinler için farklı ayar
If:
  PathMatch: src/.*\.c
CompileFlags:
  Add: [-DSRC_BUILD]
---
If:
  PathMatch: tests/.*\.c
CompileFlags:
  Add: [-DUNIT_TEST, -DMOCK_HARDWARE]
  Remove: [-O2]
---
If:
  PathMatch: drivers/.*\.c
CompileFlags:
  Add: [--target=aarch64-linux-gnu, --sysroot=/opt/sysroot-aarch64]

clangd sürüm ve flag uyumluluğu

06 VS Code + clangd

VS Code'da clangd extension'ı kurulup yapılandırılırken yerleşik IntelliSense (Microsoft C/C++ extension) ile çakışmayı önlemek gerekir.

Extension kurulumu

># VS Code marketplace'den kur
# Extension ID: llvm-vs-code-extensions.vscode-clangd

# veya komut satırından
code --install-extension llvm-vs-code-extensions.vscode-clangd

IntelliSense çakışmasını önleme

># .vscode/settings.json
{
  "C_Cpp.intelliSenseEngine": "disabled",
  "C_Cpp.autocomplete": "disabled",
  "C_Cpp.errorSquiggles": "disabled",

  "clangd.path": "/usr/bin/clangd",
  "clangd.arguments": [
    "--compile-commands-dir=${workspaceFolder}",
    "--background-index",
    "--background-index-priority=normal",
    "--clang-tidy",
    "--header-insertion=iwyu",
    "--completion-style=detailed",
    "--function-arg-placeholders",
    "--fallback-flags=-std=c11",
    "--log=info",
    "--pch-storage=memory"
  ],
  "clangd.onConfigChanged": "restart"
}

c_cpp_properties.json vs clangd

Microsoft C/C++ extension'ının c_cpp_properties.json dosyası ve clangd birbirini dışlar. İkisi aynı anda kullanılmamalıdır:

Uzak geliştirme (SSH container)

># Remote container'da clangd çalıştırma
# .devcontainer/devcontainer.json
{
  "name": "Embedded Linux Dev",
  "image": "myorg/embedded-dev:latest",
  "customizations": {
    "vscode": {
      "extensions": [
        "llvm-vs-code-extensions.vscode-clangd"
      ],
      "settings": {
        "clangd.path": "/usr/bin/clangd-17",
        "clangd.arguments": [
          "--compile-commands-dir=/workspace",
          "--background-index",
          "--clang-tidy"
        ]
      }
    }
  },
  "mounts": [
    "source=/opt/sysroot-aarch64,target=/opt/sysroot-aarch64,type=bind,readonly"
  ]
}

clangd durum kontrolü

># VS Code komut paletinden
# "clangd: Open Log" — bağlantı ve index durumu
# "clangd: Restart Language Server" — yeniden başlat
# "clangd: Show AST" — seçili ifadenin AST ağacı

# Terminal'den clangd test
echo '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"capabilities":{}}}' | \
  clangd --compile-commands-dir=builddir-aarch64

07 Kernel kaynak kodu için clangd

Linux kernel kaynak kodunu IDE'de anlamlı biçimde gezebilmek için compile_commands.json üretimi ve clangd yapılandırması özel adımlar gerektirir.

gen_compile_commands.py

Linux kernel 5.x'ten itibaren kendi compile_commands.json üretecine sahiptir:

># Kernel derleme (cross)
export ARCH=arm64
export CROSS_COMPILE=aarch64-linux-gnu-
make defconfig
make -j$(nproc)

# compile_commands.json üret
python3 scripts/clang-tools/gen_compile_commands.py

# Üretilen dosya kernel kaynak kökündedir
ls compile_commands.json

gen_compile_commands.py çalışma prensibi

Script, build dizinindeki .*.cmd dosyalarını tarar. Kernel build sistemi her .o dosyası için bir .cmd dosyası oluşturur; bu dosya tam derleme komutunu içerir. Script bu komutları toplayıp JSON formatına dönüştürür.

># Örnek .cmd dosyası (drivers/gpio/.gpio-sysfs.o.cmd)
# cmd_drivers/gpio/gpio-sysfs.o :=
# aarch64-linux-gnu-gcc -Wp,-MMD,drivers/gpio/.gpio-sysfs.o.d
# -nostdinc -I./arch/arm64/include -I./arch/arm64/include/generated
# -I./include -I./arch/arm64/include/uapi
# -include ./include/linux/compiler-version.h
# -D__KERNEL__ -mlittle-endian -DKASAN_SHADOW_SCALE_SHIFT=3
# -fmacro-prefix-map=./= -std=gnu11 ...
# -c -o drivers/gpio/gpio-sysfs.o drivers/gpio/gpio-sysfs.c

Kernel için .clangd

># Linux kaynak kökü .clangd
CompileFlags:
  Add:
    - --target=aarch64-linux-gnu
    - -isystem/usr/lib/llvm-17/lib/clang/17/include

  # GCC'ye özgü kernel flag'leri clang'da çalışmaz
  Remove:
    - -mno-fp-ret-in-387
    - -mpreferred-stack-boundary=3
    - -fno-allow-store-data-races
    - -fconserve-stack
    - -mindirect-branch=thunk-extern
    - -mharden-sls=all
    - -fzero-call-used-regs=used-gpr
    - -fno-stack-clash-protection
    - -mrecord-mcount
    - -mnop-mcount
    - --param=allow-store-data-races=0

Diagnostics:
  Suppress:
    - pp_including_mainfile_in_preamble

Index:
  Background: Skip   # Kernel çok büyük — arka plan indeksini devre dışı bırak

Modül geliştirmede out-of-tree derleme

># Dış modül için compile_commands.json üretimi
# Makefile
obj-m += mydriver.o
mydriver-objs := src/mydriver_core.o src/mydriver_spi.o

# Derleme ve compile_commands.json üretimi
make -C /path/to/linux M=$(pwd) modules \
  ARCH=arm64 CROSS_COMPILE=aarch64-linux-gnu-

# gen_compile_commands.py'yi dış modül dizinine uygula
python3 /path/to/linux/scripts/clang-tools/gen_compile_commands.py \
  -d $(pwd)

# .clangd (modül dizini)
CompileFlags:
  CompilationDatabase: .
  Add:
    - --target=aarch64-linux-gnu
    - -isystem/usr/lib/llvm-17/lib/clang/17/include

compile_commands.json boyutunu yönetme

># Kernel tüm dosyalar için çok büyük — sadece ilgili alt sistem
python3 scripts/clang-tools/gen_compile_commands.py \
  -- drivers/net/ drivers/gpio/ drivers/spi/

# clangd bellek sınırı ayarla (settings.json)
"clangd.arguments": [
  "--background-index=false",
  "--limit-results=50",
  "--limit-references=1000"
]

08 clang-tidy ve clang-format entegrasyonu

clangd, clang-tidy lint kontrollerini ve clang-format kod formatlama kurallarını projeye entegre ederek kod kalitesini CI sürecine kadar uzanan bir zincirde otomatikleştirir.

.clang-tidy yapılandırması

># .clang-tidy (proje kökü)
---
Checks: >
  -*,
  bugprone-*,
  cert-*,
  clang-analyzer-*,
  misc-*,
  performance-*,
  portability-*,
  readability-braces-around-statements,
  readability-else-after-return,
  readability-function-cognitive-complexity,
  readability-identifier-naming,
  -bugprone-easily-swappable-parameters,
  -cert-err34-c,
  -misc-include-cleaner

WarningsAsErrors: ''

HeaderFilterRegex: '^/home/user/myproject/include/.*'

CheckOptions:
  - key: readability-function-cognitive-complexity.Threshold
    value: '20'
  - key: readability-identifier-naming.FunctionCase
    value: lower_case
  - key: readability-identifier-naming.VariableCase
    value: lower_case
  - key: readability-identifier-naming.GlobalConstantCase
    value: UPPER_CASE
  - key: readability-identifier-naming.MacroDefinitionCase
    value: UPPER_CASE

.clang-format yapılandırması (kernel stili)

># .clang-format (Linux kernel stili temel alınarak)
---
BasedOnStyle: LLVM
IndentWidth: 8
UseTab: Always
TabWidth: 8
BreakBeforeBraces: Linux
AllowShortIfStatementsOnASingleLine: false
AllowShortFunctionsOnASingleLine: false
AllowShortLoopsOnASingleLine: false
IndentCaseLabels: false
ColumnLimit: 80
SpaceBeforeParens: ControlStatements
PointerAlignment: Right
AlignTrailingComments: true
SortIncludes: false
IncludeBlocks: Preserve

VS Code format on save

># .vscode/settings.json
{
  "[c]": {
    "editor.defaultFormatter": "llvm-vs-code-extensions.vscode-clangd",
    "editor.formatOnSave": true,
    "editor.formatOnType": false
  },
  "[cpp]": {
    "editor.defaultFormatter": "llvm-vs-code-extensions.vscode-clangd",
    "editor.formatOnSave": true
  }
}

CI pipeline — lint ve format kontrolü

># .github/workflows/lint.yml
name: Kod Kalitesi

on: [push, pull_request]

jobs:
  clang-tidy:
    runs-on: ubuntu-22.04
    steps:
      - uses: actions/checkout@v4

      - name: Bağımlılıkları kur
        run: sudo apt-get install -y clang-tidy-17 ninja-build cmake

      - name: Build (compile_commands.json üret)
        run: |
          cmake -B build \
            -DCMAKE_EXPORT_COMPILE_COMMANDS=ON \
            -DCMAKE_C_COMPILER=clang-17
          cmake --build build -j$(nproc)

      - name: clang-tidy çalıştır
        run: |
          run-clang-tidy-17 \
            -p build \
            -header-filter='^.*include/.*' \
            $(find src -name '*.c') 2>&1 | tee tidy-output.txt
          if grep -q "warning:" tidy-output.txt; then
            echo "clang-tidy uyarılari bulundu"
            exit 1
          fi

  clang-format:
    runs-on: ubuntu-22.04
    steps:
      - uses: actions/checkout@v4

      - name: clang-format sürümü
        run: clang-format-17 --version

      - name: Format kontrolü
        run: |
          find src include -name '*.c' -o -name '*.h' | \
            xargs clang-format-17 --dry-run --Werror

clang-tidy tek dosya çalıştırma

># Tek dosyada clang-tidy
clang-tidy-17 \
  -p builddir-aarch64 \
  src/sensor_spi.c \
  -- --target=aarch64-linux-gnu

# Belirli kontrolü çalıştır
clang-tidy-17 \
  -p build \
  -checks='bugprone-use-after-move,misc-unused-parameters' \
  src/main.c

# Otomatik düzeltme uygula
clang-tidy-17 -p build -fix src/config.c

clang-format git ile entegrasyon

># Yalnızca değiştirilen satırları formatla (git ile)
git diff -U0 HEAD | \
  clang-format-diff-17 -p1 -style=file -i

# Pre-commit hook
cat > .git/hooks/pre-commit << 'EOF'
#!/bin/sh
CHANGED=$(git diff --cached --name-only --diff-filter=ACM | grep '\.[ch]$')
if [ -n "$CHANGED" ]; then
  git diff -U0 --cached -- $CHANGED | \
    clang-format-diff-17 -p1 -style=file > /tmp/fmt.patch
  if [ -s /tmp/fmt.patch ]; then
    echo "Format hatasi var. 'make format' calistirin."
    cat /tmp/fmt.patch
    exit 1
  fi
fi
exit 0
EOF
chmod +x .git/hooks/pre-commit