BARR-C:2018 완전 분석 - 60개 규칙 실전 가이드

// 파일명: SensorDriver.c  (대소문자 혼용)
// 파일명: led-driver.c    (하이픈 사용)

// 파일명: sensor_driver.c  ✓
// 파일명: led_driver.c     ✓

void MotorSpeed(uint16_t rpm);      // 대문자 시작, 동사 없음
void motor_speed(uint16_t rpm);     // 동사 없음 (getter인지 setter인지 불명확)

void set_motor_speed(uint16_t rpm);     // ✓ 동사 + 명확한 의도
uint16_t get_motor_speed(void);         // ✓ getter 명확
void start_motor(void);                 // ✓ 간결한 동사

// 하드웨어 제어 함수
void init_gpio(void);                   // ✓
void enable_timer(uint8_t timer_id);    // ✓
void disable_interrupt(IRQn_Type irq);  // ✓
 
// 나쁜 예
void GPIO_Init(void);                   // ✗ 대문자
void timer2_enable(void);               // ✗ 동사가 뒤에

int Calculate;          // 동사 (함수로 오해)
int motorRPM;           // 카멜 케이스
int m_speed;            // 헝가리안 표기법

uint16_t motor_speed;       // ✓ 명사 + 의미 명확
uint32_t sensor_value;      // ✓
bool is_running;            // ✓ 상태 변수

// 전역 변수는 g_ 접두사로 구분
uint32_t g_system_tick;         // ✓ 전역 변수 명확
static uint16_t s_sensor_count; // ✓ 정적 변수 명확

typedef struct {
    uint8_t id;
} Sensor;  // 타입인지 변수인지 불명확
 
typedef uint32_t Counter;  // _t 없음

typedef struct {
    uint8_t id;
    uint16_t value;
} sensor_t;  // ✓ 타입임이 명확
 
typedef uint32_t counter_t;  // ✓
 
// 사용 예
sensor_t temperature_sensor;  // 타입과 변수 명확히 구분

// 레지스터 맵 타입 정의
typedef struct {
    volatile uint32_t CR;    // Control Register
    volatile uint32_t SR;    // Status Register
    volatile uint32_t DR;    // Data Register
} timer_regs_t;
 
// 하드웨어 추상화 타입
typedef struct {
    GPIO_TypeDef *port;
    uint16_t pin;
} gpio_pin_t;
 
gpio_pin_t led_pin = {GPIOA, GPIO_PIN_5};  // ✓ 명확한 사용

#define maxSpeed 100        // 소문자 (변수로 오해)
#define Max_Speed 100       // 대소문자 혼용
#define max-speed 100       // 하이픈 (구문 오류)

#define MAX_SPEED 100           // ✓
#define BUFFER_SIZE 256         // ✓
#define PI 3.14159265359        // ✓
 
// 함수형 매크로
#define MIN(a, b) ((a) < (b) ? (a) : (b))  // ✓

// 레지스터 주소 정의
#define GPIO_BASE       0x40020000U
#define UART_BASE       0x40011000U
 
// 비트 마스크
#define GPIO_PIN_0      (1U << 0)
#define GPIO_PIN_5      (1U << 5)
 
// 하드웨어 설정
#define SYSTEM_CLOCK    72000000U   // 72 MHz
#define BAUD_RATE       115200U

// 나쁜 예: 매크로 함수 (타입 안전성 없음)
#define SQUARE(x) ((x) * (x))  // x가 x++이면 위험
 
// 좋은 예: inline 함수 (타입 안전)
static inline uint32_t square(uint32_t x) {
    return x * x;  // ✓
}

int sensor_value;       // 16비트? 32비트? 불명확
unsigned long counter;  // 32비트? 64비트?

#include <stdint.h>
 
int16_t sensor_value;       // ✓ 항상 16비트
uint32_t counter;           // ✓ 항상 32비트
uint8_t buffer[256];        // ✓ 바이트 단위 명확

int8_t pin_number = 5;      // 핀 번호는 음수가 없음
int32_t buffer_size = 1024; // 크기는 항상 양수

uint8_t pin_number = 5;         // ✓ 0-255 범위
uint32_t buffer_size = 1024;    // ✓ 크기는 부호 없음

