Go to the first, previous, next, last section, table of contents.

변수 사용 방법(How to Use Variables)

변수(variable)란 그 변수의 값(value)으로 알려진 텍스트 문자열을 표현하기 위해서 makefile에서 정의된 이름이다. 이런 값들은 명시적인 요구에 의해서, 타겟으로, 종속물로, 명령들로, 그리고 makefile의 다른 일부로 대입된다. (make의 다른 어떤 버전들에서는 변수들이 매크로(macros)라고 불린다.)

규칙안에 있는 쉘 명령들을 제외하고, 변수들과 함수들은, `='를 사용한 변수 정의의 오른편을 읽을 때, define 지시어를 사용한 변수 정의의 바디딜을 읽을 때, 확장된다.

변수들은 파일 이름들 리스트들, 컴파일러에게 전달하는 옵션들, 실행할 프로그램들, 소스 파일들을 찾을 디렉토리들, 결과를 쓸 디렉토리들, 또는 상상할 수 있는 모든 것을, 표현할 수 잇다.

변수 이름은 `:', `#', `=', 또는 시작이나 끝에 공백문자를 담고 있지 않는, 문자들의 임의의 시퀀스일 수 있다. 그러나 알파벳, 숫자, 그리고 밑줄이 아닌 것을 담고 있는 변수 이름들은 피해야 한다. 왜냐면 그들이 미래에 다른 특수한 의미를 가질 수 있기 때문이다. 그리고 어떤 쉘에서는 그들이 환경을 통해서 서브-make에게 전달될 수 없기 때문이다. (see section 서브-make에 대한 통신 변수(Communicating Variables to a Sub-make)).

변수 이름들은 대소문자를 구분한다. `foo', `FOO', 그리고 `Foo'는 모두 서로 다른 변수들이다.

변수 이름들에 대해서 대문자 알파벳을 사용하는 것이 전통적이지만 우리는 makefile안에서 내부적인 목적으로 사용되는 변수 이름들에 대해서 소문자 알파벳들을 사용하고 묵시적 규칙들을 제어하는 파라미터들에 대해서나 사용자가 명령 옵션들로 오버라이드(see section 변수 겹쳐쓰기(Overriding Variables))해야 하는 파라미터들에 대해서는 대문자로 예약해놓기를 권하는 바이다.

몇가지 변수들이 단일 구두점이나 단지 몇문자들로 이루어진 이름을 가진다. 이런 것들은 자동 변수들(automatic variables)이고 그들은 특별한 특수 용도를 가진다. See section 자동 변수들(Automatic Variables).

변수 참조의 기본(Basics of Variable References)

변수의 값을 대입하기 위해서 변수의 이름을 괄호나 중괄호로 묶은 뒤에 달러 기호를 앞에 붙인다: `$(foo)' 또는 `${foo}'는 변수 foo에 대한 유효한 참조이다. `$'의 이 특별한 의미때문에 우리는 파일 이름이나 명령안에서 단일 달러 기호의 효과를 가지기 위해서 반드시 `$$'를 써야 한다.

변수 참조들은 어떤 문맥 중에서도 사용될 수 있다: 타겟, 종속물, 명령, 대부분의 지시어, 그리고 새로운 변수 값 안에서. 다음은 일반적인 경우의 예제이다. 여기서 변수는 어떤 프로그램의 모든 오브젝트 파일들의 이름들을 갖고 있다: 

objects = program.o foo.o utils.o
program : $(objects)
        cc -o program $(objects)

$(objects) : defs.h

변수 참조들은 엄격한 텍스트 대입이 일어나는 방식으로 작동한다. 그래서 다음과 같은 규칙은 

foo = c
prog.o : prog.$(foo)
        $(foo)$(foo) -$(foo) prog.$(foo)

C 프로그램 `prog.c'을 컴파일하는 데 사용될 수 있다. 변수 값 앞에 있는 공백들은 변수 할당에서 무시되기 때문에 foo는 정확하게 `c'이다. (여러분의 makefile을 실제로 이렇게 작성하지 마라!)

달러 기호, 열기-괄호 또는 열기-중괄호가 아닌 하나의 문자 앞에다 달러 기호를 붙이면 이것은 그 단일 문자를 변수 이름으로 취급한다. 그래서 x 변수에 대한 참조로써 `$x'를 사용할 수 있다. 그러나 이런 관례는, 자동 변수(see section 자동 변수들(Automatic Variables))의 경우를 제외하고는 사용되지 않도록 강하게 권장되고 있다.

변수의 두 취향(The Two Flavors of Variables)

GNU make에서 한 변수가 값을 가질 수 있는 방법은 두가지이다; 우리는 이것들을 변수의 두 flavors이라고 부른다. 이 두 취향들은 그들이 확장될 때 무엇을 하는가와 그들이 정의된 방법에 따라서 구분된다.

첫번째 변수 취향은 recursively expanded 변수이다. 이런 종류의 변수들은 `='(see section 변수 설정(Setting Variables))를 사용한 라인들이나 define 지시어 (see section 축어 변수 정의(Defining Variables Verbatim))에 의해서 정의된다. 여러분이 지정한 값은 있는 그대로 설치된다; 이것이 다른 변수들에 대한 참조를 담고 있다면 이런 참조들은 그 변수가 대입될 때마다 확장된다(어떤 다른 문자열을 확장하는 코스에서). 이것이 일어날 때 이것은 recursive expansion라고 불린다.

