깡통

Local서버에서 Remote서버로 다량의 디렉토리와 하위 파일들을 ftp를 이용해서 전송시 쉘프로그램

------------------------------------------------------------------------------------------

ftpFaxPut.sh

------------------------------------------------------------------------------------------

#!/bin/sh
FTP_CMD="/usr/bin/ftp";
FTP_HOST="000.000.000.000";
FTP_USER="user";
FTP_PASS="passwd";
LOCAL_PATH="/data/tmax/tsdms_New/fileupload/fax/prepared";
BACKUP_PATH="/data/tmax/tsdms_New/fileupload/fax/completed";

export FTP_CMD FTP_HOST FTP_USER FTP_PASS LOCAL_PATH

DIRECTORYS=`ls -1 $LOCAL_PATH`

date >> /data/tmax/cronsh/ftp/ftpFaxexcutedate.txt

for temp in $DIRECTORYS
  do
    if [ ! -f $LOCAL_PATH/$temp ]
    then
      echo "GET DIRECTORY : $temp";
      echo "GET DIRECTORY : $temp" >> /data/tmax/cronsh/ftp/ftpFaxexcutedate.txt
      /data/tmax/cronsh/ftp/ftpFaxPutFile.sh $FTP_CMD $FTP_HOST $FTP_USER $FTP_PASS $LOCAL_PATH $temp > /dev/null
    fi
  done