// 센서 값 (음수 온도)
int16_t temperature = -25;  // ✓ 음수 필요
 
// 오류 코드 (음수 = 오류)
int32_t result = read_sensor();
if (result < 0) {
    // 오류 처리
}

// 나쁜 예: 부호 있는 타입 비트 연산
int8_t mask = 0x80;  // -128로 해석 (부호 확장)
 
// 좋은 예
uint8_t mask = 0x80U;  // ✓ 128로 해석

char buffer[256];  // 텍스트? 바이너리 데이터? 불명확
char status = gpio_read();  // GPIO 상태를 char로?

// 텍스트 문자열
char message[] = "Hello";  // ✓ 텍스트는 char
 
// 바이너리 데이터
uint8_t buffer[256];       // ✓ 바이트 배열
uint8_t status = gpio_read();  // ✓ GPIO 상태

// UART 수신 버퍼
uint8_t rx_buffer[128];  // ✓ 바이너리 데이터
 
// 프로토콜 파싱
void parse_packet(const uint8_t *data, uint16_t length) {
    if (data[0] == 0xAA && data[1] == 0x55) {  // 헤더 확인
        // 패킷 처리
    }
}
 
// 디버그 메시지 (텍스트)
const char *error_msg = "Sensor timeout";  // ✓ 텍스트는 char

enum state {
    STATE_IDLE,
    STATE_RUNNING,
    STATE_ERROR
};  // 크기 불명확 (1바이트? 4바이트?)

typedef enum {
    STATE_IDLE = 0,
    STATE_RUNNING = 1,
    STATE_ERROR = 2
} state_t;
 
// 또는 크기 강제
typedef uint8_t state_t;
#define STATE_IDLE      0U
#define STATE_RUNNING   1U
#define STATE_ERROR     2U

// 나쁜 예: enum 크기 불명확
typedef struct {
    enum state status;  // 1바이트? 4바이트?
    uint8_t id;
} device_t;  // 구조체 크기 예측 불가
 
// 좋은 예: 크기 명확
typedef struct {
    uint8_t status;  // ✓ 1바이트 명확
    uint8_t id;      // ✓
} device_t;  // 2바이트 (패딩 제외)

uint32_t *gpio_data = (uint32_t*)0x40020000;  // volatile 없음
*gpio_data = 0x01;  // 컴파일러가 최적화로 제거할 수 있음

// 하드웨어 레지스터
volatile uint32_t *gpio_data = (volatile uint32_t*)0x40020000;
*gpio_data = 0x01;  // ✓ 컴파일러가 최적화하지 않음
 
// ISR 공유 변수
volatile uint32_t g_tick_count = 0;
 
void SysTick_Handler(void) {
    g_tick_count++;  // ISR에서 수정
}
 
void delay_ms(uint32_t ms) {
    uint32_t start = g_tick_count;  // ✓ volatile 읽기
    while ((g_tick_count - start) < ms) {
        // 대기
    }
}

// 나쁜 예: volatile은 원자성을 보장하지 않음
volatile uint32_t g_counter = 0;
 
void increment(void) {
    g_counter++;  // Read-Modify-Write (3개 명령어, 인터럽트 가능)
}
 
// 좋은 예: 원자성 보장
void increment(void) {
    __disable_irq();
    g_counter++;
    __enable_irq();
}
 
// 또는 atomic 타입 사용 (C11)
#include <stdatomic.h>
atomic_uint_fast32_t g_counter = ATOMIC_VAR_INIT(0);
atomic_fetch_add(&g_counter, 1);  // ✓ 원자적 증가

int is_ready = 1;  // int를 bool처럼 사용
int flag = TRUE;   // 매크로 TRUE (비표준)

#include <stdbool.h>
 
bool is_ready = true;       // ✓ 명확한 불리언
bool has_error = false;     // ✓
 
if (is_ready) {
    // 실행
}

// 나쁜 예
int is_sensor_ready(void) {
    return 1;  // 1이 true? 0이 false?
}
 
// 좋은 예
bool is_sensor_ready(void) {
    return true;  // ✓ 명확
}

typedef struct {
    uint8_t id;       // 1바이트
    // [3바이트 패딩]
    uint32_t value;   // 4바이트
} data_t;  // 총 8바이트 (패딩 때문)