예를 들어서, 

foo = $(bar)
bar = $(ugh)
ugh = Huh?

all:;echo $(foo)

이것은 `Huh?'를 에코한다: `$(foo)'는 `$(bar)'로 확장된다. 그리고 이것은 `$(ugh)'로 확장된다. 그리고 이것은 마지막으로 `Huh?'로 확장된다.

이런 변수의 취향은 다른 make 버전들에 의해서 지원되는 유일한 종류이다. 이것은 장점도 있고 단점도 있다. 장점은(대부분의 사람들이 말하듯이) 다음과 같다: 

CFLAGS = $(include_dirs) -O
include_dirs = -Ifoo -Ibar

이것은 원래 의도된 대로 수행할 것이다: `CFLAGS'가 명령안에서 확장될 때, 이것은 `-Ifoo -Ibar -O'로 확장될 것이다. 가장 큰 단점은 변수의 마지막에다 무언가를 덧붙일 수 없다는 것이다. 다음과 같이 

CFLAGS = $(CFLAGS) -O

이것은 변수 확장의 무한 루프를 발생할 것이기 때문이다. (실제로 make는 무한 루프를 검출하고서 에러를 보고한다.)

다른 단점은 정의안에서 참조된 임의의 함수(see section 텍스트 변환을 위한 함수(Functions for Transforming Text))가 변수가 확장될 때마다 실행될 것이라는 것이다. 이것은 make가 더 느리게 실행하도록 만든다; 더 나쁜 것은 이것은 wildcard와 shell 함수들이, 그들이 호출될 때 쉽게 제어할 수 없기 때문에 또는 얼마나 많이 호출될 것인가를 제어할 수 없기 때문에 예측할 수 없는 결과를 만들어 낸다.

재귀적으로 확장되는 변수들의 이런 모든 문제점들과 불편함을 피하기 위해서 다른 취향이 있다: 단순하게 확장되는 변수들(simply expanded variables).

Simply expanded variables 는 `:=' (see section 변수 설정(Setting Variables))를 사용해서 정의된다. 단순하게 확장되는 변수의 값은 변수가 정의될 때 다른 변수들과 함수들에 대한 참조를 확장하면서 단 한번만 스캔된다. 단순하게 확장되는 변수의 실제 값은 여러분이 작성한 텍스트를 확장한 결과이다. 이것은 다른 변수에 대한 어떤 참조도 담고 있지 않다; 이것은 그들을 값을 이 변수가 정의되었던 때의 것과 같은 것으로 갖는다. 그래서 

x := foo
y := $(x) bar
x := later

는 다음과 같다 

y := foo bar
x := later

단순하게 확장된 변수가 참조될 때 그것의 값은 있는 그대로 대입된다.

다음은 좀 더 복잡한 예제인데, shell 함수(See section shell 함수(The shell Function).)와 `:='를 결합해서 사용하는 것을 예시한 것이다. 이 예제는 또한 변수 MAKELEVEL에 대한 사용을 보여준다. 이 변수는 이것이 한 레벨에서 다른 레벨로 지나갈 때 변하는 것이다. (MAKELEVEL에 대한 정보에 대해서는 See section 서브-make에 대한 통신 변수(Communicating Variables to a Sub-make).) 

ifeq (0,${MAKELEVEL})
cur-dir   := $(shell pwd)
whoami    := $(shell whoami)
host-type := $(shell arch)
MAKE := ${MAKE} host-type=${host-type} whoami=${whoami}
endif

`:='의 이런 사용의 장점은 전형적인 `디렉토리 안으로 들어가는' 명령이 다음과 같이 보일 때이다: 

${subdirs}:
      ${MAKE} cur-dir=${cur-dir}/$@ -C $@ all

단순 확장 변수들은 일반적으로 복잡한 makefile 프로그래밍을 좀 더 예측가능하도록 만든다. 왜냐면 이들은 대부분의 프로그래밍 언어에서의 변수들처럼 작동하기 때문이다. 그들은 어떤 변수를 자신의 값(또는 확장 함수들 중의 하나에 의해서 어떤 방식으로 처리된 이것의 값)을 사용하여 재정의할 수 있도록 하며 확장 함수들을 좀 더 효율적으로 사용할 수 있도록 한다 (see section 텍스트 변환을 위한 함수(Functions for Transforming Text)).