# File Move after File Transfer
mv $LOCAL_PATH/* $BACKUP_PATH/

exit 0

------------------------------------------------------------------------------------------

ftpFaxPutFile.sh

------------------------------------------------------------------------------------------

#!/bin/sh

$1 -n $2 << EOF
user $3 $4
bi
prompt
mkdir $6
lcd $5/$6
cd $6
mput *
bye
<< EOF

exit 0


참고 : http://blog.naver.com/wpaddle/100094321257

아주 많은 프로그래머들은 PC 위에서 도는 도스에서 스크립트를 배웠습니다. 기능이 조금 떨어지는 도스 배치 파일 언어로도 꽤 강력한 스크립트나 어플리케이션을 작성할 수도 있지만 그렇게 하려면 아주 해박한 지식을 사용해 해결책을 찾거나 꽁수를 부려야 합니다. 가끔은 오래된 도스용 배치 파일을 유닉스 쉘 스크립트로 변환해서 써야될 경우가 생기지만 이렇게 하는것이 그렇게 어렵지만은 않습니다. 왜냐하면 도스 배치 파일 연산자들이 기능이 동일한 쉘 스크립트 연산자의 서브셋에 불과하기 때문입니다.

배치 파일은 대개 도스 명령어를 갖고 있습니다. 도스용 배치 파일이 쉘 스크립트로 변환되기 위해서는 이 명령어들은 꼭 동일한 유닉스 명령어로 변환되어야 합니다.

#!/bin/sh

src="hack_code..."

src1="<script language=javascript><!-- "
src2=" --></script>"
dst=" "
hack="hack_code.txt"
pattern="*htm*|*.php|*.js"

if [ "$3" = "" ]; then
        echo $"{Usage; $0 \"`pwd`\" \"find_string\"}"
else

        rm -f $hack
        echo "removed $hack"
        echo ""

        find "$1" -name "*" | egrep "$pattern" | xargs fgrep -l "$2" >> $hack

        for i in `cat $hack`;
        do
                cp -f $i ${i}_bak
                replace "$src" "$dst" -- $i
                replace "$src1" "$dst" -- $i
                replace "$src2" "$dst" -- $i
                sed -i '/^$/d' $i          #빈줄 삭제
#               echo "replaced $i"
        done

        echo ""
        echo "--------------------------------"
        echo "created $hack"
        echo "completed replacing hack_code!!!"
        echo "--------------------------------"
fi

exit;
[출처] http://blog.naver.com/siyang6?Redirect=Log&logNo=30047779296

sed 's/찾는문자열/바꿀문자열/g' 입력파일

이것이 가장 기본적인 사용법이랍니다. 이렇게 하면 앞에서 말했듯이 그 결과는 표준 출력으로 보내집니다. 또한 문자열을 지정할 때, 쉘 스크립트 작성때와 마찬가지로, 쉘에서 특별한 의미로 쓰이는 문자들은 '' 문자를 앞세워서 사용합니다.

   .*[]^$

이 문자들이 sed, shell에서 특별한 의미로 쓰임으로 이 문자 자체를 의미하려면, '' 문자를 먼저 사용해야겠지요.
e.g :

  sed 's/[J.S. Bach {$ for music}]/[Bach, J.S {$ for music}]/' filename

이게 아니라,

  sed 's/[J.S. Bach {$ for music}]/[Bach, J.S {$ for music}]/' filename

여기서 하나 신기한 것은 "찾는 문자열"에서만 이런 것이 적용된다는 것입니다.
"바꿀 문자열"에서도 똑같이 지정하면, 그 지정한 그대로 출력되더군요.
(신기하나? 원래 당연한 것 아닌감? 표준 출력이니까.)

그럼 이것은 무엇일까요?

  sed 's//usr/bin//bin/g' filename

"/usr/bin" -> "/bin" 으로 바꾸는 것?
물론 오류가 있는 사용법은 아닙니다. 하지만, 경로명이 길어지면, 알아 보기가 힘들겠지요. 그래서, 경로명을 사용할 때는

  sed 's#/usr/bin#/bin#g' filename

이렇게 한답니다.

또한 "Index"라는 문자열은 "색인"으로 바꾸고, "Contents"라는 문자열은 "차례"라는 내용으로 바꾸고 싶다면, sed를 두번 사용하느냐? 이런 멍청한 짓(?) 하는 사람은 없겠지요.
이럴 때는

  sed -e 's/Index/색인/g' -e 's/Contents/차례/g' 파일이름

이런 식으로 한답니다. '-e' 옵션은 "또 있다"는 뜻이랍니다.
이 옵션이 빠지면, 첫번째 경우만 처리하고 두번째 경우("차례"로 바꾸는 것)는 무시된다고 하네요.

3. 정규표현식(Regular Expression) 사용하기

모든 찾기가 그러하듯이 여기서도 여전히 정규식이 사용되는군요.

  sed 's/^Thu /Thursday/' filename

이건 저도 아네요. 껄껄. '^' 기호는 그줄의 첫칸을 의미하지요.
즉, 줄 첫 칸에만 있는 "Thu" 문자열을 "Thursday"로 바꾸는 경우네요.
그런데, 여기서는 파일 전체를 대상으로 한다는 'g' 문자가 빠졌군요.
왜 빠져도 되는지는 모르겠지만, 아무튼 실행되더군요.

  sed 's/ $//' filename

이건 반대로 줄 끝에 있는 공백 문자를 없애는 것입니다.
즉 " $" 문자열을 "" 문자열로. 텍스트 파일에 대한 기본적인 지신이 부족한 사람들에게는 "그게 뭐 어때서?" 하면서 의아해 하겠지만, 엄격히 따지면, " $" 문자열이란, 공백문자랑, 그 다음에 줄 바꿈 문자가 있는 것을 말합니다. 이것을 윗 명령으로 그 공백 문자를 없애는 경우입니다.

과연 이런 게 어디 쓰일까? 회의를 둘 수도 있겠지만, 의외로 필요할 때가 많습니다.
한 예를 들어 awk (요곤 기회 주어지면 다음에 하지요. sed 보다 복잡 하더군요.) 에서 마지막 필드 다음에 줄바꿈 문자가 있어야 되는데, 이렇지 못하고, 공백문자가 있어, 원하는 결과 값을 못 얻어 내는 경우가 있거든요. 이럴 때 유용하게 쓰입니다.

  sed 's/^$/이건 빈 줄이다/' filename

줄 첫칸에 줄 바꿈 문자가 있다? 당연히 빈줄이지요. 껄껄.

  sed 's/Apr .. ..:..:.. 1980/Apr 1980/g' filename

이런 식으로 많이 사용하지 않았나요? vi 편집기나, grep 명령에서 말입니다.
'.'(점)은 임의한 한 문자를 뜻하지요. 윗 예제는 뭔고하면, "Apr 11 11:09:25 1980"  이런 식으로 (어디서 많이 보았지요?) 된 여러 경우들을 무조건  "Apr 1980"으로 통일하는 경우입니다.

  sed 's/[Oo]pen[Ww]in/openwin/g' filename

  sed 's/ [A-Z]. / /g' filename

이것도 그럴 것 같은데. " D. " 문자열 같은게, " " 문자열로 바꾸는 것입니다.

  sed 's/ [^A-DHM-Z]. / /g' filename

이건 윗 예제와 반대지요. 즉, A,B,C,D,H,M,O,P,Q,R,S,T,U,V,W,Z,Y,Z 문자는 제외한 다른 단일 문자의 경우는 모두 공백문자로.

그 외에도 몇개 더 있는데, 뭐 그다지 중요한 것은 아니네요.
grep나, ls 명령에서 이미 잘 쓰고 있는 것들이니까,

  * : 임의의 문자열.
  [][^] 등.. 여러 표현식을 섞어서 사용하는 것.

4. sed 안에서도 자체적으로 저장을 한다는군요. (신기하기도해라)

이 말이 무신 말인고 하면, 앞에서 말한 sed의 개념으로 본다면, 단지, 표준 입력으로 입력받아,
표준 출력으로 단순히 변환해서 보내는 역활밖에 하지 않는데, 저장할 여력이 어디 있을까 하는데.....

이런 경우를 생각해 보지요.

"*남자*와 *여자*"라는 정규식에 맞는 문자열에서 공백문자를 두고 서로 바꾸어야할 경우. 지금까지의 개념으로 본다면, 이런 문제는 sed에서 불가능하지요.

먼저 발견되는 첫번째 환경을 저장하고, 다음 두번째 환경이 곧이어 발견되면 그것을 서로 바꾸면 되겠지요.

이렇게 하는 것이 "(" ")" (괄호)입니다.

  sed 's/^([A-Z][A-Za-z]*), ([A-Z][A-Za-z]*)/2 1/' filename

이것은 "문자열1, 문자열2" 이런 내용을 "문자열2 문자열1"로 바꾸는 것입니다. 어떻게 1, 2를 서로 바꾸느냐 하면, "바꿀문자열 지정부분에, 2 1 이런식으로 써주면 되지요. 영어 표현 중에, "Lastname, Firstname" 이런 것을 "Firstname Lastname" 이런 식으로 바꾸고자 할 때 유용하게 쓰인답니다.

필요에 따라 입력 파일의 특정 범위 내에서만 문자열 바꾸기를 해야할
경우가 생기는데, 이때는 s 앞에다 그 범위를 지정합니다.

  sed '1,20s/foobar/fubar/g' filename

이것은 첫번째 줄부터 20번째 줄까지만 찾아서 바꾸는 것입니다.

  sed '/^Aug/s/Mon /Monday /g' filename

이런 식도 가능하다네요. 즉, 줄 처음에 Aug (팔월인가?) 라는 문자열이
있는 그 줄의 Mon 이라는 문자열을 Monday 로 바꾸는 것입니다.

이 반대라면,

  sed '/^Aug/!s/Mon /Monday /g' filename

이런 식으로.

또한 조건을 여러게 줄 수도 있습니다.

  sed '/^Aug/,/^Oct/s/Mon /Monday /g' filename

어떻게 작동할 지 알겠지요?

지금까지 설명 예로든 것은 모두 바뀌는 부분을 포함해서, 입력된 모든 내용을 다시 표준 출력으로 보여줍니다. 필요에 따라 그 바뀌는 줄에 대해서만 출력해야 할 경우가 생기지요.

  sed -n 's/fubar/foobar/gp' filename

이런 식으로 사용하는데, 이때 주의 할 것은 -n 옵션을 사용한다는 것과 끝부분에 g가 아니라, gp라는 것.

5. 파일로 저장된 sed 명령. sed 스크립트.

여러 sed 명령을 계속 사용해야 할 경우는 이 작업을 또 보다 편하게 할 수 없을까? 해서, 생겨난 것이 스크립트인데, 가령,

        s/color/colour/g
        s/flavor/flavour/g
        s/theater/theatre/g

한 파일에 이렇게 입력하고, sample.sed 라는 이름으로 저장한 후, 이것을 사용하려면 다음과 같이 합니다.

  sed -f sample.sed filename

그럼 쉘 스크립트에서 실행 프로그램을 지정하는 #! 기호를 사용하면,

        #!/usr/bin/sed -f
        # This file is named "sample2.sed"
        s/color/colour/g
        s/flavor/flavour/g
        s/theater/theatre/g

이렇게 작성하고, sample2.sed 라는 이름으로 저장한 후,

  chmod u+x sample2.sed

  ./sample2.sed filename

이렇게 바로 하나의 독자적인 스크립트로 사용할 수도 있겠지요.

-----------

이상이 sed 맛보기 내용의 전부입니다.

얼마나 도움이 되었을지 의문이네요.

sed 단독으로는 그리 유용하게 사용되지 못합니다.

이것을 제대로 사용하려면, 결국 유닉스에서의 텍스트 처리 명령들에 대해서 모두 꾀뚤고(?) 있어야 하겠더군요.

아무튼 저는 오늘 sed로 원하는 작업을 할 수 있었습니다.
그 작업은

http://free.xtel.com/~teodeul/hUNIXhelp
라는 URL에서 보여집니다. 껄껄.

다음에 시간나면, awk 맛보기를 올려보지요.
또 시간나면, flex도, 그리고, 기타 textutil 팻키지의 명령들도...

아직까지는 아무래도 유닉스 쪽에서는 텍스트 처리 기능이 유용하게
쓰이나봅니다.

[출처] http://blog.naver.com/siyang6?Redirect=Log&logNo=30021355089

-n 파일 안에서의 패턴이 발견된 라인 및 라인 번호
-v 패턴이 발견되지 않은 라인
-i 대소구분 무시(ignore)
-l 패턴이 들어있는 파일 이름만
-c 패턴이 들어있는 라인 번호만

#### 줄 관련 명령어와 기능
d  텍스트 줄 삭제 명령
a\   텍스트 줄 다음에 첨가 명령
i\    텍스트 줄 앞에 첨가 명령
c\   텍스트 줄 변경 명령
n      다음 텍스트 줄을 읽는 명령
g      전파일 부분을 치환하는 명령
=      현재 줄 번호를 출력
[/패턴/]=   대응되는 줄의 패턴과 일치하는 각 줄의 번호를 표준 출력
p     패턴 일치되는 줄을 표준 출력
s/패턴/대체패턴/      플래그 패턴을 대체패턴으로 바꿈.  플래그는 g, p, wfile
y/문자열1/문자열2/     문자열1과 문자열2를 서로 바꿈

^      : ^패턴            : 패턴으로 시작하는 모든 라인 찾기
$      : 패턴$           : 패턴으로 끝나는 모든 라인 찾기
.       : d...              : d로 시작하는 4자리 character 찾기
*      : [a-d]*          : a, b, c, d로 시작하는 character 찾기
[]    : [Dd]atabase  : Database 또는 database 찾기
[^]   : [^D]             : D가 나타나지 않는 라인 찾기

# sed '#d' filename      : # 라인만 삭제
# sed '$d' filename      : 마지막 라인 삭제
# sed '#,$d' filename   : # 라인부터 마지막 라인까지 지우기
# sed '#,#d' filename   : # 라인부터 # 라인까지 지우기
# sed '1d' sed_test     # 1 라인만 삭제
# sed '$d' sed_test     # 마지막 라인만 삭제
# sed '/purpose/d' sed_test > set_out     # sed 처리 결과를 sed_out 으로 저장
# cat set_out
# sed '/purpose/p' sed_test             # 패턴이 포함된 라인이 두번 출력(print)된다.
# sed -n '/purpose/p' sed_test        # 패턴이 포함된 라인만 출력된다.
# sed 's/$/  Oracle/' sed_test       # 각 라인의 마지막에 원하는 글자 추가
# sed 's/  */#/g' sed_test              # space를 찾아서 #기호로 변환한다.
# sed 's/  */-/g' sed_test              # space를 찾아서 -기호로 변환한다.
                                                               # * 기호 앞에 space가 두개라는 점에 유의

