/* 이름이 보이는 네 가지 범위 --- 표준이 정한 그대로. */
#include <stdio.h>

/* ① 파일 스코프: 여기서부터 이 파일 끝까지 보인다 */
static int file_level = 1;

/* ② 함수 원형 스코프: 매개변수 이름 rows·cols 는 이 괄호가 닫히면 사라진다.
      이름이 사라져도 쓸모는 있다 --- 뒤 매개변수의 크기를 이 이름으로 적는다. */
void print_grid(int rows, int cols, int grid[rows][cols]);

/* ③ 함수 스코프: 레이블은 함수 전체에서 보인다. 블록 안에 적어도 그렇다. */
static int find_first_negative(const int *a, int n)
{
    for (int i = 0; i < n; i++) {
        if (a[i] < 0) {
            goto found;          /* 아래 블록 안의 레이블로 뛴다 */
        }
    }
    return -1;
    {
    found:                       /* 블록 안에 있어도 함수 어디서나 보인다 */
        return 0;
    }
}

void print_grid(int rows, int cols, int grid[rows][cols])
{
    for (int r = 0; r < rows; r++) {
        for (int c = 0; c < cols; c++) printf(" %d", grid[r][c]);
        putchar('\n');
    }
}

int main(void)
{
    /* ④ 블록 스코프: 이 중괄호 안에서만 */
    int block_level = 2;
    {
        int inner = 3;
        printf("inner block sees: file=%d block=%d inner=%d\n",
               file_level, block_level, inner);
    }
    /* 여기서 inner 는 이미 이름이 아니다 */

    int grid[2][3] = {{1, 2, 3}, {4, 5, 6}};
    puts("\nthe grid, sized by names from the prototype scope:");
    print_grid(2, 3, grid);

    int values[] = {5, 7, -2, 9};
    printf("\nfirst negative found: %s\n",
           find_first_negative(values, 4) == 0 ? "yes" : "no");
    return 0;
}

/* 스코프는 '선언자가 끝난 지점'부터 시작한다 --- 등호 앞이 아니라. */
#include <stdio.h>

typedef int meter;          /* 파일 스코프의 타입 이름 */

int main(void)
{
    /* i 의 스코프는 = 를 만나기 *전에* 이미 시작했다.
       그래서 sizeof(i) 는 방금 선언한 그 i 를 가리킨다(값은 읽지 않는다). */
    int i = sizeof(i);
    printf("int i = sizeof(i);  -> %d\n", i);

    /* 자기 자신의 주소를 담는 포인터도 같은 이치로 성립한다 */
    void *self = &self;
    printf("void *self = &self; -> self == &self is %s\n",
           self == (void *)&self ? "true" : "false");

    {
        /* 이 자리에서 meter 는 타입 이름이다. 그러나 아래 한 줄이 지나면
           이 블록에서 meter 는 *변수*다 --- 선언자가 끝난 지점부터. */
        meter meter = 42;
        printf("meter meter = 42;   -> %d  (the type name is now shadowed)\n", meter);
    }

    /* 블록을 벗어나면 meter 는 다시 타입 이름이다 */
    meter distance = 7;
    printf("outside the block, meter is a type again -> %d\n", distance);

    /* for 의 첫 칸에 선언한 이름은 루프가 끝나면 사라진다 */
    for (int n = 0; n < 3; n++) { /* n 은 여기서만 */ }
    /* 여기서 n 은 이름이 아니다 --- 같은 이름을 다시 써도 서로 무관하다 */
    for (int n = 10; n > 8; n--) { /* 앞의 n 과 아무 관계가 없다 */ }
    puts("\ntwo loops used the name n; neither knows the other");
    return 0;
}

/* 가림(shadowing), 그리고 전처리기는 스코프를 모른다는 것. */
#include <stdio.h>

int count = 100;                 /* 파일 스코프 */

static void layers(void)
{
    printf("file scope        : count = %d\n", count);
    int count = 10;              /* 파일 스코프의 count 를 가린다 */
    printf("function body     : count = %d\n", count);
    {
        int count = 1;           /* 다시 가린다 */
        printf("inner block       : count = %d\n", count);
    }
    printf("back in the body  : count = %d\n", count);
    /* 가려진 이름은 사라진 것이 아니다 --- 다른 이름으로는 여전히 닿는다 */
}

static void define_inside(void)
{
    /* 이 지시는 '함수 안' 이라는 자리와 아무 상관이 없다.
       전처리는 컴파일 전에 끝나고, 전처리기는 블록을 모른다. */
#define LIMIT 5
    printf("\ninside the function : LIMIT = %d\n", LIMIT);
}

static void far_away(void)
{
    /* 다른 함수인데도 LIMIT 이 그대로 살아 있다 --- 스코프가 아니라
       '그 지점부터 파일 끝까지'이기 때문이다. */
    printf("another function    : LIMIT = %d\n", LIMIT);
}

int main(void)
{
    layers();
    define_inside();
    far_away();
    printf("\nthe file-scope count is still %d\n", count);
    return 0;
}