또한 이들을 사용해서 제어된 선두 공백문자(controlled leading whitespace)를 변수 값들로 채용할 수 있다. 선두 공백문자들은 입력에서, 변수 참조와 함수 호출들의 대입이 있기 이전에, 제거된다; 이것은 선두 공백문자들을 다음과 같이 변수 참조로 막음으로써 변수 값안에 선두 공백문자들을 넣을수 있다는 것을 의미한다: 

nullstring :=
space := $(nullstring) # end of the line

여기서 변수 space의 값은 정확히 하나의 스페이스이다. `# end of the line' 주석은 여기에서 명확성을 위해서 들어가 있는 것이다. 뒤에 있는 공백문자들이 변수 값들로부터 제거되지 않기 때문에 라인의 마지막에 있는 하나의 스페이스가 동일한 효과를 가질 것이다(그러나 좀 더 읽기가 힘들다). 공백 문자를 변수 값의 마지막에다 넣는다면 라인의 마지막에서 저것과 같이 주석을 넣는 것이, 여러분의 의도를 명확하게 하기 위해서, 좋은 생각이다. 역으로 변수 값의 마지막에다 임의의 공백 문자들을 넣고자 하지 않는다면, 다음과 같이 라인의 마지막에다 몇개의 공백 문자 뒤에 아무데나 주석을 넣지 않도록 반드시 기억하자: 

dir := /foo/bar    # directory to put the frobs in

여기에서 dir 변수의 값은 `/foo/bar '이다(네개의 뒤에 붙은 스페이스들과 함께). 이것은 아마도 의도한 바가 아닐 것이다. (이 정의하에서 `$(dir)/file'과 같은 것을 상상해보라!)

변수들에 대한 다른 할당 연산자 `?='가 있다. 이것은 조건 변수 할당 연산자(conditional variable assignment operator)라고 불린다. 왜냐면 이것은 그 변수가 아직 정의되지 않았을 경우에만 효력을 가지기 때문이다. 다음 문장은: 

FOO ?= bar

다음과 정확하게 동일하다 (see section origin 함수(The origin Function)): 

ifeq ($(origin FOO), undefined)
  FOO = bar
endif

빈 값으로 설정된 변수도 여전히 정의된 것이기 때문에, `?='는 그 변수를 설정하지 않는다는 것에 주의하자.

변수 참조의 고급 기능(Advanced Features for Reference to Variables)

이 섹션은 좀 더 유연한 방식으로 변수들을 참조하는 데 사용할 수 있는 고급 기능들을 몇가지 설명한다.

대입 참조(Substitution References)

substitution reference(대입 참조)는 한 변수의 값을 지정하는 다른 대체값으로 대입한다. 이것은 `$(var:a=b)' (또는 `${var:a=b}') 형식이며 이것의 의미는, 변수 var의 값을 취해서 한 단어의 뒤에 있는 각 a를 그 값안에 있는 b로 교체하고 결과 문자열을 대입한다는 것을 의미한다.

우리가 "한 단어의 뒤에 있는"이라고 말할 때, 우리는 a가 대체되기 위해서는, 이것이 공백문자가 뒤에 있도록 또는 그 값의 마지막에 있도록 나타나야 한다는 것을 의미한 것이디ㅏ; 그 값안에서 다른 위치에 있는 a는 변경되지 않을 것이다. 예를 들어서: 

foo := a.o b.o c.o
bar := $(foo:.o=.c)

이것은 `bar'를 `a.c b.c c.c'로 설정한다. See section 변수 설정(Setting Variables).

대입 참조는 실제로 patsubst 확장 함수 (see section 문자 대입과 분석을 위한 함수들(Functions for String Substitution and Analysis))의 사용의 축소판이다. 우리는 대입 참조를, 다른 make 구현물과의 호환성을 위해서, patsubst과 함께 제공한다.

대입 참조의 다른 타입은 patsubst의 풀 파워를 사용할 수 있도록 한다. 이것은 위에서 기술된 `$(var:a=b)'과 동일한 형식을 가진다. 다만 이제는 a가 반드시 단일 `%'를 반드시 담아야 한다는 점을 제외하고 말이다. 이런 경우는 `$(patsubst a,b,$(var))'와 동일하다. patsubst 함수 설명은 See section 문자 대입과 분석을 위한 함수들(Functions for String Substitution and Analysis). 

For example:

foo := a.o b.o c.o
bar := $(foo:%.o=%.c)

이것은 `bar'를 `a.c b.c c.c'로 설정한다.

계산된 변수 이름(Computed Variable Names)

계산된 변수 이름들은 정교한 makefile 프로그래밍에서나 필요한 복잡한 개념이다. 대부분의 목적의 경우 이것들을 생각할 필요가 없다. 단 변수의 이름안에 달러 기호를 넣는 것은 심각한 결과를 만들어낼 수 있다는 것을 아는 것을 제외하고 말이다. 그러나 여러분이 모든 것을 이해하기를 원하는 타입의 사람이라면 또는 실제로 그들이 무엇을 하는지 이해하고자 한다면 계속 읽기 바란다.