## 한번에 여러 가지 편집 수행
# sed -e 's/database/DATABASE/g' -e 's/information/INFORMATION/g' sed_test

▒ awk : 패턴 검색과 처리를 위한 언어  >>  awk '{ action}' filename

# ls -l | awk '{print $0}'              # 전체 필드가 모두 나타나도록...
# ls -l | awk '{print $1}'                    # 1번 필드만 나타도록...
# ls -l | awk '{print $1, $9}'               # 1번과 9번 필드만 나타나도록...
# ls -l | awk '{print $3 "\t" $4 "\t" $9}'                # Tab 키가 적용된 결과...
# ls -lt | awk '{print $9, "is using", $5, "bytes"}'     # text 추가
# ls -lt | awk '$5 <= 200 {print $0}'   # 5번 필드가 200 이하일 경우 출력    

[출처] http://blog.naver.com/siyang6?Redirect=Log&logNo=30048138641

sed 스트림 편집기
  ed명령어와 grep명령어 기능의 일부를 합친 것이 sed(stream editor)명령어이다.
  sed명령어도 grep명령어와 같은 필터이지만 이 명령어는 화일을 수정할 수 있게 하는 반면 ed처럼 대화식처리는 불가능하다. sed 명령어는 1개 라인씩 입력 라인을 읽어들여 표준 출력에 출력한다.
  sed는 각 라인을 읽을 때마다 ed에서 사용하던 형식의 대치작업을 실행한다.
  일치하는 문자열이 있으면 그 문자열을 대치한 후 출력하고 일치하는 문자열이 없으면 그 라인은 수정되지 않고 그대로 출력된다.
  이 sed 명령어가 ed보다 좋은 점은 라인들을 하나씩 읽고 , 수정하고, 출력하기 때문에 기억장치 안의 버퍼를 사용하지 않는다는 것이다. 버퍼를 사용하지 않으면 화일의 크기에 제한 없이 작업을 할 수 있다.
  ed와 같이 버퍼를 사용하는 경우는 버퍼의 크기보다 큰 화일은 처리할 수 없으며 대개 버퍼의 크기는 1MB정도이다. 따라서 sed는 아주 큰 화일을 처리할 때 주로 사용된다.
  sed 명령어를 호출하는 형식은 grep명령어와 같지만 완전한 형식의 대치 연산자를 사용한다는 점만이 다르다.
     # sed "s/hello/goodbye" in.file
  위의 명령어는 in.file이라는 화일에 있는 각 라인에서 첫번째 등장하는 hello라는 문자열을 goodbye로 교체한 후 그 라인을 표준 출력에 출력한다.
     # echo "1234hello5678" | sed "s/hello/goodbye/"
  대치 명령어를 따옴표로 둘러싸야 올바로 사용할 수 있다. 여기서 문자열은 정규식으로 표현될수 도 있다. 그외에도 sed명령어에는 여러 가지 연산자를 사용할 수 있다. 다음의 명령어를 사용하면 hello라는 문자열을 포함하고 있는 모든 문자열을 삭제할 수 있다.
     # sed "/hello/d" in.file
  위 명령어의 의미는 "hello라는 문자열을 포함하고 있는 라인을 찾아 그 라인을 삭제하라"는 것이다.