typedef struct {
    uint32_t value;   // 4바이트
    uint8_t id;       // 1바이트
    // [3바이트 패딩]
} data_t;  // 총 8바이트 (순서 조정해도 패딩 필요)

typedef struct {
    uint8_t id;       // 1바이트
    uint8_t reserved[3];  // ✓ 명시적 패딩
    uint32_t value;   // 4바이트
} data_t;  // 총 8바이트 (의도 명확)

typedef struct __attribute__((packed)) {
    uint8_t id;       // 1바이트
    uint32_t value;   // 4바이트
} data_t;  // 총 5바이트 (패딩 없음)
 
// 주의: ARM에서 정렬되지 않은 접근은 Hard Fault 발생 가능

// UART 패킷 구조체
typedef struct __attribute__((packed)) {
    uint8_t header;     // 0xAA
    uint8_t length;     // 데이터 길이
    uint8_t data[32];   // 페이로드
    uint8_t checksum;   // XOR 체크섬
} uart_packet_t;  // ✓ 패킹으로 정확한 크기

void process_data(void *data);  // 타입 불명확

void process_sensor_data(const sensor_data_t *data);  // ✓ 타입 명확
void write_buffer(uint8_t *buffer, uint16_t length);  // ✓

// 읽기 전용 데이터
void print_message(const char *msg);  // ✓ msg 수정 불가
 
// 포인터가 가리키는 데이터 수정 불가
void read_config(const config_t *cfg);  // ✓
 
// 포인터 자체 수정 불가
void set_led(uint8_t *const led_port);  // ✓ led_port 재할당 불가

void (*callback)(uint8_t event);  // 선언이 복잡
 
void register_callback(void (*cb)(uint8_t event)) {
    // 함수 파라미터가 길고 읽기 어려움
}

// 함수 포인터 타입 정의
typedef void (*event_callback_t)(uint8_t event);
 
event_callback_t callback;  // ✓ 간결한 선언
 
void register_callback(event_callback_t cb) {
    callback = cb;  // ✓ 가독성 높음
}

// GPIO 인터럽트 콜백
typedef void (*gpio_irq_callback_t)(uint8_t pin);
 
static gpio_irq_callback_t irq_callbacks[16];  // 핀별 콜백
 
void gpio_register_irq(uint8_t pin, gpio_irq_callback_t callback) {
    if (pin < 16) {
        irq_callbacks[pin] = callback;
    }
}
 
void EXTI0_IRQHandler(void) {
    if (irq_callbacks[0] != NULL) {
        irq_callbacks[0](0);  // 콜백 호출
    }
}

typedef struct {
    uint8_t flag1 : 1;
    uint8_t flag2 : 1;
    uint8_t value : 6;
} config_t;  // 비트 순서가 컴파일러마다 다름

typedef struct {
    uint8_t flags;  // 비트 필드 대신 플래그
} config_t;
 
#define FLAG1_MASK  (1U << 0)
#define FLAG2_MASK  (1U << 1)
#define VALUE_MASK  (0x3FU << 2)  // 6비트
 
// 사용
config_t cfg;
cfg.flags |= FLAG1_MASK;  // ✓ flag1 설정
bool flag1 = (cfg.flags & FLAG1_MASK) != 0;  // ✓ flag1 읽기

// MCU 레지스터 매핑 (데이터시트와 일치)
typedef struct {
    uint32_t EN : 1;      // Enable bit
    uint32_t RESERVED1 : 3;
    uint32_t MODE : 2;    // Mode bits
    uint32_t RESERVED2 : 26;
} timer_cr_t;  // ✓ 하드웨어 매핑용

typedef enum {
    TYPE_INT,
    TYPE_FLOAT,
    TYPE_STRING
} data_type_t;
 
typedef struct {
    data_type_t type;  // ✓ 활성 멤버 식별
    union {
        int32_t int_val;
        float float_val;
        char string_val[32];
    } value;
} tagged_data_t;
 
// 사용
void process_data(const tagged_data_t *data) {
    switch (data->type) {
        case TYPE_INT:
            printf("%d\n", data->value.int_val);  // ✓ 안전한 접근
            break;
        case TYPE_FLOAT:
            printf("%f\n", data->value.float_val);
            break;
        case TYPE_STRING:
            printf("%s\n", data->value.string_val);
            break;
    }
}