변수들은 하나의 변수 이름안에서 참조될 수 있다. 이런 것을 우리는 계산된 변수 이름(computed variable name) 또는 포개진 변수 참조(nested variable reference)라고 부른다. 예를 들어서, 

x = y
y = z
a := $($(x))

이것은 a를 `z'로 정의한다: `$($(x))'안에 있는 `$(x)'는 `y'로 확장되기 때문에 `$($(x))'는 `$(y)'로 확장되고 이것은 다시 `z'로 확장된다. 여기서 참조하는 변수의 이름은 명시적으로 언급되지 않았다; 이것은 `$(x)'의 확장에 의해서 계산되었다. `$(x)' 참조는 바깥 변수 참조에 안에 포개져 있다.

이전 예제는 두 레벨의 포갬을 보여준 것이지만 임의의 레벨도 가능하다. 예를 들어서 다음은 세단계 레벨이다: 

x = y
y = z
z = u
a := $($($(x)))

여기서 가장 안쪽에 있는 `$(x)'는 `y'로 확장되고 그래서 `$($(x))'는 `$(y)'로 확장되며 이것은 다시 `z'로 확장된다; 이제 우리는 `$(z)'를 가진다. 이것은 `u'이 된다.

하나의 변수 이름 안에서 재귀적으로-확장되는 변수들에 대한 참조는 일반적인 스타일로 다시 확장된다. 예를 들어서: 

x = $(y)
y = z
z = Hello
a := $($(x))

이것은 a를 `Hello'로 정의한다: `$($(x))'는 `$($(y))'이 되고 이것은 `$(z)'이 되며 이것은 다시 `Hello'가 된다.

포개진 변수 참조들은 다른 참조들과 마찬가지로 변경된 참조들과 함수 호출들 (see section 텍스트 변환을 위한 함수(Functions for Transforming Text))을 가질 수 있다. 예를 들어서 subst 함수 (see section 문자 대입과 분석을 위한 함수들(Functions for String Substitution and Analysis))를 사용하는 다음 예제는: 

x = variable1
variable2 := Hello
y = $(subst 1,2,$(x))
z = y
a := $($($(z)))

결국 a를 `Hello'로 정의한다. 이것과 같이 둘둘 꼬인 포개진 참조를 쓰고자 하는 사람이 있을런지 의심스럽지만 이것은 잘 작동하는 것이다: `$($($(z)))'는 `$($(y))'로 확장된다. 그리고 이것은 다시 `$($(subst 1,2,$(x)))'이 된다. 이것은 x로부터 `variable1' 값을 얻어서 `variable2'로 대입해서 이것을 변경한다. 그래서 전체 문자열은 `$(variable2)'이 된다. 그리고 이것은 그것의 값이 `Hello'인 단순 벼수 참조이다.

계산된 변수 이름은 단일 변수 참조로 완전히 이루어질 필요가 없다. 이것은 몇개의 변수 참조들을, 몇가지 불변 텍스트와 함께, 가질 수 있다. 예를 들어서, 다음은 

a_dirs := dira dirb
1_dirs := dir1 dir2

a_files := filea fileb
1_files := file1 file2

ifeq "$(use_a)" "yes"
a1 := a
else
a1 := 1
endif

ifeq "$(use_dirs)" "yes"
df := dirs
else
df := files
endif

dirs := $($(a1)_$(df))

dirs에게 use_a와 use_dirs의 설정에 종속적으로, a_dirs, 1_dirs, 또는 1_files와 동일한 값을 줄 것이다.

계산된 변수 이름들은 또한 대입 참조에서 다음과 같이 사용될 수 있다: 

a_objects := a.o b.o c.o
1_objects := 1.o 2.o 3.o

sources := $($(a1)_objects:.o=.c)

이것은 sources를, a1의 값에 따라서, `a.c b.c c.c'나 `1.c 2.c 3.c'로 정의한다.

포개진 변수 참조들의 이런 종류의 사용에 대한 유일한 제한은 그들이 호출된 함수의 이름의 일부를 지정할 수 없다는 것이다. 이것은 인식된 함수 이름에 대한 테스트가 포개진 참조들의 확장 이전에 이루어지기 때문이다. 예를 들어서, 

ifdef do_sort
func := sort
else
func := strip
endif

bar := a d b g q c

foo := $($(func) $(bar))