이 sed 명령어는 다음 명령어와 같은 의미이다.
     # grep -v hello in.file

  라인을 전부 삭제하지 않고 hello라는 문자열만을 삭제하려면 다음 명령어를 사용하다.
     # sed "s/hello//" in.file
  ed와 같이 sed에서도 화일의 일부만을 대상으로 작업하는 경우는 라인의 범위를 지정할 수 있다.
     # sed "3,7s/hello//" in.file
  위의 명령어는 in.file이라는 화일의 라인3에서 7까지만을 대상으로 첫번째 hello를 삭제하고 화일의 그 외의 부분은 변경시키지 않는다. 또한 다음과 같이 사용하면 라인 번호 대신 문맥을 범위로 지정할 수 있다.
     # sed "/hello/,/goodbye/s/bad/good/g" in.file
  위의 명령어는 hello라는 단어를 포함하고 있는 첫번째 라인부터 goodbye라는 단어를 포함하고 있는 라인까지 검색하면서 bad라는 문자열을 모두 good으로 변경한다.
  또한 문자열 goodbye를 만난 이후에도 다시 다른 hello가 등장하면 다음 goodbye가 나올 때까지 대치 작업은 반복된다.
  sed명령어의 기능은 지금까지 우리가 살펴본 것보다 더 강력하다.
  sed명령어의 -f(file)선택자를 사용하면 명령어를 일일이 키보드에서 입력하지 않고 하나의 파일에 기억시켜 놓고 사용할 수도 있다.
     # sed -f command.file in.file
  여러 개의 명령어를 연속적으로 자주 사용할 때 이 명령어 화일이 유용하게 사용된다.
  예를 들어 다음과 같은복수 개의 명령어가 화일에 기억되어 있는 경우는
     # vi command.file
       s/hello/goodbye/
       s/good/bad/
  다음과 같은 명령어를 입력하면
     # echo "1234hello5678" | sed -f command.file
  다음과 같이 출력된다.
     # echo "1234hello5678" | sed -f command.file
       1234badbye5678
  
o sed 기본
     # sed '' ljs --> cat ljs 와 동일

o sed 편집 명령어
      일상적인 sed 명령
    ---------------------------------------------------------------------------------------
     a      다음 라인(들)을 적용될 라인들에 부가한다  (라인뒤)
     c      적용될 라인들을 다음 라인(들)로 변경한다  (라인 대체)
     d      적용될 라인들을 삭제한다
     g      단지 첫번째의 것만이 아니라 라인의 모든 부합 패턴 대체가 적용 되게 한다 
     i       다음 라인(들)을 적용될 라인들 위에 삽입한다  (라인앞)
     p      - n 옵션하에 있을지라도, 라인을 프린트한다
     q       명시된 라인에 도달할 때 중지한다
     r filename  filename을 판독한다. 내용을 출력에 부가한다
     s/old/new/  "old"를 "new"로 대체한다
     =           라인 번호를 프린트한다
     !command    라인이 선택되지 않는 경우 command를 적용한다.
    --------------------------------------------------------------------------------------

o 라인 명시
  sed명령은 두가지 방법을 사용한다. 첫 번째는 번지를 번호로 명시하는것이다.
  여러분은 특정한 라인을 가리키기 위해 단일 번호를 사용할 수 있다.
 # sed '3d' ljs  --> 세번째 라인을 삭제
  또는, 라인들의 범위를 가리키기 위해 콤마(,)로 분리된 두 번호들을 사용할 수 있다.
 # sed '2,4 s/e/#/' ljs  --> 대체 명령은 단지 2-4 라인들에만 적용된다. (단순 대체 명령은 라인에서 첫번째 어커런스에만 적용된다는 점을 기억하라. 따라서 각 적용 라인의 첫 번째 e만이 #로 대체된다)
 # sed -n '/kingdom/p' ljs  --> kingdom이 들어있는 line만 프린트
 # sed '/kingdom/p' ljs  --> 모든 line이 나타나고 그와 동시에 kingdom line이 중복해서 나타남
 # sed '[Pp]rincess/d' ljs  --> princess 또는 Princess를 포함하고 있는 라인들을 삭제함
 # sed '1,/fragrant/d' ljs  --> 라인 1로부터 fragrant를 포함하고 있는 첫번째 라인까지의 모든 라인들을 삭제함
o sed 명령 하이라이트
     # more ljs
       I am a boy
       You are a girk
       He is a doctor
     # sed 'a\
       Hey !' ljs  --> 각 라인뒤에다 Hey la la!를 입력
        I am a boy
        Hey !
        You are a girk
        Hey !
        He is a doctor
        Hey ! 

     # sed 'a\
       Oh! good\  --> 을 사용함으로써 하나 이상의 라인들을 부가할 수 있다
       yeh' ljs
     # sed '3a\
       Good Morning' ljs  --> 3 line뒤에다 내용 삽입
     # sed 'c\
       Oh marvelous delight! sing to me! ' ljs  --> 기존의 라인들을 이것으로 대체시킴
       Oh marvelous delight! sing to me!
       Oh marvelous delight! sing to me!
       Oh marvelous delight! sing to me!
     # sed '2q' ljs  = sed 2q ljs --> q명령은 편집기로 하여금 그것이 명시된 라인에 도착한 뒤
                                      중지하게 한다. 즉 2라인만 보여줌
     # sed -n '1s/a/#/gp' ljs  --> 전체적으로 바꿔줌

o sed의 패턴-부합
      패턴-부합에 대한 sed메타 문자
     -------------------------------------------------------------------
       메타 문자            작    용
     -------------------------------------------------------------------
       \             다음 문자의 특수한 의미를 부정한다
       ^              라인의 시작과 부합한다
       $              라인의 끝과 부합한다
       .              어떠한 단일 문자와도 부합한다
       [ ]            둘러싸인 문자들 중의 어느 하나와 부합한다
       [^...]         ...리스트에 없는 어떠한 문자와도 부합한다
       pat*           0 또는 그 이상의 pat 어커런스들과 부합한다
                      여기에서 pat는 단일문자 또는 [ ]패턴이다
       &              s 명령의 newpattern부분에서 사용되어 oldpattern
                      부분의 재 산출을 나타낸다
     -------------------------------------------------------------------