typedef union {
    uint32_t word;  // 32비트 전체 접근
    struct {
        uint8_t byte0;
        uint8_t byte1;
        uint8_t byte2;
        uint8_t byte3;
    } bytes;  // 바이트 단위 접근
} reg32_t;
 
reg32_t timer_counter;
timer_counter.word = 0x12345678;
uint8_t low_byte = timer_counter.bytes.byte0;  // 0x78

void process_sensor_data(void) {
    // 150줄의 복잡한 로직
    // 센서 읽기 + 필터링 + 보정 + 저장 + 통신
    // ...
}  // 하나의 함수에 모든 로직

static uint16_t read_sensor_raw(void) {
    // 10줄: ADC 읽기
}
 
static uint16_t filter_sensor_value(uint16_t raw) {
    // 20줄: 이동 평균 필터
}
 
static uint16_t calibrate_sensor_value(uint16_t filtered) {
    // 15줄: 보정 적용
}
 
void process_sensor_data(void) {
    uint16_t raw = read_sensor_raw();
    uint16_t filtered = filter_sensor_value(raw);
    uint16_t calibrated = calibrate_sensor_value(filtered);
    save_sensor_data(calibrated);
    send_sensor_data(calibrated);
}  // ✓ 각 함수 50줄 이내

void init_uart(uint32_t baud, uint8_t parity, uint8_t stop_bits, 
               uint8_t data_bits, uint8_t flow_ctrl, uint32_t timeout);
// 6개 파라미터 - 너무 많음

typedef struct {
    uint32_t baud_rate;
    uint8_t parity;
    uint8_t stop_bits;
    uint8_t data_bits;
    uint8_t flow_control;
    uint32_t timeout_ms;
} uart_config_t;
 
void init_uart(const uart_config_t *config);  // ✓ 1개 파라미터
 
// 사용
uart_config_t cfg = {
    .baud_rate = 115200,
    .parity = UART_PARITY_NONE,
    .stop_bits = UART_STOPBITS_1,
    .data_bits = 8,
    .flow_control = UART_FLOWCONTROL_NONE,
    .timeout_ms = 1000
};
init_uart(&cfg);  // ✓ 가독성 높음

void update_display_and_check_button(void) {
    // LCD 업데이트
    // 버튼 상태 확인
    // LED 제어
    // 여러 작업 혼재
}

void update_display(void);          // ✓ 디스플레이만
bool is_button_pressed(void);       // ✓ 버튼만
void set_led_state(bool state);     // ✓ LED만

uint16_t read_adc(void) {
    // 실패 시 0 반환? 0이 유효한 값일 수 있음
}

typedef enum {
    STATUS_OK = 0,
    STATUS_ERROR = -1,
    STATUS_TIMEOUT = -2
} status_t;
 
status_t read_adc(uint16_t *out_value) {
    if (/* timeout */) {
        return STATUS_TIMEOUT;
    }
    *out_value = /* ADC 값 */;
    return STATUS_OK;  // ✓ 성공/실패 명확
}
 
// 사용
uint16_t adc_value;
if (read_adc(&adc_value) == STATUS_OK) {
    // 성공
} else {
    // 오류 처리
}

uint32_t factorial(uint32_t n) {
    if (n == 0) return 1;
    return n * factorial(n - 1);  // 재귀 (스택 사용)
}
// n=1000이면 스택 오버플로

uint32_t factorial(uint32_t n) {
    uint32_t result = 1;
    for (uint32_t i = 1; i <= n; i++) {
        result *= i;
    }
    return result;  // ✓ 스택 사용 일정
}

callback();  // NULL이면 크래시

if (callback != NULL) {
    callback();  // ✓ 안전한 호출
}

// sensor.c
static void init_adc(void) {
    // 파일 내부에서만 사용
}
 
void sensor_init(void) {
    init_adc();  // ✓ 내부 함수 호출
}

static inline uint16_t read_gpio_pin(GPIO_TypeDef *port, uint16_t pin) {
    return (port->IDR & pin) ? 1 : 0;  // ✓ 간단한 래퍼
}