이것은 sort나 strip 함수에게 매개변수로써 `a d b g q c'를 주지 않고, `foo'에게 변수 `sort a d b g q c'나 `strip a d b g q c' 의 값을 준다. 이런 제한은, 그런 변화가 좋은 아이디어라고 보여질 경우 제거될 수도 있다.

변수 할당의 왼쪽편에서, 또는 define 지시어 안에서 다음과 같이 계산된 변수 이름들을 사용할수도 있다: 

dir = foo
$(dir)_sources := $(wildcard $(dir)/*.c)
define $(dir)_print
lpr $($(dir)_sources)
endef

이 예제는 변수 `dir', `foo_sources', 그리고 `foo_print'를 정의한다.

포개진 변수 참조(nested variable references)는 재귀적으로 확장된 변수(recursively expanded variables) (see section 변수의 두 취향(The Two Flavors of Variables)) 와, 비로 이들 모두 makefile 프로그래밍을 할 때 아주 복잡한 방식으로 사용되지만, 많이 다르다는 것을 주목하자.

변수가 값을 얻는 방법(How Variables Get Their Values)

변수들은 다음과 같은 몇가지 방법으로 값들을 얻을 수 잇다:

변수 설정(Setting Variables)

makefile로부터 변수를 설정하기 위해서는 `='나 `:='가 뒤에 붙은 변수 이름으로 시작하는 라인을 작성한다. 그 라인에서 `='나 `:=' 뒤에 오는 것은 무엇이든 값(value)이 된다. 예를 들어서 다음은, 

objects = main.o foo.o bar.o utils.o

objects라는 이름의 변수를 정의한다. 변수의 주변에 있는 공백문자들, `=' 뒤에 있는 공백문자들은 무시된다.

`='로 정의된 변수들은 재귀적으로 확장된(recursively expanded) 변수들이다. `:='로 정의된 변수들은 단순하게 확장된(simply expanded) 변수드이다; 이들 정의들은 이 정의가 만들어지기 이전에 확장되었을 변수 참조들을 담을 수있다. See section 변수의 두 취향(The Two Flavors of Variables).

변수 이름은 함수와 변수 참조들을 가질 수 있다. 이들은 그 라인이 사용할 실제 변수 이름을 찾기 위해서 읽혀질 때 확장된다.

한 변수의 값의 길이는 제한이 없다. 단 컴퓨터의 스와핑 공간의 크기에 종속적이다. 어떤 변수 정의가 길면 그것을 몇개의 라인들로 나누고 원하는 위치에 역슬래쉬-개행문자를 넣어서 쪼개는 것도 좋은 생각이다. 이것은 make의 기능에 영향을 미치지 않고 makefile이 좀 더 읽히기 쉽도록 만들 것이다.

대부분의 변수 이름들은 그것을 전혀 설정하지 않으면, 값으로써 빈 문자열을 가지는 것으로 생각된다. 몇가지 변수들이 빈 것이 아닌 내장 초기 값들을 가지지만 여러분은 그것들을 일반적인 방식으로 설정할 수 있다 (see section 묵시적 규칙에 의해 사용되는 변수(Variables Used by Implicit Rules)). 몇가지 특수 변수들이 각 규칙에 대해서 새로운 값으로 설정된다; 이런 것들은 자동(automatic) 변수라고 한다 (see section 자동 변수들(Automatic Variables)).

어떤 변수가 그것이 앞서 설정되지 않았을 경우에만 어떤 값으로 설정되기를 원한다면 `=' 대신에 단축 연산자 `?='를 사용할 수 있다. 다음 `FOO' 변수의 두가지 설정들은 동일하다 (see section origin 함수(The origin Function)): 

FOO ?= bar

그리고 

ifeq ($(origin FOO), undefined)
FOO = bar
endif

변수에 텍스트를 덧붙이기(Appending More Text to Variables)

이미 정의된 변수의 값에다 텍스트를 추가하는 것은 종종 유용하다. 여러분은 이것을 다음과 같이 `+='이 담겨진 라인으로 한다: 

objects += another.o

이것은 objects 변수의 값을 취해서 텍스트 `another.o'를 그것에 더한다(앞에다 하나의 공백을 붙인다). 그래서: 

objects = main.o foo.o bar.o utils.o
objects += another.o

이것은 objects를 `main.o foo.o bar.o utils.o another.o'로 설정한다.

`+='를 사용하는 것은 다음과 비슷하다: 

objects = main.o foo.o bar.o utils.o
objects := $(objects) another.o

그러나 여러분이 좀 더 복잡한 값들을 사용할 때 중요해지는, 방법상에서 차이가 난다.

문제의 변수가 이전에 정의된 것이 아니라면 `+='는 `='인 것처럼 작동한다: 이것은 재귀적으로-확장된 변수를 정의한다. 그러나 이전의 정의가 있다면, `+='가 하는 정확한 일은 원래 정의한 변수의 취향이 무엇이었는가에 따라서 달라진다. 변수의 두 취향에 대한 설명을 보려면, See section 변수의 두 취향(The Two Flavors of Variables).