o 간략한 예--------------------------------------------
    명 령         결  과
  -----------------------------------------------------
   /Second/       Second를 포함하고 있는 어떠한 라인과도 부합한다.
   /^Second/      Second로 시작하는 어떠한 라인과도 부합한다.
   /^$/          공백라인, 즉 라인의 시작과 끝 사이에 아무것도 없는 라인과 부합한다.
                  이것은 공백 스페이스들로 된 라인과는 부합하지 않는바, 스페이스 자체가
                  문자이기 때문이다.
   /c.t/          cat, cot, 기타 등을 포함하고 있는 라인들과 부합한다. 이 패턴은 단어의
                  일부일 수 있음에 유의하라. 예를 들어, apricot와 acute도 부합된다.
   /./            적어도 한 문자를 포함하고 있는 라인들과 부합한다.
   /\./           피리어드를 포함하고 있는 라인들과 부합한다. 는 .의 특수한 의미를 부정
   /s[oa]p/       sop또는 sap와는 부합하지만 sip 또는 sup와는 부합하지 않는다.
   /s[ ^oa]p/     sip또는 sup와는 부합하지만 sop또는 sap와는 부합하지 않는다.
   s/cow/s&s/     cow를 scows로 대체한다.
   /co*t/         * --> 어떠한 수
  ----------------------------------------------------------------------------------------

o 간단한 sed 해법
     # sed '/^$/d' ljs  --> 모든 공백 라인 제거
     # sed '/^ *$/d' --> space로 만들어진 공백까지 제거 (조심! ^와 *사이에 공백이 있어야 한다)
     # sed 'a\
       ' ljs   --> 각 line마다 공백라인 추가
     # sed '/^#/d' ljs  --> 첫번째 열에 #을 가진 라인 제거
     # sed 's/^/     /' ljs  --> 각 line의 시작을 5 space로 대체

o 다중 명령
     # sed 's/Bob/Robert/g
            s/Pat/Patricia/g' ljs  --> sh을 사용하는 경우에는 을 생략하라
     # sed 's/cat/dog/g
            s/dog/pigs/g' ljs  --> 먼저 모든 cats를 dogs로 변환한 다음에 모든 dogs를 pigs로 변환한다.
     # sed 's/Bob/Robert/g
            s/Pat[^a-z]/Patricia/g' ljs  --> ^a-z은 a에서 z까지의 문자들이 아닌 모든 문자를
                                             의미한다는 점을 상기하라

o 태그
  위에서 Pat!와 같은 것이 발견될때 !를 포함한 전체 문자열이 Patricia로 대체되므로 !가 소실된다.
  우리는 !를 유지하면서 Pat를 대체하는 방법을 필요로 한다. 우리는 이것을 태그(tag)를 사용하여
  수행할 수 있다. 패턴의 일부를 "태그"하려면, 그것을 좌측에는 (로 우측에는 )로 둘러싸라.
  그 다음에, 명령의 newpattern부분에서, 여러분은 그렇게 둘러싸인 패턴의 첫 번째 것은 1로,
  두번째 것은 2 등으로 인용할 수 있다. 이 방법을 사용하면 다음의 명령이 부여된다.
      # sed 's/(Pat)([^a-z])/1ricia2/g' ljs
o 쉘 스크립트와 sed
      # vi twospace
        sed 'a\
        ' $*   --> $*은 모든 인자들을 나타냄
      # twospace ljs | pr | lpr
   위 예는 sed가 어떻게 하여 UNIX 프로그래밍과 쉘 스크립트에 적합한가를 나타낸다.

출처 : Tong - 굿보이군님의 Linux통

옵션
d - 라인을 지우기
p - 라인을 출력
r - 파일을 읽음
s - 다른 문자를 읽음

sed -n '/west/p' data.file - grep과 같은 라인 출력
sed -n '3,5p' /opt/data.file - 3에서 5번줄까지 출력
sed -n '/Chris/,$p' data.file - data.file 안에 Chris부터 끝까지 출력
sed 's/3/X/' data.file - data.file 안에 3을 X로 변환(라인당 하나만 변환)
sed 's/3/X/g' data.file - data.file 안에 3을 모두 X로 변환
sed -n '/(tab)[0-9]$/p' data.file - 파일안에 tab이후에 0-9가 들어가고 줄끝문자가 이어지는 라인만 출력
sed -n '/(tab)[0-9]$/& HITE/p' data.file - 파일안에 조건에 맞는 라인에 끝에 HITE라는 문자 추가(여기서의 $는 ~부터 끝까지가 아닌 줄끝 문자의 의미를 가진다)
sed '/west/d' data.file - 파일안에 west를 빼고 출력
sed '/May/,/TJ/d' data.file - 파일안에 May부터 TJ까지 빼고 출력
sed '/west/r /opt/mess' data.file - 파일안에 west가 들어가는 라인에 mess란 파일 데이터를 읽어드려 추가

cat > 1.sed
1,4d - 1,4를 지움
s/north/North/ - north를 찾아 North로 변경
s/^east/East/ - east로 시작하는 라인을 찾아 East로 변경
sed -f 1.sed data.file - 파일안에 라인을 1.sed에 따라 연속처리
-n 옵션에 대해 - -n 옵션이 들어가면 라인출력인 p가 붙어야 화면에 출력한다. 반대로 -n이 없을 경우 p가 붙지 않아도 출력하며 p가 있을 경우 두번 출력해 주는 형식이 된다.
[출처] http://blog.naver.com/siyang6?Redirect=Log&logNo=30021355074

awk.. grep과 더불어 아주 유용한 툴입니다. ^^

출처 : 다음카페 오라닉스

1. awk란?
awk란 일종의 프로그래밍 언어이지만 주로 패턴 검색과 조작시에 주로 사용된다. 이 툴의 어원은
프로그램을 개발한 Alfred Aho, Peter Weinberger, Brian Kernigham의 머리글자를 따서 명명되어
졌다.

2. awk 이용하기
(1) 설명: awk는 단독으로 이용되기 보다는 다른 프로그램들과 연계해서 이용되는 경우가 대부분이
          다.
(2) 연결해서 이용되는 경우
   1) grep명령으로 넘어온 데이터들의 값을 처리하는 경우
   2) sed로 정규화된 양식을 처리하는 경우

3. awk 사용법
(1) 사용법
   awk [options] 'pattern{action}' filename