// sensor.h
void sensor_init(void);
uint16_t sensor_read(void);
 
// sensor.c
#include "sensor.h"
 
void sensor_init(void) {
    // 구현
}

void debug_printf(const char *fmt, ...);  // 디버그 전용

uint32_t temp;  // 함수 시작 부분에 선언
 
void process(void) {
    // 100줄 후...
    temp = calculate();  // temp가 중간에 오염될 위험
}

void process(void) {
    // 사용 직전에 선언
    uint32_t temp = calculate();  // ✓
}

// globals.c
uint32_t g_counter;  // 모든 파일에서 접근 가능

// sensor.c
static uint32_t g_sensor_count = 0;  // ✓ 파일 범위로 제한
 
uint32_t get_sensor_count(void) {
    return g_sensor_count;  // getter로 접근
}

uint32_t counter;  // 초기화 안 됨 (쓰레기 값)
counter++;  // 미정의 동작

uint32_t counter = 0;  // ✓ 선언 시 초기화

const uint32_t SYSTEM_CLOCK = 72000000U;  // ✓ 상수
const char *error_msg = "Timeout";        // ✓ 문자열 상수

uint8_t buffer[256];  // 256이 무슨 의미?

#define BUFFER_SIZE 256
uint8_t buffer[BUFFER_SIZE];  // ✓ 의미 명확

// config.c
uint32_t g_system_config = 0;
 
// config.h
extern uint32_t g_system_config;  // ✓

const uint8_t lookup_table[16] = {
    0, 1, 2, 3, 4, 5, 6, 7,
    8, 9, 10, 11, 12, 13, 14, 15
};  // ✓ 크기 명확

if (timer > 1000) {  // 1000이 무슨 의미?

#define TIMEOUT_MS 1000
if (timer > TIMEOUT_MS) {  // ✓

sensor_config_t cfg = {
    .baud_rate = 115200,
    .timeout = 1000
};  // ✓ 멤버 이름 명시

uint8_t *buffer = NULL;  // ✓

if (flag)
    process();  // 나중에 문장 추가 시 버그 위험

if (flag) {
    process();  // ✓ 항상 중괄호
}

switch (state) {
    case STATE_IDLE:
        break;
    case STATE_RUNNING:
        break;
    default:
        // 오류 처리 또는 assert
        break;
}

switch (cmd) {
    case CMD_RESET:
        reset_device();
        // fall through (의도적)
    case CMD_INIT:
        init_device();
        break;
    default:
        break;
}

while (1) {  // ✓ 명시적 무한 루프
    if (should_exit()) {
        break;  // 명확한 탈출
    }
}

int init_device(void) {
    if (alloc1() != 0) {
        goto error_alloc1;
    }
    if (alloc2() != 0) {
        goto error_alloc2;
    }
    return 0;
 
error_alloc2:
    free1();
error_alloc1:
    return -1;
}

if (5 == count) {  // ✓ = 실수 시 컴파일 오류

if ((a && b) || c) {  // ✓

while (is_busy())
    ;  // ✓ 명시적 빈 루프

#ifndef SENSOR_H
#define SENSOR_H
 
// 내용
 
#endif /* SENSOR_H */

#include <stdint.h>      // 표준
#include <stdbool.h>
 
#include "cmsis.h"       // 외부
 
#include "sensor.h"      // 내부

#ifdef __cplusplus
extern "C" {
#endif
 
// 선언
 
#ifdef __cplusplus
}
#endif

counter++;  // counter를 1 증가

// 하드웨어 버그 우회: 첫 번째 읽기는 무시
(void)adc_read();
uint16_t value = adc_read();  // 두 번째 읽기가 정확

/**
 * @brief ADC 값을 읽습니다.
 * @param[in] channel ADC 채널 번호 (0-15)
 * @param[out] value 읽은 ADC 값 (0-4095)
 * @return STATUS_OK 성공, STATUS_ERROR 실패
 */
status_t adc_read(uint8_t channel, uint16_t *value);

// TODO: DMA 전송으로 최적화 필요
// FIXME: 타임아웃 처리 추가

# .clang-tidy
Checks: >
  readability-*,
  modernize-*,
  performance-*