여러분이 어떤 변수의 값에다 `+='로 무엇인가를 덧붙일 때, make는 기본적으로, 그 변수의 초기 정의에서 여분의 텍스트를 포함한 것처럼 작동한다. 맨먼저 `:='로 정의해서 단순 확장 변수를 만들었다면 `+='는 그것에다 단순-확장 정의를 추가하고, `:='가 하는 것처럼 이전 값에다 그것을 덧붙이기 이전에 새로운 텍스트로 확장한다. (`:='의 완전한 설명에 대해서는, see section 변수 설정(Setting Variables)). 사실 

variable := value
variable += more

는 완전히 다음과 동일하다: 

variable := value
variable := $(variable) more

한편 일반 `='를 사용하여 재귀적으로-확장되도록 맨처음 정의했던 변수에 `+='를 사용한다면 make는 조금 다른 것을 한다. 재귀적으로-확장되는 변수를 정의할 때 make는 그 변수를 여러분이 변수나 함수 참조로 설정한 값으로 즉각 확장하지 않는다는 것을 기억하자. 그 텍스트를 있는 그대로 넣는 대신에 이런 변수와 함수 참조들이 나중에, 새로운 변수를 참조할 때, 확장되도록 저장한다 (see section 변수의 두 취향(The Two Flavors of Variables)). 재귀적으로-확장되는 변수에 대해서 `+='를 사용할 때 여러분이 지정한 새로운 텍스트를 make가 어디에 덧붙이는 곳이 바로 이 확장되지 않은 텍스트이다. 

variable = value
variable += more

이것은 다음과 거의 동일하다: 

temp = value
variable = $(temp) more

단 하나 물론 이것은 temp라는 변수를 정의하지 않는다는 점을 제외하고 말이다. 이것의 중요성은 그 변수의 예전 값이 변수 참조를 담고 있을 때 발생한다. 다음 일반 예제를 보자: 

CFLAGS = $(includes) -O
...
CFLAGS += -pg # enable profiling

첫번째 라인은 CFLAGS 변수를 다른 변수 includes에 대한 참조로써 정의한다. (CFLAGS는 C 컴파일을 위한 규칙들에 의해서 사용된다; see section 묵시적 규칙들의 카달로그(Catalogue of Implicit Rules).) `='를 정의에서 사용하는 것은 CFLAGS가 재귀적으로-확장된 변수로 만든다. 이것은 `$(includes) -O'가, make가 CFLAGS의 정의를 처리할 때 확장되지 않는다는 것을 의미한다. 그래서 includes는 그의 값이 효력을 발휘하도록 정의될 필요가 아직 없는 것이다. 이것은 CFLAGS에 대한 다른 참조가 있기전에 정의되기만 하면 된다. `+='를 사용하지 않고서 CFLAGS의 값에다 무엇인가를 덧붙이려고 한다면 우리는 다음과 같이 할런지도 모른다: 

CFLAGS := $(CFLAGS) -pg # enable profiling

이것은 거의 근사한 것이지만 우리가 원하는 바로 그것은 아니다. `:='를 사용하면 CFLAGS를 다시 단순하게-확장되는 변수로 재정의해버린다; 이것은 make가 그 변수를 설정하기 전에 `$(CFLAGS) -pg'라는 텍스트로 확장해버린다는 것을 의미한다. includes가 아직도 정의된 것이 아니라면 우리는 ` -O -pg'를 얻고, 나중에 나온 includes 정의는 아무런 효력을 발휘하지 못한다. 역으로 `+='를 사용함으로써 우리는 CFLAGS를 확장되지 않은 값 `$(includes) -O -pg'로 설정한다. 그래서 우리는 includes에 대한 참조를 보존한다. 그러므로 그 값이 나중에 정의를 얻게 되면 `$(CFLAGS)'와 같은 참조는 여전히 그 값을 사용한다.

override 지시어

어떤 변수가 명령 매개변수 (see section 변수 겹쳐쓰기(Overriding Variables)) 로 설정되었다면 makefile 안의 일반 할당은 무시된다. 명령 매개변수로 설정된 바 있더라도 그 변수를 makefile 안에서 설정하고자 한다면 override 지시어를 사용할 수 있다. 이것은 다음과 같이 보이는 라인이다: 

override variable = value

또는 

override variable := value

좀 더 많은 텍스트를 명령 라인에서 정의된 변수에다 덧붙이려면 다음과 같이 사용한다: 

override variable += more text

See section 변수에 텍스트를 덧붙이기(Appending More Text to Variables).

override 지시어는 makefile과 명령 매개변수들 간의 전쟁에서 자동 조절을 위해서 고안된 것이 아니었다. 이것은 사용자가 명령 매개변수들로 지정한 값들을 변경하거나 더할 수 있도록 고안된 것이다.