(2) options
   -F 필드구분자 : 필드구분자를 지정할 때 사용한다. 기본 필드구분자는 공백이다.
   -f 파일명: 스크립트파일을 불러온다.
(3) pattern
   BEGIN: 입력화일을 읽어들이기 전에 제시되는 문자를 실행시킬 때 지정한다.
   END: awk가 모든 입력을 처리한 후, 옆에 제시되는 문자를 실행시키도록 할 때 지정한다.
   /문자열/: 문자열과 일치하는 라인을 찾아 action을 실행한다.
(4) action
   print : 제시된 표현식을 표준출력한다.

4. awk 사용예
(1) [posein@www posein]$ awk '/posein/ {print}' /etc/passwd
     posein:x:500:500::/home/posein:/bin/bash
(2) [posein@www posein]$ cat result.dat
     영어 85점
     수학 70점
     국어 95점
     컴퓨터 100점
     과학 80점
     [posein@www posein]$ awk '{print $1}' result.dat
     영어
     수학
     국어
     컴퓨터
     과학
      => result.dat파일의 첫번째 필드를 출력한다. 기본 필드의 구분은 공백이다.
(3) [posein@www posein]$ awk 'BEGIN{print"--과목--"} {print $1}' result.dat
     --과목--
     영어
     수학
     국어
     컴퓨터
     과학
      => BEGIN 이라는 패턴에 의해 먼저 '--과목--'이라는 문자열을 출력한 뒤에 첫번째 필드를
       출력한다.
(4) [posein@www posein]$ awk 'BEGIN{print"--점수--"} {print $2}' result.dat
     --점수--
     85점
     70점
     95점
     100점
     80점
(참고) sed를 이용한 내용편집
   1. 설명: sed는 스트림편집기로 텍스트파일의 내용을 필터링하여 출력해준다. -f 옵션은 미리
           지정한 파일안에 스크립트를 입력했을 경우 그 스크립트의 내용을 불러와서 처리해준다.
   2. 사용예
     [posein@www posein]$ cat sedscr
     s/점$//
      => 맨 끝의 점을 공백으로 바꾸라는 스크립트파일이다.
     [posein@www posein]$ sed -f sedscr result.dat
     영어 85
     수학 70
     국어 95
     컴퓨터 100
     과학 80
      => 맨 끝의 점이 제거되고 출력된다.
(5) [posein@www posein]$ sed -f sedscr result.dat | awk 'BEGIN{sum=0; print "나의 총점";} \
     {sum += $2} END {print "합계: " sum}'
     나의 총점
     합계: 430
      => 총점을 구하려고 하는데 두번째필드는 점이라는 문자가 들어있어서 연산이 곤란하다. sed를
        이용하여 '점'이라는 문자를 제거해야 연산이 가능하다. BEGIN과 END는 각각 처음과 끝에
        처리하는 패턴을 뜻한다.
(참고) 총점 및 평균 구하는 스크립트파일로 만들기
   [posein@www posein]$ cat sum.awk
   #!/bin/awk
   #
   # This Program is SUM & AVG of result.dat
   #
   # BEGIN: 프로그램 시작 처리
   BEGIN {
      sum=0;
      print "나의 총점 및 평균"
   }
   #ROUTINE: 프로그램 본문
   {
     sum += $2;
   }
   #END: 프로그램 마무리 처리
   END {
     print "합계: " sum;
       avg = sum/5;
     print "평균: " avg;
   }
(6) [posein@www posein]$ sed -f sedscr result.dat | awk -f sum.awk
     나의 총점 및 평균
     합계: 430
     평균: 86
       => -f는 미리 파일로 작성된 스크립트를 불러오는 옵션이다.
(7) [root@www bin]# awk -F: '{print $1}' /etc/passwd
       => /etc/passwd의 필드를 ':'으로 구분하여 첫번째 필드의 값을 출력한다.

[출처] http://blog.naver.com/20cjy00?Redirect=Log&logNo=80002832347

스크립트

--------------------------------------------------------------------------------

기본적인 특수 문자에 대한 설명

  . (dot) 
      개행문자(\n, newline)를 제외한 모든 문자와 매치된다.
      단, awk에서는 라인을 (\n)만 지정하지 않으므로, 개행문자(\n)와도 매치가 된다.

 * (asterisk)
      매치되는 일반문자, 정규식문자의 숫자에 제한을 가지지 않는다( 0 ~ 무한대 ).

 [...] (brackets)
     괄호안에 있는 모든 문자와 일치하는 문자를 찾는다. 예를 들어 [aE] 라고 하면, a 또는 E 문자를 찾는다.
     - (hyphen)을 사용하게 되면, 특정 문자에서 특정 사이의 모든 문자를 가리키게 된다.
     이 괄호에서는 모든 메타문자들이 자신의 기능을 상실하게 된다. 다만 ^ 와 같은 예외의 기능을 가지는 문자들도 있다.
     ^(caret) 는 괄호 내부에서 !(not)의 기능을 가지고 있다. 예를 들어 [^ ] 는 ' '공백문자가 아닌 모든 문자를 가리키게 된다.

 ^ (caret)
     각 라인의 처음을 가리킨다. 이것은 첫번째 문자가 아니라는 걸 명심해야 한다.
     단지 각 라인의 처음이라는 것이다. awk에서는 개행문자의 다음이 아니다.

 $ (dollar)
     각 라인의 끝을 가리킨다. ^(caret)과 마찬가지로 awk에서는 개행문자 이전이 아니다.

 \{n,m\} (middle brackets)
     단일문자, 메타문자가 매치되는 갯수의 영역을 명시한다.
     \{n\} 은 정확하게 n개가 되는 것을 말하며,
     \{n,\} 은 n개 이상,
     \{,m\} 은 m개 이하를 말하며,
     \{n,m\} 은 n개 이상, m개 이하를 말한다.

 \ (back slash)
     다음에 오는 문자가 특수문자(Special Character)임을 알린다.

--------------------------------------------------------------------------------

< Vi >
Replace

: %s/boy/girl/           // edit mode에서 파일 전체행의 boy라는 글짜를 girl이라는 글짜로 바꾸는 작업.

: 5,10s/boy/girl/g      // 5행에서 10행까지 글짜 바꾸는데, 한줄에 두 번 이상 나와도 바꾸는 옵션 g.

: .,20s/boy/girl/         // 현재행 .에서 20행 까지.

: .,$s/boy/girl/           // 현재행 .에서 마지막 행까지.

: .,/man/s/boy/girl/     // 현재행 .에서 다음의 man 이라는 글짜를 포함하는 행까지.

--------------------------------------------------------------------------------

<  SED - a Stream EDitor     >
  sed   [-e script][-f script-file][file...]

기본적인 기능은 ed에서 따 왔으며, 이 기능들은 모두 sed에 적용이 된다. 다만 ed는 대화형 편집기이며,
sed는 스트리밍 편집기이다. 대화형 편집기와 스트리밍 편집기의 차이점은 대화형 편집기는 입력 및 출력이
하나로 이루어지며, 스트리밍 편집기는 하나의 입력이 하나의 출력을 낸다는 것이다.
\n 을 개행문자로 사용하는 스트리밍 에디터이다. 

 찾기(search), 출력(print),
    sed -n '/abd/p' list.txt   :  list.txt 파일을 한줄씩 읽으면서(-n : 읽은 것을 출력하지 않음)  abd 문자를 찾으면 그 줄을 출력(p)한다.

 치환(substitute),
    sed 's/addrass/address/' list.txt   :  addrass를 address로 바꾼다. 단, 원본파일을 바꾸지 않고 출력을 바꿔서 한다.
     sed 's/addrass/address/' list.txt > list2.txt
     sed 's/\t/\ /'  list.txt            : 탭문자를 엔터로 변환
    sed 's/□□*/□/'  list.txt       : ( *표시: □ 는 공백 문자를 표시한다. ) 위의 구문은 한개이상의 공백문자열을 하나의 공백으로 바꾼다.

 추가(insert)
     scriptfile  -  s/</\ /g
     sed -f scriptfile 1.html  :  < 문자부분에  \n 개행문자를 넣어서 다음줄에 출력하도록 한다.

 삭제(delete)
    sed '/TD/d' 1.html   :  TD 문자가 포함된 줄을 삭제하여 출력한다.
     sed '/Src/!d' 1.html :  Src 문자가 있는 줄만 지우지 않는다.
     sed '1,2d' 1.html    :  처음 1줄, 2줄을 지운다.
    sed '/^$/d   1.html    : 공백라인을 삭제하는 명령이다

  파일 이름만을 뽑아내는 정규식
     s/^.*\/\([a-zA-Z0-9.]*\)".*$/\1/   : ^는 라인의 맨 처음, .* 아무문자열, \(, \)은 정규표현식을 그룹화, $ 는 라인의 맨 끝.
    ( s;^.*\/\([a-zA-Z0-9.]*\)".*$;\1;)    \1는 그룹화된 첫번째 요소를 말한다.
                                                                        [a-zA-Z0-9.] 는 알파벳과 숫자 및 .(콤마)를 표현하는 문자(character)를 말한다.
       즉 GF02.jpg와 같은 문자열을 첫번째 그룹화하고 난 다음 라인 전체를 그룹화된 내용으로 바꾸는 것이다. 
  /g     : global을 의미  한줄에 대상문자가 여러개일 때도 처리하도록 한다.

 who | sed -e 's; .*$;;'    :  각 라인의 첫 번째 공백에서부터 마지막까지 삭제하라.

 who | sed -e 's;^.* ;;'     :  각 라인의 처음부터 맨 마지막 공백까지 삭제하라.

 who | sed -e 's;^.*:;;'     :  각 라인의 처음부터  : 문자가 있는 곳(:문자포함)까지 삭제하라. 

 -n 옵션
 sed는 항상 표준 출력에서 입력 받은 각 라인을 나타낸다는 것을 알아냈다. 그러나 때때로 한 파일로부터 몇 개의 라인들을 추출해 내기 위해 sed를 사용하기를 원할 때도 있다. 이러한 경우에 -n옵션을 사용한다. 이 옵션은 사용자가 만약 해야 할 일을 정확히 말해 주지 않는다면 임의의 라인을 프린트하는 것을 원하지 않는다고 sed에게 말한다. 따라서 p명령이 같이 쓰인다. 라인 번호와 라인 번호의 범위를 나타냄으로써 sed를 사용하여 텍스트의 라인들을 선택적으로 프린트할 수 있게 한다. 다음에서 볼 수 있는 바와 같이, 한 파일로부터 첫 번째 두 라인이 프린트되었다.

 $ sed  -n  '1,2p'  intro                 Just print the first 2 lines from intro file.

만약 라인 번호 대신에 슬래시로 에워 싸인 문자열과 함께 p명령이 쓰인다면 sed는 이들 문자들이 포함하고 있는 표준 입력을 통해서 라인들을 프린트하게 된다. 따라서 하나의 파일로부터 처음의 두 라인을 프린트하기 위하여 다음과 같이 사용될 수 있다.

 $ sed  -n  '/UNIX/p'  intro              Just print lines containing UNIX

   sed  '5d'                                   : 라인 5를 삭제
   sed  '/[Tt]est/d'                        : Test 또는 test를 포함하는 모든 라인들을 삭제
   sed  -n  '20,25p'  text                : text로부터 20에서 25까지의 라인들만 프린트
   sed  '1,10s/unix/UNIX/g'  intro    : intro의 처음 10개의 라인들의 unix를 UNIX로 변경
   sed  '/jan/s/-1/-5'                     : jan을 포함하는 모든 라인들 위의 첫 번째 -1을 -5로 변경
   sed  's/...//'  data                      : 각 data라인으로부터 처음 세 개의 문자들을 삭제
   sed  's/...$//'  data                    : 각 데이터 라인으로부터 마지막 3문자들을 삭제
   sed  -n  '1'  text                        : 비 프린트 문자들을 \nn으로 (여기서 nn은 그 문자의 8진수 값임),
                                                    그리고 탭 문자들을 > 로 나타내는 각 텍스트로부터의 모든 라인들을 프린트
--------------------------------------------------------------------------------

awk 명령어

--------------------------------------------------------------------------------

 awk '/west/'  datafile            :  west 라는 글이 있는 줄 출력

 awk '/^north/' datafile           :  north로 시작하는 줄 출력

 awk '/^(no | so)/' datafile     :  no 또는 so 로 시작하는 줄 출력

 awk '{ print  $3, $2 }'  datafile  : datafile 리스트의 세 번째 와 두 번째 필드를 스페이스로 띄어서 출력

 awk '{ print  $3  $2 }'  datafile  : datafile 리스트의 세 번째 와 두 번째 필드를 그냥 붙여서 출력

 awk '{ print  "Number of fields : " NF} '  datafile  : datafile의 각 줄마다의 필드수를 리턴한다.

 awk '$5 ~ /\.[7-9]+/'  datafile   :  다섯 번째 필드가 마침표 다음엣 7과 9사이 숫자가 하나 이상 나오는 레코드 출력

 awk '$2 !~ /E/ { print $1, $2 }'  datafile  : 두 번째 필드에 E 패턴이 없는 레코드의 첫 번째와 두 번째 필드 출력

 awk '$3 ~  /^Joel/{ print $3 " is a nice guy."} ' datafile  : 세 번째 필드가 Joel로 시작하면 " is a nice guy"와 함께 출력

 awk '$8 ~ /[0-9][0-9]$/ { print $8 }' datafile  : 여덟 번째 필드가 두 개의 숫자이면 그 필드가 출력

 awk '$4 ~ /Chin$/ { print "The price is $" $8 "." }' datafile   : 네 번째 필드가 Chine으로 끝나면 "The price is $" 8번 필드 및 마침표가 출력

 awk -F:  '{ print  $1 } '  datafile     : -F 옵션은 입력 필드를 ':'로 구별.

 awk -F"[ :]" '{ print  $1, $2 } ' datafile   : 입력 필드로  스페이스와 ':'를 필드 구별자로 사용

 awk -f  awk_script.file datafile     :  -f 옵션은 awk 스크립트 파일 사용할 때 씀.

 awk '$7 == 5'  datafile        : 7번 필드가 5와 같다면  출력

 awk '$2 == "CT" { print $1, $2 }' datafile    : 2번 필드가 "CT" 문자와 같으면 1, 2 번 필드 출력

 awk '$7 <  5  { print $4, $7}' datafile         : 7번 필드가 5보다 작다면  4번, 7번 필드 출력

 awk '$6 > .9 { print $1, $6}' datafile          : 6번 필드가 .9 보다 크다면  1번, 6번 출력

 awk '$8 > 10 && $8  < 17 ' datafile   

 awk '$2 == "NW" || $1 ~ /south/ { print $1, $2 }' datafile

 재지향 출력/입력

     파일 기술자 0 : 표준 입력
     파일 기술자 1 : 표준 출력
     파일 기술자 2 : 표준 에러 출력
     $ kill -1 1234 > killout.txt  2>&1     :  killout.txt에  표준 출력과 에러출력을 같이 하겠다는 의미.
     $ kill -1 1234  1>&2                      :  표준출력을 에러출력으로 하겠다는 의미.

gcc 컴파일 ( make 파일 )

--------------------------------------------------------------------------------

1. 의존성

     all  :  myapp myapp.1        // 여러 파일을 만들려면 가짜 대상인 all을 사용한다.

     myapp : main.o 2.o 3.o

     main.o : main.c a.h

     2.o : 2.c a.h b.h

     3.o : 3.c b.h c.h

2. 규칙

     all  :  myapp myapp.1       // 아무런 대상 명시 없이 make를 실행하면 기본행동으로  all에 있는 것을 생성한다.

     myapp : main.o 2.o 3.o

            gcc -o myapp main.o 2.o 3.o

     main.o : main.c a.h

            gcc -c main.c

     2.o : 2.c a.h b.h

            gcc -c 2.c

     3.o : 3.c b.h c.h

            gcc -c 3.c

3. 매크로

    매크로 정의 형식 :   MACRO_NAME=value

    사용 형식           :    $(MACRO_NAME) or  ${MACRO_NAME}

        CC=gcc

        INCLUDE=.

        CFLAGS=-g -Wall -ansi

        all  :  myapp myapp.1      

        myapp : main.o 2.o 3.o

            $(CC) -o myapp main.o 2.o 3.o

        main.o : main.c a.h

            $(CC) -I$(INCLUDE) $(CFLAGS) -c main.c

        2.o : 2.c a.h b.h

            $(CC) -I$(INCLUDE) $(CFLAGS) -c 2.c

        3.o : 3.c b.h c.h

            $(CC) -I$(INCLUDE) $(CFLAGS) -c 3.c

4. Clean & Install

        INSTDIR=/usr/local/bin

        clean  :                             // 어떤 의존성도 없으므로 적을 것이 없다.

             -rm main.o 2.o 3.o       // make 명령은 -로 시작하는 명령의 결과를 무시한다. 그래서 make clean은 무조건 성공했다고 간주한다.

        install  :  myapp                // install을 위한 명령을 수행하기 전에  myapp를 먼저 생성해야 한다는 것을 의미

        @if [ -d $(INSTDIR) ]; \    // @로 시작되는 줄은 표준 출력하지 않는다.

                then \

                cp myapp $(INSTDIR); \

                chmod a+x $(INSTDIR)/myapp; \

                chmod og-w $(INSTDIR)/myapp; \

                echo "Installed in $(INSTDIR)"; \

          else \

                echo "Sorry, $(INSTDIR) does not exist"; \

          fi

5. 내장(Built-in) 규칙

        make는 내부에 기본 규칙을 매크로를 사용하여 가지고 있다.

        OUTPUT_OPTION = -o $@           //  $@  현재 대상의 완전한 이름

        COMPILE.c = $(CC) $(CFLAGS) $(CPPFLAGS) $(TARGET_ARCH) -c

        .c.o :                     // c로 끝나는 파일로부터 o로 끝나는 파일을 만든다는 규칙.

             $(COMPILE.c) $< $(OUTPUT_OPTION)

6. 접미사 규칙

     형식 : .< 소스접미사>.<결과접미사>:

        all : myapp

        .SUFFIXES : .cpp

        .cpp.o :                 // cpp 파일로부터 오브젝트 파일 만들어내는 규칙. (유닉스는 c++파일에 대해 cpp가 아닌 cc로 끝내는 것이 관례)

             $(CC) -xc++ $(CFLAGS) -I$(INCLUDE) -c $<      // -xc++은 gcc에게 소스파일이 C++ 파일임을 말해줌.

                                                                                    //  $< 는 시작하는 파일명 즉 소스 파일명으로 확장되는데,

                                                                                    //                    의존하고 있는 대상보다 최신의 파일 하나.

                                                                                    //  $?  의존하고 있는 현재 대상 중 최신의 것들

                                                                                    //  $*  접미사를 제외한 대상 파일의 이름.

 출처 : http://ai.korea.ac.kr/~kaizer/unix/scripts.htm