예를 들어서 C 컴파일러를 실행할 때 언제나 `-g' 스위치를 원한지만 사용자에게 보통처럼 명령 매개변수들로 다른 스위치를 지정하는 것을 허락하고자 한다고 가정하자. 그러면 다음과 같이 override 지시어를 사용할 수 있을 것이다: 

override CFLAGS += -g

override 지시어를 define 지시어로 또한 사용할 수 있다. 이것은 여러분이 기대하는 것과 비슷하게 작동할 것이다: 

override define foo
bar
endef

define에 대한 정보는 다음 섹션을 참조.

축어 변수 정의(Defining Variables Verbatim)

어떤 변수의 값을 설정하는 다른 방법은 define 지시어를 사용하는 것이다. 이 지시어는 개행 문자들이 그 값에 포함되는 것을 허용하는 비일상적인 문법을 가진다. 이렇게 하는 것은 명령들의 묶인 시퀀스(canned sequence)를 정의할 때 편리하다.

define 지시어는, 동일한 라인에, 그 변수의 이름이 뒤따라오고 그외는 아무것도 없다. 변수의 값은 다음에 있는 라인들에 나타난다. 값의 끝은 endef 를 담고 있는 라인에 의해서 표시된다. 문법상의 이런 차이외에 define 은 `='와 비슷하게 작동한다: 이것은 재귀적으로-확장되는 변수를 생성한다 (see section 변수의 두 취향(The Two Flavors of Variables)). 변수의 이름은 함수와 변수 참조를 담고 있을 수 있다. 이것은 사용되는 실제 변수 이름을 찾기 위해서 지시어가 읽힐 때 확장된다. 

define two-lines
echo foo
echo $(bar)
endef

일반 할당에서의 값은 개행을 가지지 못한다; 그러나 define 안의 값들의 라인을 나누는 개행들은 그 변수의 값이 된다(endef 앞에 잇는 마지막 개행은 예외인데 이것은 값의 일부로 생각되지 않는다).

이전 예제는 기능적으로 다음과 동일하다: 

two-lines = echo foo; echo $(bar)

세미콜론으로 나뉜 두 명령들이 두개의 분할된 쉘명령들과 비슷하게 작동하기 때문이다. 그러나, 두개의 분리된 라인을들 사용하는 것은 make 가 쉘을 두번 호출하여 각 라인에 대해서 독립된 서브쉘에서 실행된다는 것을 주목하자. See section 명령 실행(Command Execution)

define 으로 만들어진 변수 정의들이 명령행 변수 정의들보다 우선순위가 더 높기를 바란다면 define 과 함께 override 지시어를, 다음과 같이 묶어서 쓸 수 있다: 

override define two-lines
foo
$(bar)
endef

See section override 지시어.

환경으로부터의 변수들(Variables from the Environment)

make 의 변수들은 make 가 실행중인 환경으로부터 올 수 있다. make 가 시작할 때 본 모든 환경변수들은 make 변수로 동일한 이름과 동일한 값을 가진채 변환된다. 그러나 makefile에서의 명시적 할당이나, 명령 매개변수를 사용한 명시적 할당은 환경을 오버라이드한다. (`-e' 플래그가 지정되면 환경으로부터의 값들이 makefile에 있는 할당들을 오버라이드한다. See section 옵션들의 요약(Summary of Options). 그러나 이것은 권장되는 바가 아니다.)

그래서 CFLAGS 라는 변수를 환경에서 설정하면 이런 컴파일러 스위치들을 대부분의 makefileㄷ르에 있는 모든 C 컴파일이 사용하도록 할 수 잇다. 이것은 표준 또는 전통적인 의미의 변수들에 대해서 안전하다. 왜냐면 어떤 makefile도 그들을 다른 것으로 사용하지 않을 것이라는 것을 여러분은 알고 있기 때문이다. (그러나 이것은 완전히 믿을만한 것이 아니다; 어떤 makefile들은 CFLAGS를 명시적으로 지정해서 환경에 잇는 값에 의해서 영향을 받지 못할 수도 있기 때문이다.)

make가 재귀적으로 호출될 때 외부 호출에서 정의된 변수들은 내부 호출로, 환경을 통해서 전달될 수 있다 (see section make의 재귀적 사용(Recursive Use of make)). 디폴트로 환경으로부터 또는 명령행으로부터 온 변수들만이 재귀적 호출에 전달된다. export 지시어를 사용해서 다른 변수들을 익스포트할 수 있다. 자세한 내용은 See section 서브-make에 대한 통신 변수(Communicating Variables to a Sub-make).

환경으로부터의 변수들을 다르게 사용하는 것은 권장되지 않는다. makefile들이 그들의 기능을 그들의 제어 바깥에서 설정된 환경변수들에 의존한다는 것은 별로 현명한 것이 아니다. 왜냐면 이렇게 하는 것은 동일한 makefile을 가지고 다른 사용자들이 다른 결과를 얻게 만들기 때문이다. 이것은 대부분의 makefile의 전체 목적에 위배된다.

그런 문제들은 SHELL 이라는 변수로, 특별히 잘 일어날 것이다. 이것은 일반적으로 환경에서 사용자의 인터렉티브 쉘로 지정하는 데 사용된다. 이런 선택이 make 에 영향을 미치는 것은 원하는 것이 아닐 것이다. 그래서 make 는 SHELL 환경변수의 값을 무시한다 (SHELL 이 보통 설정되지 않는 MS-DOS와 MS-Windows는 제외. See section 명령 실행(Command Execution).)

타겟-종속적인 변수 값( Target-specific Variable Values)

make 에 있는 변수값들은 보통 전역적이다; 즉, 그들이 평가된 위치와 상관없이 이들은 동일하다(물론 그들이 리셋되지 않는다면). 한가지 예외는 자동 변수들의 경우이다 (see section 자동 변수들(Automatic Variables)).

다른 예외는 타겟-종속 변수 값(target-specific variable values)이다. 이 기능은 동일한 변수에 대해서, make 가 현재 빌드하고 있는 타겟에 기반해서, 다른 값들을 정의할 수 있도록 한다. 자동변수의 경우 이런 값들은 단지 타겟의 명령 스크립트의 내용안에서(그리고 다른 타겟-종속적인 할당에서)만 사용 가능하다.

타겟-종속적인 변수값은 다음과 같이 설정한다: 

target ... : variable-assignment

또는 다음과 같이 정의한다: 

target ... : override variable-assignment

다수의 target 값들은 타겟 리스트의 각 멤버에 대해서 타겟-종속적인 값을 개별적으로 생성한다.

variable-assignment 는 할당의 유효한 형태이면 아무거나 된다; 재귀적 (`='), 정적 (`:='), 덧붙이기 (`+=', 또는 조건 (`?='). variable-assignment에 나타나는 모든 변수들은 타겟의 내용물 안에서 평가된다: 그래서 임의의 사전-정의된 타겟-종속적인 변수 값들이 효력을 발휘할 것이다. 이 변수는 실제로 어떤 "전역" 값과도 구분이 된다는 점에 주목하자: 두 변수들이 동일한 취향(재귀적 vs. 정적)을 반드시 가질 필요는 없다.

타겟-종속적인 변수들은 다른 makefile 변수와 동일한 우선순위를 가진다. 명령행에서 주어진 변수들이(그리고 `-e' 옵션이 주어졌다면 환경에서 주어진 변수들이) 우선권을 가질것이다. override를 지정하는 것은 타겟-종속 변수 값이 더 선호되도록 할 것이다.

타겟-종속적인 변수들의 특수한 기능이 하나 더 있다: 타겟-종속적인 변수를 정의할 때 그 변수의 값이 또한 이 타겟의 모든 종속물들에 대해서도 영향을 미친다(단 이런 종속물들이 그들 자신의 타겟-종속적인 변수 값으로써 그것을 오버라이드하지 않았다면 말이다). 그래서 예를 들면 다음과 같은 문장은: 

prog : CFLAGS = -g
prog : prog.o foo.o bar.o

CFLAGS를 `prog'에 대한 명령 스크립트에서 `-g'로 설정할 것이다. 그러나 이것은 또한 CFLAGS를 `prog.o', `foo.o', 그리고 `bar.o'를 생성하는 명령 스크립트안에서, 그리고 이들의 종속물들을 생성하는 임의의 명령 스크립트들을 생성하는 명령 스크립트들 안에서 `-g'로 설정할 것이다.

패턴-종속적인 변수값(Pattern-specific Variable Values)

타겟-종속적인 변수값 (see section 타겟-종속적인 변수 값( Target-specific Variable Values)) 에 덧붙여서, GNU make는 패턴-종속적인 변수값을 지원한다. 이 형에서 변수는 지정된 패턴과 일치하는 임의의 타겟에 대해서 정의된다. 이런식으로 정의된 변수들은, 그 타겟에 대해서 명시적으로 정의된 임으의 타겟-종속적인 변수들 이후에, 그리고 타겟 종속적인 변수가 어버이 타겟에 대해서 정의되기 전에, 검색된다.

패턴-종속적인 변수값은 다음과 같이 지정한다: 

pattern ... : variable-assignment

또는 다음과 같이: 

pattern ... : override variable-assignment

여기서 pattern 는 %-패턴이다. 타겟-종속 변수값과 동일하게 다수의 pattern 값들이 각 패턴에 대해서 개별적으로 패턴-종속 변수값을 생성한다. variable-assignment 는 유효한 할당이면 무엇이든 된다. 임의의 명령행 변수 설정이, override가 지정되지 않았다면, 더 높은 우선순위를 가진다.

예를 들어서: 

%.o : CFLAGS = -O

이것은 패턴 %.o와 일치하는 모든 타겟들에 대해서 `-O'를 CFLAGS의 값으로 할당할 것이다.

Go to the first, previous, next, last section, table of contents.