Man page  — FLEX

    해설
        툴의 짧은 개요

    간단한 예

    입력 파일의 포맷

    패턴
        flex 가 사용하는 확장한 정규 표현

    입력의 매치 방법
        무엇이 매치 할까를 결정하는 규칙

    액션
        패턴이 매치 했을 때에 무엇을 실시하는지를 지정하는 방법

    생성된 스캐너
        flex 가 생성하는 스캐너에 관한 상세;
        입력원의 제어 방법

    개시 조건
        스캐너에의 문맥의 도입과
        "미니 스캐너" 의 제어 방법

    복수의 입력 버퍼
        복수의 입력원을 취급하는 방법;
        파일은 아니고 캐릭터 라인으로부터 스캔 하는 방법

    파일의 끝의 룰
        파일의 끝나에 매치 하는 특별한 룰

    잡다한 매크로
        액션으로 사용 가능한 매크로의 통계

    유저가 사용 가능한 값
        액션으로 사용 가능한 값의 통계

    Yacc 와의 인터페이스
        lex 스캐너와 yacc 파서와의 결합

    옵션
        flex 의 명령행 옵션과
        "%option" 지시문

    성능 관련
        스캐너를 가능한 한 고속으로 하는 방법

    C++ 스캐너의 생성
        C++ 스캐너 클래스 생성을 위한
        (실험적인) 기능

    Lex 및 POSIX 와의 비호환성
        AT&T lex 및 POSIX lex 표준과
        flex 와의 달라

    진단
        flex (혹은 생성한 스캐너)가 출력한다
        에러 메세지로 의미가 명확하지 않은 걸

    관련 파일
        flex 가 사용하는 파일

    결함 / 버그
        flex 의 기존의 문제

    관련 항목
        툴에 관계하는 다른 문서

    저자
        연락 방법을 포함합니다

    %%
    username    printf( "%s", getlogin() );

다른 예를 보고 봅시다:

    %{
            int num_lines = 0, num_chars = 0;
    %}

    %%
          ++num_lines; ++num_chars;
    .        ++num_chars;

    %%
    main()
            {
            yylex();
            printf( "# of lines = %d, # of chars = %d ,
                    num_lines, num_chars );
            }

다음은 좀 더 복잡한 예입니다:

    /* scanner for a toy Pascal-like language */

    %{
    /* need this for the call to atof() below */
    #include <math.h>
    %}

    DIGIT    [0-9]
    ID       [a-z][a-z0-9]*

    %%

    {DIGIT}+    {
                printf( "An integer: %s (%d)  , yytext,
                        atoi( yytext ) );
                }

    {DIGIT}+". "{DIGIT}*        {
                printf( "A float: %s (%g)  , yytext,
                        atof( yytext ) );
                }

    if|then|begin|end|procedure|function        {
                printf( "A keyword: %s , yytext );
                }

    {ID}        printf( "An identifier: %s , yytext );

    "+"|"-"|"*"|"/"   printf( "An operator: %s , yytext );

    "{"[^} *"}"     /* eat up one-line comments */

    [ \t +          /* eat up whitespace */

    .            printf( "Unrecognized character: %s , yytext );

    %%

    main( argc, argv )
    int argc;
    char **argv;
        {
        ++argv, --argc;  /* skip over program name */
        if ( argc > 0 )
                yyin = fopen( argv[0], "r" );
        else
                yyin = stdin;

        yylex();
        }

이 예의 자세한 것은, 이후시에로 설명합니다.

    정의
    %%
    룰
    %%
    유저 코드

이름의 정의는 다음의 형식입니다:

    이름 정의

    DIGIT    [0-9]
    ID       [a-z][a-z0-9]*

    {DIGIT}+". "{DIGIT}*

    ([0-9])+". "([0-9])*

flex 의 입력의 룰 (은)는 다음의 형식의 일련의 룰로부터 됩니다:

    패턴   액션

패턴과 액션의 자세한 것은 후의 해설을 봐 주세요.

마지막으로, 유저 코드의 부분은 단순하게 그대로의 형태로 lex.yy.c 에 카피됩니다. 스캐너를 호출하는 또는 불려 가는 부수 routine를 위해서(때문에) 사용됩니다. 이 부분은 있어도 없어도 상관하지 않습니다; 없는 경우에는, 입력 파일중의 2 번째의 %% 도 생략 할 수 있습니다.

정의와 룰의 부분에서는, 인덴트 되었다 텍스트와 %{ (와)과 %} (와)과의 사이의 텍스트는 그대로의 형태로 출력에 카피됩니다 (이 때 %{} 는 삭제됩니다). %{} 는 인덴트되어 있지 않은 행에 나타날 필요가 있습니다.

룰의 부분에서는, 최초의 룰의 전에 나타나는 인덴트 된 혹은 %{} 부분의 텍스트는, 스캔 routine에 로컬인 변수와 (선언의 후에는) 스캔 routine에 들어갈 때마다 실행되는 코드를 선언합니다. 룰 부분의 다른 인덴트 된 혹은 %{} 부분의 텍스트는 출력에 카피됩니다만, 의미는 분명하게 정의되지 않고 컴파일시에 에러가 될지도 모릅니다 (이 사양은 POSIX 호환을 위해서(때문에) 있습니다; 다른 이러한 사양은 이후를 봐 주세요).

정의의 부분(룰의 부분은 아닙니다)에서는, 인덴트되어 있지 않은 코멘트("/*" 로부터 시작되는 행)는 다음의 것 "*/" 까지 그대로의 형태로 카피됩니다.

    x          캐릭터 'x'에 매치.
    .           개행을 제외한 모든 캐릭터(바이트).
    [xyz]      "캐릭터 클래스"; 이 경우, 'x', 'y', 'z'의 어느 것에도
                 매치 합니다.
    [abj-oZ]   범위 지정을 포함한 "캐릭터 클래스"; 이 경우, 'a', 'b'와
                 'j'로부터 'o'까지의 임의의 레터와 'Z'에 매치 합니다.
    [^A-Z]     "부정문자 클래스"; 클래스에 포함되지 않는 임의의 캐릭터에
                 매치 합니다.  이 경우, 'A'로부터 'Z'까지의 대문자
                 「이외의」캐릭터에 매치 합니다.
    [^A-Z    대문자와 개행을 「제외하다」모든 캐릭터.
    r*         0 혹은 그 이상의 r. r 는 임의의 정규 표현.
    r+         1 혹은 그 이상의 r.
    r?          0 혹은 1개의 r ( 「덤」의 r)
    r{2,5}     2 개(살)에서 5개까지의 r.
    r{2,}      2 개(살) 이상의 r.
    r{4}       정확히 4개의 r.
    {이름}     "이름" 의 정의의 전개.
               (위를 참조)
    "[xyz]\"foo"
               캐릭터 라인 [xyz]"foo
    \X         X 가 'a', 'b', 'f', 'n', 'r', 't', 'v'의 몇개의
                 (이)라고 해 ANSI-C 에서의 \X 의 해석이 됩니다.
                 그 이외의 경우, 캐릭터 'X' ('*'와 같은 오퍼레이터의
                 의미를 지워, 그 캐릭터 자체를 지정할 때에 사용합니다).
    \123       8 진수로 123 으로 나타내지는 캐릭터.
    \x2a       16 진수로 2a 로 나타내지는 캐릭터.
    (r)        r 에 매치; ()은 우선 순위를 바꾸기 위해서(때문에) 사용.
                 (이하를 참조)


    rs         정규 표현 r 에 정규 표현 s 가 계속되는; 「연결(concatenation)」
                 (이)라고 부릅니다.


    r|s        r 혹은 s.


    r/s        뒤로 s 가 계속될 때의 r.
                 s 에 매치 하는 텍스트는 이 룰의 "최장 적합" 을 판정한다
                 때로는 포함됩니다만, 액션이 실행되기 전에
                 입력에 되돌려집니다.
                 액션은 r 에 매치 하는 텍스트만을 봅니다.
                 이 패턴은 "우문맥(trailing context)" 으로 불립니다.
                 (flex 가 정확하게 매치 불능인 r/s 의 편성은 다수 있습니다;
                 "위험한 우문맥" 에 대해서는,
                 이후의, 결함 / 버그의 마디의 기술을 봐 주세요. )
    ^r         줄머리에 있는 r. (스캔의 시작 혹은
                 스캔 된 개행의 오른쪽입니다).
    r$         줄 끝에 있는 r. "r/  와 등가(개행 전입니다).
                 "r/  와 같습니다.

               flex 의 "개행" 의 표현은 flex 를 컴파일 했다
               C 컴파일러가 해석하는 ' 와 완전하게 일치하는 것에
               주의해 주세요;
               특정의 시스템 DOS 에서는 \r 를 입력으로부터 없앨까
               "r$" 를 나타내기 위해서(때문에) 명시적으로 r/\r 를 사용할 필요가 있습니다.


    <s>r       개시 조건 s 에 있어서의 r. (개시 조건에 대해서는 이하를
               참조).
    <s1,s2,s3>r
               위에 같다. 다만 개시 조건은 s1, s2, s3 의 머지않아 이라도 좋다.
    <*>r       임의의 개시 조건의 r. 개시 조건은 배타적인 물건이라도 좋다.


    <<EOF>>    파일의 종료.
    <s1,s2><<EOF>>
               개시 조건이 s1 혹은 s2 일 때의 파일의 종료.

우에에 둔 정규 표현은 우선 순위에 의해 그룹으로 나눌 수 있고 있습니다. 맨 위의 그룹이 가장 높은 우선도로, 맨 밑의 그룹의 우선 순위가 가장 낮아지고 있습니다. 그룹내에서는 같은 우선 순위입니다. 예를 들면,

    foo|bar*

    (foo)|(ba(r*))

    foo|(bar)*

    (foo|bar)*

캐릭터 혹은 캐릭터 범위에 가세해 캐릭터 클래스도 캐릭터 클래스의 표현 (을)를 포함합니다. 이러한 표현은 [: 및 :] 의 딜리미터에 둘러싸입니다 (캐릭터 클래스의 '['와 ']'와의 사이에 나타날 필요가 있습니다; 다른 요소가 캐릭터 클래스안에 나타나도 상관하지 않습니다). 유효한 표현은 이하와 같습니다:

    [:alnum:] [:alpha:] [:blank:]
    [:cntrl:] [:digit:] [:graph:]
    [:lower:] [:print:] [:punct:]
    [:space:] [:upper:] [:xdigit:]

예를 들면 이하의 표현은 모두 같습니다:

    [[:alnum:]]
    [[:alpha:][:digit:]]
    [[:alpha:]0-9]
    [a-zA-Z0-9]

패턴에 관한 주의점입니다:

-	부정문자 클래스, 예를 들면 위의 "[^A-Z]" 는 "  (혹은 이것을 나타내는 escape sequence)가 명시적으로 부정문자 클래스에 나타나고 있는 경우 (예를 들면 "[^A-Z ")를 제외해 개행에 매치 합니다. 이것은 다른 정규 표현 툴이 부정문자 클래스를 취급하는 방법과는 다릅니다만, 불행한 일로 이 모순은 역사적으로 확립해 있습니다. 개행에 매치 한다는 것은, 입력에 다른 쿼츠가 존재하지 않는 경우에 [^"]* 와 같은 패턴이 입력 전체에 매치 하는 것을 의미합니다.
-	룰은 우문맥('/'오퍼레이터 혹은 '$'오퍼레이터) (을)를 고들 한 살 밖에 가질 수 없습니다. 개시 조건 '^'와 "<<EOF>>" 패턴은 패턴이 최초로 없으면 안되어, '/', '$' (와)과 같이 () 안에 넣을 수 없습니다. 룰의 선두는 아닌 '^'혹은 룰의 끝은 아닌 '$'는 특별한 의미를 잃어, 통상의 캐릭터로서 다루어집니다.
	이하는 무효입니다: foo/bar$ <sc1>foo<sc2>bar 전자는 "foo/bar  라고 쓸 수 있습니다.
	이하에서는 '$'와 '^'와는 통상의 캐릭터로서 다루어집니다: foo|(bar$) foo|^bar "foo" 혹은 "개행이 계속되는 bar" 를 지정하고 싶은 경우는, 다음의 표현을 사용해 주세요 (특별한 '|'의 동작은 다음에 설명합니다): foo | bar$ /* action goes here */ 같은 방법으로, foo 혹은 줄머리의 bar 를 지정 가능합니다.

매치이 결정되면(자), 성냥에 대응하는 텍스트( 토큰 (으)로 불립니다)가 글로벌 캐릭터 포인터 yytext 에 의해 사용 가능해져, 길이가 글로벌 정수 yyleng 에 의해 사용 가능해집니다. 그 후, 매치 한 패턴에 대응한다 액션 하지만 실행되고(액션의 상세한 기술은 다음에 실시합니다), 나머지의 입력이 나머지의 매치을 위해서(때문에) 스캔 됩니다.

매치이 발견되지 않으면 디폴트 룰 하지만 실행됩니다: 입력의 다음의 캐릭터가 매치 했다고 보고 방 되어 표준 출력에 카피됩니다. 가장 간단하고 정당한 flex 의 입력은 이하와 같습니다:

    %%

yytext (은)는 2 개(살)이 다른 방법에 의해 정의될 수 있는 일로 주의해 주세요: 캐릭터 포인터 혹은 캐릭터 배열 입니다. flex 하지만 어느 쪽의 정의를 사용할까는 특별한 지시문 %pointer 혹은 %array (을)를 flex 의 입력의 최초의(정의) 부분에 포함하는 것으로 제어할 수 있습니다. 디폴트는 %pointer (이어)여, -l lex 호환 옵션을 사용했을 경우에는 예외적으로 yytext (은)는 배열이 됩니다. %pointer (을)를 사용하는 이점은 스캔이 고속으로 있는 것, 매우 큰 토큰에 매치 할 때에도 (동적 메모리를 다 사용하지 않는 한) 버퍼 오버플로우가 되지 않는 것입니다. 결점은, 액션이 yytext (을)를 수정하는 것이 제한되는 것(차절 참조), unput() 호출이 yytext 의 현재의 내용을 파괴하는 것입니다. 이것은 다르다 lex 버젼간에서의 이식성에 관한 두통거리입니다.

%array 의 이점은 yytext 의 내용을 뜻한대로 변경할 수 있는 것, unput() (을)를 호출해도 yytext 의 내용이 파괴되지 않는 것입니다(아래와 같이 참조). 게다가, 기존의 lex 프로그램은 yytext (을)를 외부로부터 다음의 형식의 선언을 사용해 액세스 하고 있는 일이 있습니다:

    extern char yytext[];

%array 하 yytext (을)를 캐릭터수 YYLMAX (디폴트는 충분히 큰 값)의 배열이다고 정의합니다. 이 크기는, flex 의 입력의 최초의 부분에서 단순하게 YYLMAX (을)를 다른 값에 #define 하는 것으로써 변경할 수 있습니다. 상기대로, %pointer 사용시에는 yytext 는 큰 토큰을 격납하기 위해서 동적으로 커집니다. 이것은 %pointer (을)를 사용한 스캐너는 매우 큰 토큰 (예를 들면 코멘트 블록 전체)(을)를 격납 가능한 것을 의미합니다만, 스캐너가 yytext 의 크기를 바꿀 때마다 토큰 전체를 선두로부터 재스캔 하는 것이 필요하기 (위해)때문에 이러한 토큰에 대한 매칭은 늦어질 수 있는 일을 기억해 두어 주세요. 현재, yytext 하 unput() 하지만 결과적으로 돌려주는 텍스트가 클 때에는 동적이게는 커져 선; 실행시 에러가 됩니다.

또, %array 하 C++ 스캐너 클래스에서는 사용할 수 없는 것에 주의해 주세요( c++ 옵션에 관해서는 아래와 같이 참조).

    %%
    "zap me"

다음은, 복수의 공백이나 캐릭터를 단일의 공백에 압축해 줄 끝의 공백을 버리는 프로그램입니다:

    %%
    [ \t]+        putchar( ' ' );
    [ \t]+$       /* ignore this token */

액션이 '{'를 포함한 경우, 액션은 대응하는 '}'까지 계속되어, 복수행에 건너는 경우도 있습니다. flex (은)는 C 의 캐릭터 라인 및 코멘트에 관해서 알고 있어, 그러한 안의 brace를 오해할 것은 없습니다만, 액션이 %{ 그리고 시작되는 것을 허락해, 다음의 %} 까지의 텍스트가 액션이다고 합니다 (액션 내부의 임의개의 brace에는 관계 없습니다).

수직 바 ('|')만으로부터 되는 액션은 "다음의 룰과 같은" 을 의미합니다. 설명은 이하를 봐 주세요.

액션은 임의의 C 코드를 포함할 수가 있습니다. 이것에는, yylex() (을)를 호출한 routine에 대해서 값을 돌려준다 return 문장도 포함됩니다. yylex() 하지만 불릴 때, 마지막에 남은 토큰으로부터 처리를 재개해, 파일의 종료 혹은 return 를 실행할 때까지 처리를 실시합니다.

액션은 자유롭게 yytext (을)를 변경할 수 있습니다만, 예외는 길이를 늘리는 것입니다 (캐릭터를 말미에 가세하게 되어, 이것은 입력 스트림의 후속 하는 캐릭터를 덧쓰기합니다). 이것은 %array 사용시에는 들어맞지 않습니다(상술); 이 경우 yytext (을)를 자유롭게 변경할 수 있습니다.

액션은 자유롭게 yyleng (을)를 변경할 수 있습니다만, 액션이 yymore() (을)를 사용할 때에는 예외적으로 변경 해서는 안됩니다(후술).

많은 특별한 지시문이 있어, 액션중에 포함할 수가 있습니다:

-	ECHO yytext 를 스캐너의 출력에 카피합니다.
-	BEGIN 뒤로 개시 조건의 이름을 쓰면(자), 스캐너를 대응하는 개시 조건으로 설정합니다(후술).
-	REJECT 입력(혹은 입력의 머리)에 "2 번째에 자주(잘)(second best)" 매치 하는 룰 에 진행되도록(듯이) 스캐너에 지시합니다. "입력의 매치 방법" 으로 가리킨 것처럼 룰은 선택되어 yytext (와)과 yyleng (은)는 적절히 설정됩니다. 선택되는 룰은, 최초로 선택된 룰과 같은 길이이지만 flex 의 입력 파일에서 다음에 나오는 것, 혹은 적은 캐릭터수에 매치 하는 것입니다. 예를 들면 다음의 예에서는 입력중의 말을 세어 "frob" 가 발견될 때마다 routine special()를 부릅니다: int word_count = 0; %% frob special(); REJECT; [^ \t + ++word_count; REJECT 하지만 없는 경우, 입력중의 "frob" 는 말로서 셀 수 있는 두, 스캐너는 통상 대로 토큰마다 1 개의 액션만을 실시합니다. 복수의 REJECT (을)를 사용 가능하고, 각각 현재 유효한 룰의 다음에 좋은 선택을 찾아냅니다. 예를 들면 다음의 스캐너는,"abcd" 라고 하는 토큰을 스캔 해, 출력에 "abcdabcaba" 를 씁니다: %% a | ab | abc | abcd ECHO; REJECT; . |  /* eat up any unmatched character */ (전의 3 살의 룰은 4 번째의 룰의 액션을 공유합니다. 왜냐하면 특별한 '|'액션이 사용되고 있기 때문입니다. ) REJECT (은)는 스캐너의 성능이라고 하는 점으로 특히 코스트가 드는 기능입니다; 만약 스캐너의 액션의 언젠가 (이)라도 REJECT 가 사용되었다면, 스캐너의 모든 매칭 속도를 저하시킨다고 하는 것입니다. 한층 더 REJECT (을)를 옵션 -Cf (이)나 -CF (와)과 함께 이용할 수 없습니다.
	또, 다른 특별 액션과 달라 REJECT 하 분기(branch) 인 것에 주의해 주세요; 즉 REJECT 직후의 액션은 실행 되지 않습니다.
-	yymore() 다음에 룰과 매치 했을 때에는, 대응하는 토큰은, 현재의 yytext 의 내용과 바꿔 넣는 것이 아니라 yytext 에 추가 하도록(듯이) 스캐너에 지시합니다. 예를 들면, 입력 "mega-kludge" 가 주어지면(자), 이하는 "mega-mega-kludge" 를 출력에 씁니다: %% mega- ECHO; yymore(); kludge ECHO; 최초의 "mega-" 는 매치 해 출력에 에코 됩니다. 다음에 "kludge" 가 매치 합니다만, 직전의 "mega-" 가 아직 yytext 의 선두에 남아 있어"kludge" 의 ECHO 룰은 실제로는 "mage-kludge" 를 씁니다.
yymore() 의 사용에 관계되어 2 개의 주의점이 있습니다. 우선, yymore() (은)는 현재의 토큰의 크기를 반영한다 yyleng 의 값의 정확함에 의존하는 것이어, yymore() 사용시에는 yyleng (을)를 변경해 되지 않습니다. 다음에, 스캐너의 액션에 yymore() (이)가 있으면(자), 스캐너의 매치 속도에 약간 악영향이 있습니다.
-	yyless(n) 현재의 토큰으로부터 최초의 n 캐릭터를 제외한 것을 입력 스트림에 되돌립니다. 되돌린 캐릭터 라인은 스캐너가 다음의 매칭을 취할 때 재차 스캔 됩니다. yytext (와)과 yyleng (은)는 적절히 조정됩니다(예를 들면 yyleng 하 n 됩니다). 예를 들면, 입력 "foobar" 가 주어지면(자), 이하는 "foobarbar" 를 씁니다: %% foobar ECHO; yyless(3); [a-z]+ ECHO; 인수 0 을 yyless 에게 주면(자), 현재의 입력 캐릭터 라인 전체가 재차 스캔 됩니다. (예를 들면 BEGIN (을)를 사용해) 다음에 스캐너가 입력하는 방법을 변경하고 있지 않으면 엔들레스 루프가 됩니다.
yyless (은)는 매크로이며, flex 입력 파일에서만 사용 가능하고, 다른 원시 파일로부터는 사용 불능인 것에 주의해 주세요.
-	unput(c) 캐릭터 c (을)를 입력 스트림에 되돌립니다. 되돌린 캐릭터는 다음에 스캔 되는 캐릭터가 됩니다. 다음의 액션은 현재의 토큰을 채택해 괄호내에 들어갈 수 있어 재스캔 합니다. { int i; /* Copy yytext because unput() trashes yytext */ char *yycopy = strdup( yytext ); unput( ')' ); for ( i = yyleng - 1; i >= 0; --i ) unput( yycopy[i] ); unput( '(' ); free( yycopy ); } unput() (은)는 캐릭터를 입력 스트림의 선두 에 되돌리므로, 캐릭터 라인을 되돌리는 경우에는 뒤로부터 전으로 향해 되돌릴 필요가 있습니다.
unput() 사용시의 중요한 잠재적인 문제는, %pointer 사용시(디폴트)에 unput() (을)를 호출하면(자), 우단의 캐릭터로부터 개시해 1 캐릭터씩 왼쪽을 향해 소비되어 yytext 의 내용이 파괴 되는 것입니다. (상기 예의 같게) unput() 호출 후도 yytext 의 내용을 보존하기 위해서는, 시작해에 다른 장소에 카피하는지, 스캐너를 %array (을)를 사용하도록(듯이) 구축하는 것입니다(입력의 매치 방법 참조).
마지막으로, EOF (을)를 되돌려 입력 스트림에 파일의 끝을 마크 한다고는 할 수 없는 것에 주의해 주세요.
-	input() 다음의 캐릭터를 입력 스트림로부터 읽습니다. 다음의 예는 C 코멘트를 먹습니다: %% "/*" { register int c; for ( ; ; ) { while ( (c = input()) ! = '*' && c ! = EOF ) ; /* eat up text of comment */ if ( c == '*' ) { while ( (c = input()) == '*' ) ; if ( c == '/' ) break; /* found the end */ } if ( c == EOF ) { error( "EOF in comment" ); break; } } } (스캐너가 C++ 그리고 컴파일 되었을 때는, 이 routine는 yyinput() 그렇다고 하는 명칭이 되어, C++ 스트림의 input (와)과 이름이 충돌하는 것을 피합니다. )
-	YY_FLUSH_BUFFER 스캐너의 내부 버퍼를 플래시 해, 다음에 스캐너가 토큰을 매치 하려고 했을 때 버퍼를 YY_INPUT 에서 리필 합니다(생성된 스캐너로 후술). 이 액션은, 복수의 입력 버퍼에 대해 후술 한다 보다 일반적인 yy_flush_buffer() 함수의 특별한 케이스입니다.
-	yyterminate() 액션의 return 문 대신에 사용할 수가 있습니다. yyterminate() (은)는 스캐너를 종료해,"모두 종료" 를 의미하는 0 을 호출해 원함수에 돌려줍니다. 디폴트에서는 yyterminate() (은)는 파일의 마지막에 이르렀을 때에도 불립니다. yyterminate() (은)는 매크로이며, 정의 다시 할 수가 있습니다.

    int yylex()
        {
        ... various definitions and the actions in here ...
        }

    #define YY_DECL float lexscan( a, b ) float a, b;

yylex() (은)는 불릴 때, 글로벌 입력 파일 yyin (디폴트에서는 표준 입력)(으)로부터 토큰을 스캔 합니다. 파일의 끝이 되는(이 경우 0 을 돌려줍니다)인가, 액션이 return 문장을 실행할 때까지, 실행을 계속합니다.

스캐너가 파일의 끝나에 도달하면(자), yyin 하지만 새로운 파일을 가리키지 않는가 (새로운 파일을 가리키는 경우는 이 파일의 스캔을 계속합니다), yyrestart() 하지만 불리지 않는 이상 후속 하는 호출은 미정도리입니다. yyrestart() 하 FILE * 포인터( YY_INPUT (을)를 설정해 yyin 이외의 소스를 스캔 하도록(듯이) 했을 경우에는 nil 도 가능입니다) 인 인수를 1 개 취해, 그 파일로부터의 스캔을 위해서(때문에) yyin (을)를 초기화합니다. 본질적으로, yyin (을)를 새로운 입력 파일에 할당하는 것으로 yyrestar() (을)를 사용하는 것으로는 같습니다; 후자는 전의 버젼의 flex (와)과의 호환성을 위해서(때문에) 사용 가능하고, 또 스캔의 도중에 입력 파일을 바꾸는 것이 가능합니다. 인수를 yyin (으)로서 호출하는 것으로, 현재의 입력 버퍼를 버릴 수도 있습니다; 다만, YY_FLUSH_BUFFER (상술)(을)를 사용하는 편이 좋습니다. yyrestart() 하 INITIAL 의 개시 조건을 변경해 없다 일로 주의해 주세요 (후술의 개시 조건 참조).

어느 액션중에서 return 문장을 실행하는 것으로써 yylex() 하지만 스캔을 멈추었을 경우, 스캐너는 재차 호출해 가능하고, 이 경우 스캔의 나머지의 부분으로부터 재개합니다.

디폴트로(효율이기 때문에), 스캐너는 단순한 getc() 콜은 아니고 블록 리드를 실시해, yyin (으)로부터 캐릭터를 읽습니다. 입력 취득 방법은 YY_INPUT 매크로를 정의하는 것으로써 제어할 수 있습니다. YY_INPUT 호출 순서는 "YY_INPUT(buf, result, max_size)" 입니다. 이 액션은, buf 캐릭터 배열중에 최대 max_size 캐릭터를 준비해, 정수 변수 result 안에 읽을 수 있었던 캐릭터수 혹은 정수 YY_NULL (Unix 시스템에서는 0)를 넣어 돌려줍니다. 디폴트의 YY_INPUT 는 글로벌 파일 포인터 "yyin" 로부터 읽습니다.

YY_INPUT 의 샘플 정의입니다(입력 파일의 정의부에 격납):

    %{
    #define YY_INPUT(buf, result, max_size) \
        { \
        int c = getchar(); \
        result = (c == EOF) ?  YY_NULL : (buf[0] = c, 1); \
        }
    %}

스캐너가 YY_INPUT 로부터 파일의 끝이 통지되었을 경우, 스캐너는 yywrap() 함수를 체크합니다. yywrap() 함수가 가짜(제로)를 돌려주는 경우, 함수는 속행중이라고 되어 yyin (을)를 다른 입력 파일을 가리키도록(듯이) 설정해, 스캔을 속행합니다. 함수가 진(비제로)을 돌려주는 경우, 스캐너는 종료해, 호출 바탕으로 0 을 돌려줍니다. 어느 쪽의 경우도 개시 조건은 변화하지 않는 것에 주의해 주세요; 즉 INITIAL 에는 귀가 선.

독자적인 yywrap() (을)를 설정하지 않는 경우, %option noyywrap (이 경우 스캐너는 yywrap() 하지만 1 을 돌려주었는지와 같이 동작합니다)를 사용하는지, 플래그 -ll (을)를 지정해 디폴트의 routine(항상 1 을 돌려줍니다)를 사용하지 않으면 안됩니다.

파일은 아니고 메모리중의 버퍼로부터 스캔하기 위한 3 개의 routine를 사용 가능합니다: yy_scan_string(), yy_scan_bytes(), yy_scan_buffer() 이것들에 관한 논의는 복수의 입력 버퍼의 마디를 참조해 주세요.

스캐너는, 자기의 ECHO 출력을 yyout 글로벌(디폴트에서는 표준 출력이며, 다른 FILE 포인터에 할당하는 것으로 재정의할 수 있습니다)에 씁니다.

    <STRING>[^"]*        { /* eat up the string body ... */
                ...
                }

    <INITIAL,STRING,QUOTE>\.         { /* handle an escape ... */
                ...
                }

개시 조건은, 입력의 정의(선두) 부에 있어, 인덴트 되지 않는 행으로 %s 혹은 %x (으)로부터 시작 이름이 계속되는 행에 대해 선언됩니다. 전자는 내포적 개시 조건을, 후자는 배타적 개시 조건을, 각각 선언합니다. 개시 조건을 유효하게 하는 것은 BEGIN 액션입니다. 다음의 BEGIN 액션이 실행될 때까지, 주어진 개시 조건의 룰은 유효하고, 다른 개시 조건의 룰은 무효입니다. 개시 조건이 내포적 경우, 개시 조건을 가지지 않는 룰도 또 유효합니다. 개시 조건이 배타적 경우, 개시 조건을 채우는 룰 만 하지만 유효합니다. 같은 배타 개시 조건에 의존하는 룰의 조는, flex 입력중의 다른 룰과는 독립인 스캐너를 기술합니다. 그 때문에, 배타 개시 조건을 사용하면,"미니 스캐너" (별부분과는 문법적으로 다른 부분(예를 들면 코멘트)에 대한 스캐너) (을)를 간단하게 지정할 수 있습니다.

내포적 개시 조건과 배타적 개시 조건이 아직 조금 애매하다면, 양자의 관계를 나타내는 예를 나타내 설명합니다. 이하의 룰의 조:

    %s example
    %%

    <example>foo   do_something();

    bar            something_else();

    %x example
    %%

    <example>foo   do_something();

    <INITIAL,example>bar    something_else();

특수한 개시 조건 지정자 <*> (은)는 모든 개시 조건에 매치 하는 것에 주의해 주세요. 이 때문에, 위의 예는 다음과 같이도 쓸 수 있습니다;

    %x example
    %%

    <example>foo   do_something();

    <*>bar    something_else();

디폴트 룰(매치 하지 않았던 캐릭터에 대해서는 ECHO 입니다)는 개시 조건중에서도 유효합니다. 이것은 다음의 것과 등가입니다:

    <*>. |     ECHO;

BEGIN(0) (은)는, 개시 조건이 없는 룰만이 유효하다, 최초 상태로 돌아옵니다. 이 상태는 개시 조건 "INITIAL" 로서 참조할 수 있기 (위해)때문에, BEGIN(INITIAL) 하 BEGIN(0) (와)과 등가입니다. (개시 조건명을 괄괄호는 불필요합니다만, 좋은 스타일이라고 되고 있습니다. )

BEGIN 액션은, 룰부의 선두의 인덴트 된 코드중에 나타나도 좋습니다. 예를 들면 이하의 예에서는, yylex() 하지만 불리고 글로벌 변수 enter_special 하지만 진정한 경우에는, 스캐너는 "SPECIAL" 개시 조건에 들어갑니다:

            int enter_special;

    %x SPECIAL
    %%
            if ( enter_special )
                BEGIN(SPECIAL);

    <SPECIAL>blahblahblah
    ...more rules follow...

개시 조건을 설명하기 위해서, "123.456" 과 같은 캐릭터 라인을 2 방법이 다른 해석을 하는 스캐너를 나타냅니다. 디폴트에서는 이것은, 정수 "123" 으로 닷 ('. ')와 정수 "456" 의 3 토큰으로 꼽힙니다. 그러나, 이 캐릭터 라인의 전에 "expect-floats" 의 캐릭터 라인이 있는 경우, 이것은 단일의 토큰이라고 되어 부동 소수점수(실수) 123.456 으로 여겨집니다:

    %{
    #include <math.h>
    %}
    %s expect

    %%
    expect-floats        BEGIN(expect);

    <expect>[0-9]+". "[0-9]+      {
                printf( "found a float, = %f ,
                        atof( yytext ) );
                }
    <expect>           {
                /* that's the end of the line, so
                 * we need another "expect-number"
                 * before we'll recognize any more
                 * numbers
                 */
                BEGIN(INITIAL);
                }

    [0-9]+      {
                printf( "found an integer, = %d ,
                        atoi( yytext ) );
                }

    ". "         printf( "found a dot  );

    %x comment
    %%
            int line_num = 1;

    "/*"         BEGIN(comment);

    <comment>[^* *        /* eat anything that's not a '*' */
    <comment>"*"+[^*/ *   /* eat up '*'s not followed by '/'s */
    <comment>             ++line_num;
    <comment>"*"+"/"        BEGIN(INITIAL);

개시 조건명은 실제로는 정수치이며, 격납할 수가 있는 것에 주의해 주세요. 그 때문에, 상기예는 이하와 같이 확장할 수 있습니다:

    %x comment foo
    %%
            int line_num = 1;
            int comment_caller;

    "/*"         {
                 comment_caller = INITIAL;
                 BEGIN(comment);
                 }

    ...

    <foo>"/*"    {
                 comment_caller = foo;
                 BEGIN(comment);
                 }

    <comment>[^* *        /* eat anything that's not a '*' */
    <comment>"*"+[^*/ *   /* eat up '*'s not followed by '/'s */
    <comment>             ++line_num;
    <comment>"*"+"/"        BEGIN(comment_caller);

    comment_caller = YY_START;

개시 조건은 독자적인 이름 공간을 가지지 않는 것에 주의해 주세요; %s 나 %x 의 선언에 있어서의 이름 선언의 취급은 #define 와 같습니다.

마지막으로, 배타적 개시 조건을 사용하는, 전개된 escape sequence를 포함한다(너무 긴 캐릭터 라인의 체크는 포함하지 않습니다) C 스타일의 쿼츠 캐릭터 라인에의 매치 방법을 나타냅니다:

    %x str

    %%
            char string_buf[MAX_STR_CONST];
            char *string_buf_ptr;


    \"      string_buf_ptr = string_buf; BEGIN(str);

    <str>\"        { /* saw closing quote - all done */
            BEGIN(INITIAL);
            *string_buf_ptr = '\0';
            /* return string constant token type and
             * value to parser
             */
            }

    <str>        {
            /* error - unterminated string constant */
            /* generate error message */
            }

    <str>\\[0-7]{1,3} {
            /* octal escape sequence */
            int result;

            (void) sscanf( yytext + 1, "%o", &result );

            if ( result > 0xff )
                    /* error, constant is out-of-bounds */

            *string_buf_ptr++ = result;
            }

    <str>\\[0-9]+ {
            /* generate error - bad escape sequence; something
             * like '\48' or '\0777777'
             */
            }

    <str>nbsp; *string_buf_ptr++ = ' ;
    <str>\\t  *string_buf_ptr++ = '\t';
    <str>\\r  *string_buf_ptr++ = '\r';
    <str>\\b  *string_buf_ptr++ = '\b';
    <str>\\f  *string_buf_ptr++ = '\f';

    <str>\\(. |   *string_buf_ptr++ = yytext[1];

    <str>[^\nbsp;
            char *yptr = yytext;

            while ( *yptr )
                    *string_buf_ptr++ = *yptr++;
            }

상기 예의 같게 동일한 개시 조건을 가지는 모든 룰의 전에 개시 조건을 쓰지 않으면 안 되는 것이 많습니다. flex 는 이것을 간단하고 깨끗이 하기 위한(해) 개시 조건 스코프 (을)를 도입했습니다. 개시 조건 스코프는 다음과 같이 시작됩니다:

    <SCs>{

    <ESC>{
        "nbsp;   return ' ;
        "\\r"   return '\r';
        "\\f"   return '\f';
        "\\0"   return '\0';
    }

    <ESC>"nbsp;  return ' ;
    <ESC>"\\r"  return '\r';
    <ESC>"\\f"  return '\f';
    <ESC>"\\0"  return '\0';

개시 조건의 스택을 제어하기 위해서 3 개의 routine를 사용 가능합니다:

void yy_push_state(int new_state)
	현재의 개시 조건을 개시 조건 스택의 선두에 푸쉬 해, BEGIN new_state (을)를 사용했는지와 같이 new_state (으)로 전환합니다 (개시 조건명은 정수치이기도 한 것을 생각해 내 주세요).
void yy_pop_state()
	스택의 선두를 팝 해, BEGIN (을)를 사용해 그 개시 조건으로 전환합니다.
int yy_top_state()
	스택의 내용을 변경하지 않고 , 스택의 선두를 돌려줍니다.

개시 조건 스택은 동적으로 커져, 또 짜넣어 때의 사이즈 제한은 없습니다. 메모리를 다 사용하면(자), 프로그램 실행은 중지됩니다.

개시 조건 스택을 사용하기 위해서는, 스캐너는 %option stack 지시문을 인클루드 할 필요가 있습니다 (아래와 같이 옵션을 참조해 주세요).

이와 같은 문제를 해결하기 위해(때문에), flex (은)는 복수의 입력 버퍼를 생성해 바꾸는 기구를 제공합니다. 입력 버퍼는 다음과 같이 생성됩니다:

    YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )

    void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )

    void yy_delete_buffer( YY_BUFFER_STATE buffer )

    void yy_flush_buffer( YY_BUFFER_STATE buffer )

yy_new_buffer() 하 yy_create_buffer() 의 앨리어스(alias)이며, 동적 오브젝트의 생성과 파괴를 위해서(때문에) 사용하는 C++ 의 new (와)과 delete (와)과의 호환성을 위해서(때문에) 제공하고 있습니다.

마지막에 YY_CURRENT_BUFFER 매크로는, 현재의 버퍼에 대한다 YY_BUFFER_STATE 핸들을 돌려줍니다.

이 기능을 사용해 인클루드 파일을 전개하는 스캐너의 기술예입니다( <<EOF>> 기능은 후술 합니다):

    /* the "incl" state is used for picking up the name
     * of an include file
     */
    %x incl

    %{
    #define MAX_INCLUDE_DEPTH 10
    YY_BUFFER_STATE include_stack[MAX_INCLUDE_DEPTH];
    int include_stack_ptr = 0;
    %}

    %%
    include             BEGIN(incl);

    [a-z]+              ECHO;
    [^a-z *          ECHO;

    <incl>[ \t]*      /* eat the whitespace */
    <incl>[^ \t +   { /* got the include file name */
            if ( include_stack_ptr >= MAX_INCLUDE_DEPTH )
                {
                fprintf( stderr, "Includes nested too deeply" );
                exit( 1 );
                }

            include_stack[include_stack_ptr++] =
                YY_CURRENT_BUFFER;

            yyin = fopen( yytext, "r" );

            if ( !  yyin )
                error( ... );

            yy_switch_to_buffer(
                yy_create_buffer( yyin, YY_BUF_SIZE ) );

            BEGIN(INITIAL);
            }

    <<EOF>> {
            if ( --include_stack_ptr < 0 )
                {
                yyterminate();
                }

            else
                {
                yy_delete_buffer( YY_CURRENT_BUFFER );
                yy_switch_to_buffer(
                     include_stack[include_stack_ptr] );
                }
            }

    <INITIAL><<EOF>>

이러한 룰은 닫지 않은 코멘트를 잡는 경우등에 편리합니다. 예를 들면:

    %x quote
    %%

    ...other rules for dealing with quotes...

    <quote><<EOF>>   {
             error( "unterminated quote" );
             yyterminate();
             }
    <<EOF>>  {
             if ( *++filelist )
                 yyin = fopen( *filelist, "r" );
             else
                yyterminate();
             }

    #define YY_USER_ACTION ++ctr[yy_act]

    int ctr[YY_NUM_RULES];

매크로 YY_USER_INIT 에는 최초의 스캔의 전에 항상 실시하는 액션을 재정의할 수 있습니다 (스캐너의 내부 초기화 전에 행해집니다). 예를 들면 데이터표를 읽어들이거나 로그 파일을 오픈하기 위해서 사용할 수 있습니다.

매크로 yy_set_interactive(is_interactive) (은)는 현재의 버퍼가 대화적 (이)라고 보고 방 되고 있는지 아닌지를 제어하기 위해서 사용합니다. 대화적인 버퍼의 처리는 늦어집니다만, 스캐너의 입력원이 대화적이고 버퍼를 필 하는 것을 기다리는 것에 기인한다 문제를 피하기 위해서(때문에)는 지정하지 않으면 안됩니다(이하의 -I %option interactive 플래그에 관한 논의를 참조해 주세요). 매크로 기동시에 비제로를 지정하면(자) 버퍼는 대화적으로 되어, 제로를 지정하면(자) 비대화적으로 됩니다. 이 매크로의 사용은 %option interactive, %option always-interactive, %option never-interactive 에 우선합니다(아래와 같이 옵션을 참조해 주세요). 버퍼를 스캔 해 대화적인(혹은이 아니다)라고 판단 되기 전에, yy_set_interactive() (을)를 기동해 주세요.

매크로 yy_set_bol(at_bol) (은)는 현재의 버퍼에 있어서의 다음의 토큰에 대한 매치을 위한 스캔이 줄머리로부터 시작되는지 아닌지를 제어합니다. 비제로의 매크로 인수는, '^'가 붙은 룰을 유효하게 합니다만, 제로의 매크로 인수는 '^'가 붙은 룰을 무효로 합니다.

현재의 버퍼로부터 스캔 된 다음의 토큰이 유효한 '^'룰을 가질 때, 매크로 YY_AT_BOL() (은)는 진을 돌려줍니다. 그렇지 않은 경우는 가짜를 돌려줍니다.

생성된 스캐너에서는, 모든 액션은 큰 하나의 switch 문에 모아져 YY_BREAK 그리고 나눌 수 있고 있습니다. YY_BREAK (은)는 재정의 가능합니다. 디폴트에서는 각각의 룰의 액션을 나누기 위한 단순한 "break" 입니다. YY_BREAK (을)를 재정의하는 것으로써, 예를 들면 C++ 유저가 #define YY_BREAK 를 아무것도 하지 않게 정의해 (다만 모든 룰이 "break" 나 "return" 로 끝나도록(듯이) 주의하지 않으면 안됩니다! ), 룰의 액션이 "return" 로 끝나는 것으로 YY_BREAK 하지만 액세스 할 수 없는 것에 기인하는, 도달할 수 없는 문장이 있다고 하는 경고를 피할 수가 있습니다.

    %{
    #include "y.tab.h"
    %}

    %%

    [0-9]+        yylval = atoi( yytext ); return TOK_NUMBER;

    --accepting rule at line 53 ("the matched text")

    "case"    return TOK_CASE;
    "switch"  return TOK_SWITCH;
    ...
    "default" return TOK_DEFAULT;
    [a-z]+    return TOK_ID;

    늦지만 작다
          -Cem
          -Cm
          -Ce
          -C
          -C{f, F}e
          -C{f, F}
          -C{f, F}a
    빠르지만 크다

    yy_create_buffer
    yy_delete_buffer
    yy_flex_debug
    yy_init_buffer
    yy_flush_buffer
    yy_load_buffer_state
    yy_switch_to_buffer
    yyin
    yyleng
    yylex
    yylineno
    yyout
    yyrestart
    yytext
    yywrap

    7bit            -7 옵션
    8bit            -8 옵션
    align           -Ca 옵션
    backup          -b 옵션
    batch           -B 옵션
    c++             -+ 옵션

    caseful 또는
    case-sensitive  -i 옵션의 역(디폴트)

    case-insensitive 또는
    caseless        -i 옵션

    debug           -d 옵션
    default         -s 옵션의 역
    ecs             -Ce 옵션
    fast            -F 옵션
    full            -f 옵션
    interactive     -I 옵션
    lex-compat      -l 옵션
    meta-ecs        -Cm 옵션
    perf-report     -p 옵션
    read            -Cr 옵션
    stdout          -t 옵션
    verbose         -v 옵션
    warn            -w 옵션의 역
                    (-w 옵션에는 "%option nowarn" 를 사용해 주세요)

    array           "%array" 과 등가
    pointer         "%pointer" 과 등가(디폴트)

다음의 옵션은 캐릭터 라인의 값을 받아, '='로 단락짓습니다:

    %option outfile="ABC"

    %option prefix="XYZ"

    %option yyclass="foo"

생성된 스캐너로부터 불필요한 routine를 제외하고 싶은 lint 순정 주의자를 위해서(때문에) 많은 옵션이 준비되어 있습니다. 이하를 안 세트 하면(자)(예를 들면 %option nounput ), 대응하는 routine는 생성되는 스캐너로부터 제외해집니다:

    input, unput
    yy_push_state, yy_pop_state, yy_top_state
    yy_scan_buffer, yy_scan_bytes, yy_scan_string

    REJECT
    %option yylineno
    자유장의 우문맥(trailing context)

    백업이 필요한 패턴의 조
    %array
    %option interactive
    %option always-interactive

    '^'줄머리 오퍼레이터
    yymore()

성능이 중요한 경우에는, 할 수 있을 수 있는 한계의 노력에서도는 REJECT (을)를 피해 주세요. 이것은 특히 고가의 옵션입니다.

백업을 없애면(자), 난잡하게 되어, 몹시 고생해 복잡한 스캐너를 만들게 됩니다. 실제적으로는 -b 플래그를 지정해 lex.backup 파일을 생성하는 것으로부터 시작합니다. 예를 들면, 입력

    %%
    foo        return TOK_KEYWORD;
    foobar     return TOK_KEYWORD;

    State #6 is non-accepting -
     associated rule line numbers:
           2       3
     out-transitions: [ o ]
     jam-transitions: EOF [ \001-n  p-\177 ]

    State #8 is non-accepting -
     associated rule line numbers:
           3
     out-transitions: [ a ]
     jam-transitions: EOF [ \001-`  b-\177 ]

    State #9 is non-accepting -
     associated rule line numbers:
           3
     out-transitions: [ r ]
     jam-transitions: EOF [ \001-q  s-\177 ]

    Compressed tables always back up.

상태 #8 에 관계하는 코멘트는, "foob" 가 스캔 되었을 때에 문제가 있는 것을 나타내고 있습니다. 실제, 'a'이외의 캐릭터를 만나면(자), 스캐너는 "foo" 를 수리하는 곳(중)까지 돌아옵니다. (와)과 같이 상태 #9 에 관계하는 코멘트는, "fooba" 가 스캔 되고 'r'가 계속되지 않는 경우에 관계합니다.

마지막 코멘트가 통지하는 것은, -Cf (이)나 -CF (을)를 사용하고 있으므로 않으면 백업을 없애려고 노력하는 것은 무의미한 것입니다. 왜냐하면, 압축된 스캐너에 대해서 그러한 일을 해도, 성능상의 이익은 없기 때문입니다.

백업을 없애기 위해서(때문에)는 "에러" 룰을 추가합니다:

    %%
    foo         return TOK_KEYWORD;
    foobar      return TOK_KEYWORD;

    fooba       |
    foob        |
    fo          {
                /* false alarm, not really a keyword */
                return TOK_ID;
                }

키워드의 리스트로부터 백업을 없애려면 ,"모두를 잡는다" 룰을 사용할 수가 있습니다:

    %%
    foo         return TOK_KEYWORD;
    foobar      return TOK_KEYWORD;

    [a-z]+      return TOK_ID;

백업 메세지는 cascade 하는 것이 많습니다. 복잡한 룰의 조에서는, 수백의 메세지를 얻는 것은 보통 일입니다. 그러나, 이것을 해석하면, 백업을 제거하기 위해서는 대체로의 경우수다스의 룰에만 관계 있는 것을 알겠지요 (그러나, 잘못하는 것이 많아, 잘못한 룰이 우연히 유효한 토큰에 매치 할 수 있습니다. 장래의 flex 의 기능에서는, 자동적으로 백업을 제거하는 룰을 추가하게 될지도 모릅니다).

백업을 제거하는 것으로써 이익이 있는 것은, 모든 백업을 제거한 때만이라고 하는 것을 기억해 두는 것은 중요합니다. 단 하나를 남겨도 아무것도 얻을 수가 없습니다.

가변장의 우문맥 (왼쪽 부분과 위 부분의 언젠가 혹은 양쪽 모두가 가변장)은 REJECT (와)과 거의 동일한(즉 상당한 ) 성능 열화가 됩니다. 그 때문에 다음과 같은 룰:

    %%
    mouse|rat/(cat|dog)   run();

    %%
    mouse/cat|dog         run();
    rat/cat|dog           run();

    %%
    mouse|rat/cat         run();
    mouse|rat/dog         run();

스캐너의 성능을 향상시키기 위한 여지(실현은 가장 용이)는, 매치 하는 토큰이 길면 스캐너가 고속으로 되는 것에 있습니다. 긴 토큰에서는 대부분의 입력 처리는(짧다) 내부 루프로 처리되어 액션을 위해서(때문에) 스캐너 환경을 설정하는 추가의 일(예를 들면 yytext) (을)를 거의 하지 않기 때문입니다. C 코멘트의 스캐너를 생각해 냅시다:

    %x comment
    %%
            int line_num = 1;

    "/*"         BEGIN(comment);

    <comment>[^* *
    <comment>"*"+[^*/ *
    <comment>             ++line_num;
    <comment>"*"+"/"        BEGIN(INITIAL);

    %x comment
    %%
            int line_num = 1;

    "/*"         BEGIN(comment);

    <comment>[^* *
    <comment>[^* *      ++line_num;
    <comment>"*"+[^*/ *
    <comment>"*"+[^*/ * ++line_num;
    <comment>"*"+"/"        BEGIN(INITIAL);

마지막 고속화의 예입니다: 1 행에 1 개씩이어 다른 캐릭터는 붙지 않는 것 같은, 식별자와 키워드를 모두 파일로부터 스캔 하는 것을 생각합니다. 처음은 다음과 같이 되겠지요:

    %%
    asm      |
    auto     |
    break    |
    ... etc ...
    volatile |
    while    /* it's a keyword */

    . |     /* it's not a keyword */

    %%
    asm      |
    auto     |
    break    |
    ... etc ...
    volatile |
    while    /* it's a keyword */

    [a-z]+   |
    . |     /* it's not a keyword */

    %%
    asm    |
    auto   |
    break  |
    ... etc ...
    volatile |
    while  /* it's a keyword */

    [a-z]+ |
    . |     /* it's not a keyword */

    %%
    asm    |
    auto   |
    break  |
    ... etc ...
    volatile |
    while  /* it's a keyword */

    [a-z]+ |
    [a-z]+   |
    . |     /* it's not a keyword */

마지막 주의 사항: flex (은)는 NUL 에 매치 할 때에는 늦고, 토큰이 복수의 NUL 를 포함할 때에는 특히 늦습니다. 텍스트가 자주 NUL 를 포함하는 것으로 예상되는 경우에는, 텍스트의 짧다 부분과 매치 하도록(듯이) 룰을 써야 합니다.

하나 더의 성능에 관한 최종 주의 사항: 입력의 매치 방법의 마디로 이미 가리킨 것처럼, 큰 토큰을 납입하기 위해서(때문에) yytext 의 사이즈를 동적으로 변경하면 처리가 늦어집니다. 왜냐하면, (거대한) 토큰을 재차 선두로부터 스캔 다시 하지 않으면 안 되기 때문입니다. 성능이 중요한 경우, 텍스트의 "큰" 부분에 매치 시켜야 합니다가 "거대한" 부분에 성냥 시킨다 하지는 않습니다. 양자 계목은 8K 캐릭터/토큰입니다.

flex 에 C++ 스캐너 클래스를 생성시킬 수도 있습니다. -+ 옵션을 지정한다(혹은 등가적으로 %option c++ (을)를 사용한다) 곳과 같이 실행되어 flex 의 실행 형식명이 '+'로 끝나고 있는 경우에는 자동적으로 지정됩니다. 이 옵션을 지정하면(자) flex 가 생성하는 스캐너의 디폴트는 파일 lex.yy.cc 되어 lex.yy.c (이)가 아닙니다. 생성된 스캐너는 2 개의 C++ 클래스와의 인터페이스를 정의하는 헤더 파일 FlexLexer.h (을)를 인클루드 합니다.

최초의 클래스 FlexLexer (은)는 일반적인 스캐너 클래스를 정의하는 추상 기반 클래스를 제공합니다. 이하의 멤버 함수를 제공합니다:

const char* YYText()
	마지막에 매치 한 텍스트를 돌려줍니다. yytext (와)과 등가입니다.
int YYLeng()
	마지막에 매치 한 토큰의 길이를 돌려줍니다. yyleng (와)과 등가입니다.
int lineno() const
	현재의 입력의 행 번호( %option yylineno 참조) 혹은 %option yylineno (을)를 사용하고 있지 않는 경우에는 1 (을)를 돌려줍니다.
void set_debug( int flag )
	스캐너의 디버그 플래그를 세트 합니다. yy_flex_debug 에 대입하는 것과 같습니다(옵션의 마디로 전술). 스캐너 구축시에 %option debug (을)를 사용해 디버그 정보를 짜넣을 필요가 있는 것에 주의해 주세요.
int debug() const
	현재의 디버그 플래그의 설정을 돌려줍니다.
또 다음의 것과 등가인 멤버 함수도 제공됩니다 yy_switch_to_buffer(), yy_create_buffer() (최초의 인수는 istream* 오브젝트 포인터이며 FILE* (이)가 아닙니다), yy_flush_buffer(), yy_delete_buffer(), yyrestart() (이것도 또 최초의 인수는 istream* 오브젝트 포인터입니다).
2 번째의 클래스는 FlexLexer.h 그리고 정의된다 yyFlexLexer (이어)여, FlexLexer (으)로부터 도출한 것입니다. 이하의 추가의 멤버 함수를 정의합니다:
	yyFlexLexer( istream* arg_yyin = 0, ostream* arg_yyout = 0 ) 주어진 입출력 스트림을 사용한다 yyFlexLexer 오브젝트를 구축합니다. 지정하지 않는 경우에는 각각 스트림의 디폴트 cin (와)과 cout (이)가 됩니다.
virtual int yylex()
	이것은 yylex() 하지만 통상의 flex 스캐너에 대해서 간 것과 같은 역할을 담당합니다: 룰의 액션이 값을 돌려줄 때까지, 입력 스트림을 스캔 해, 토큰을 소비합니다. yyFlexLexer (으)로부터 서브 클래스 S (을)를 도출해 yylex() (으)로부터 S 의 멤버 함수 및 변수를 액세스 하고 싶은 경우, %option yyclass="S" (을)를 지정해 yyFlexLexer (은)는 아니고 서브 클래스를 사용하는 것을 flex 에 알릴 필요가 있습니다. 이 경우 yyFlexLexer::yylex() (을)를 생성하는 것이 아니라, flex 하 S::yylex() ( 및 불려 갔다면 yyFlexLexer::LexerError() (을)를 호출하는 더미의 yyFlexLexer::yylex() 도)를 생성합니다.
	virtual void switch_streams(istream* new_in = 0, ostream* new_out = 0) yyin (을)를 new_in (비닐의 경우) 에 재할당 해, yyout (을)를 new_out (같이)에 재할당 합니다. yyin 하지만 재할당 되었을 경우에는 이전의 입력 버퍼는 소거됩니다.
	int yylex( istream* new_in, ostream* new_out = 0 ) 우선 입력 스트림을 switch_streams( new_in, new_out ) (을)를 사용해 바꾸어 yylex() 의 값을 돌려줍니다.
게다가 yyFlexLexer (은)는 다음의 프로텍트 된 가상 함수를 정의합니다. 스캐너에 맞추어 이것들을 도출 클래스에 있어 재정의 할 수 있습니다:
	virtual int LexerInput( char* buf, int max_size ) 최대 max_size 캐릭터를 buf 에 읽어들여, 읽을 수 있었던 캐릭터수를 돌려줍니다. 입력의 끝을 나타내려면 0 캐릭터를 돌려줍니다. "대화적" 스캐너( -B (와)과 -I 플래그를 참조)는 매크로 YY_INTERACTIVE (을)를 정의하는 것에 주의해 주세요. LexerInput() (을)를 재정의해, 대화적인 입력원을 스캔 할 가능성이 있는지 어떤지에 의존해 다른 액션이 필요한 경우, 이 이름이 존재하는지 어떤지의 테스트는 #ifdef 에서 가능합니다.
	virtual void LexerOutput( const char* buf, int size ) size 캐릭터를 버퍼 buf (으)로부터 써냅니다. 스캐너의 룰이 NUL 를 포함한 텍스트에 매치 가능한 경우, NUL 종단 되고 있는 이 버퍼는 "내부에" NUL 를 포함하고 있어도 상관하지 않습니다.
	virtual void LexerError( const char* msg ) 치명적인 에러 메세지를 보고합니다. 디폴트의 이 함수는 메세지를 스트림 cerr 에 써, 종료합니다.

yyFlexLexer 오브젝트는 모든 스캔시 상태를 포함하는 것에 주의해 주세요. 그러므로 이와 같은 오브젝트를 re-entrant인 스캐너로서 사용할 수 있습니다. 동일한 yyFlexLexer 클래스의 복수의 인스턴스를 구체화 가능하고, 복수의 C++ 스캐너 클래스를 편성 상기 -P 옵션을 사용하는 것으로 동일한 프로그램으로 사용 가능합니다.

마지막에 %array 기능은 C++ 스캐너 클래스에서는 사용할 수 없는 것에 주의해 주세요; %pointer (을)를 사용하지 않으면 안됩니다(디폴트).

단순한 C++ 스캐너의 예를 이하에 나타냅니다:

        // An example of using the flex C++ scanner class.

    %{
    int mylineno = 0;
    %}

    string  \"[^ ]+\"

    ws      [ \t]+

    alpha   [A-Za-z]
    dig     [0-9]
    name    ({alpha}|{dig}|\$)({alpha}|{dig}|[_.\-/$])*
    num1    [-+]? {dig}+\.?([eE][-+]? {dig}+)?
    num2    [-+]? {dig}*\. {dig}+([eE][-+]? {dig}+)?
    number  {num1}|{num2}

    %%

    {ws}    /* skip blanks and tabs */

    "/*"    {
            int c;

            while((c = yyinput()) ! = 0)
                {
                if(c == ' )
                    ++mylineno;

                else if(c == '*')
                    {
                    if((c = yyinput()) == '/')
                        break;
                    else
                        unput(c);
                    }
                }
            }

    {number}  cout << "number " << YYText() << ' ;

            mylineno++;

    {name}    cout << "name " << YYText() << ' ;

    {string}  cout << "string " << YYText() << ' ;

    %%

    int main( int /* argc */, char** /* argv */ )
        {
        FlexLexer* lexer = new yyFlexLexer;
        while(lexer->yylex() ! = 0)
            ;
        return 0;
        }

    #undef yyFlexLexer
    #define yyFlexLexer xxFlexLexer
    #include <FlexLexer.h>

    #undef yyFlexLexer
    #define yyFlexLexer zzFlexLexer
    #include <FlexLexer.h>

중요: 현재의 스캔 클래스의 형식은 실험적 (이어)여, 메이저 릴리스가 바뀌면(자) 크게 변경될 가능성이 있습니다.

이 마디에서는, flex 와 AT&T lex 와 POSIX 사양과의 사이의 모든 기존의 비호환성을 취급합니다.

flex 의 -l 옵션은 오리지날의 AT&T lex 실장과의 최대의 호환성을 유효하게 합니다만, 생성된 스캐너의 성능은 크게 저하합니다. -l 옵션을 사용해도 발생할 수 있는 비호환성은 다음에 말합니다.

flex (은)는 이하의 예외를 제외해 lex (와)과 완전 호환입니다:

-	문서에 기재되지 않았다 lex 스캐너 내부의 변수 yylineno 하 -l 혹은 %option yylineno (을)를 사용하지 않으면 서포트되지 않습니다.
	yylineno (은)는 스캐너마다(단일의 글로벌 변수)가 아니고, 버퍼마다 관리되어야 합니다.
	yylineno (은)는 POSIX 사양이 아닙니다.
-	input() routine는 재정의할 수 없습니다만, 룰에 매치 한 것에 후속 하는 캐릭터를 읽기 위해서(때문에) 불릴 수 있습니다. input() 하지만 파일의 끝나에 도달하면(자), 통상의 yywrap() 처리는 종료합니다. ``실제의''파일의 끝은 EOF (으)로서 돌려주어집니다.
	실제로는 입력은 YY_INPUT 매크로를 정의하는 것으로써 제어됩니다.
	input() (을)를 재정의할 수 없다고 한다 flex 의 제한은, 최초로 yyin (을)를 설정하는 이외의 스캐너 입력 제어 방법을 단지 규정하고 있지 않다고 하는, POSIX 사양과 합치합니다.
-	unput() routine는 재정의할 수 없습니다. 이 제한은 POSIX 에 합치하고 있습니다.
-	flex 스캐너는 lex 스캐너와는 달라 re-entrant가 아닙니다. 실제, 대화적인 스캐너에 대해, 인터럽트 처리기에서 롱 점프를 이용해 스캐너로부터 탈출해, 그 후 스캐너를 재차 호출하는 경우, 이하의 메세지를 얻겠지요: fatal flex scanner internal error--end of buffer missed 스캐너에 재차 들어가기 위해서(때문에)는, 우선 이하와 같이 해 주세요 yyrestart( yyin ); 이 호출에 의해 입력 버퍼는 버려지는 것에 주의해 주세요; 통상 이것은 대화적 스캐너에서는 문제가 아닙니다.
	또, C++ 스캐너 클래스는 re-entrant 입니다 의로, C++ 를 사용할 수 있다면, C++ 를 사용해야 합니다. 전술의 "C++ 스캐너의 생성" 을 참조해 주세요.
-	output() (은)는 서포트되고 있지 않습니다. ECHO 매크로로부터의 출력은 파일 포인터 yyout (디폴트에서는 표준 출력 )에 대해서 행해집니다.
	output() (은)는 POSIX 사양에는 없습니다.
-	lex (은)는 배타적 개시 조건 (%x)을 서포트합니다만, 이것은 POSIX 사양에 있습니다.
-	정의를 전개할 때, flex 그럼 괄호로 괄. lex 에서는 이하는: NAME [A-Z][A-Z0-9]* %% foo{NAME}? printf( "Found it  ); %% 캐릭터 라인 "foo" 에는 매치 하지 않습니다. 왜냐하면 전개된 매크로는 룰 "foo[A-Z][A-Z0-9]*? " (이)라고 등가가 되어, 우선도에서 `? '는 "[A-Z0-9]*" 와 연결해 붙습니다. flex 그럼 룰이 전개되면(자) "foo([A-Z][A-Z0-9]*)? " 되어, 캐릭터 라인 "foo" 가 매치 합니다.
	^ 그리고 시작될까 $ 그리고 끝나는 정의는, 전개시에 괄호로 괄등않다, 이러한 오퍼레이터가 정의에 대해 특별한 의미를 잃지 않게 하는 것에 주의해 주세요. 그러나 <s>, /, <<EOF>> 오퍼레이터는 flex 의 정의에서는 사용할 수 없습니다.
	-l (을)를 사용하면(자), lex 의 행동과 같이 정의를 괄호로 괄선.
	POSIX 사양에서는, 정의를 괄호로 괄.
-	lex 의 실장에 따라서는, 룰의 패턴의 우측으로 공백이 있는 경우, 룰의 액션을 다른 행으로부터 시작하는 것을 허락합니다: %% foo|bar<space here> { foobar_action(); } flex (은)는 이 기능을 서포트하지 않습니다.
-	lex 의 %r (Ratfor 스캐너의 생성) 옵션은 서포트되고 있지 않습니다. 이것은 POSIX 사양에는 포함되지 않습니다.
-	스캐너를 %array (을)를 사용해 구축한 것은 아닌 한, unput() 호출 후에는, 다음의 토큰에 매치 할 때까지 yytext (은)는 미정도리입니다. 이것은 lex 에도 POSIX 사양에도 들어맞지 않습니다. -l 옵션을 지정하는 곳의 비호환성을 없앱니다.
-	{} (수치 범위) 오퍼레이터의 우선도가 다릅니다. lex (은)는 "abc{1,3}" 을 "1 도나 2 도나 3 도의 'abc'에 매치" 이라고 해석합니다만, flex (은)는 "'ab'에 1 번이나 2 번이나 3 번의 'c'가 계속되는 것에 매치" 이라고 해석합니다. 후자가 POSIX 사양에 합치합니다.
-	^ 오퍼레이터의 우선도가 다릅니다. lex (은)는 "^foo|bar" 를 "줄머리의 'foo'인가 임의 위치의 'bar'에 매치" 이라고 해석합니다만, flex (은)는 "줄머리의 'foo'인가 'bar'에 매치" 이라고 해석합니다. 후자가 POSIX 사양에 합치합니다.
-	lex 그리고 서포트되고 있다 %a 등의 특별한 테이블 사이즈의 선언은 flex 스캐너에서는 불필요합니다; flex (은)는 이것들을 무시합니다.
-	flex (와)과 lex 의 어디라도 스캐너를 사용 가능하게 쓸 수 있도록(듯이), FLEX_SCANNER (이)라는 이름을 정의합니다. 스캐너를 생성했다 flex 의 버젼을 나타낸다 YY_FLEX_MAJOR_VERSION (와)과 YY_FLEX_MINOR_VERSION (을)를, 스캐너는 포함합니다 (예를 들면 2.5 릴리스에서는 이것들은 각각 2 로 5 가 됩니다).

이하의 flex 의 기능은 lex 및 POSIX 사양에는 포함되지 않습니다:

    C++ 스캐너
    %option
    개시 조건 스코프
    개시 조건 스택
    대화적/비대화적 스캐너
    yy_scan_string() 등
    yyterminate()
    yy_set_interactive()
    yy_set_bol()
    YY_AT_BOL()
    <<EOF>>
    <*>
    YY_DECL
    YY_START
    YY_USER_ACTION
    YY_USER_INIT
    #line 지시문
    액션의 주위의 %{}
    단일행에 있어서의 복수의 액션

    foo    handle_foo(); ++num_foos_seen;

    foo    handle_foo();

    [a-z]+    got_identifier();
    foo       got_foo();

warning, -s option given but default rule can be matched (아마 어느 특정의 개시 조건의 아래에서는) 디폴트 룰 (임의의 한 글자에 매치 한다) 밖에 특정의 입력에 대해 매치 하지 않는 것이 있습니다. -s (을)를 지정해 있으므로, 아마 그렇게 되지 않습니다.

reject_used_but_not_detected undefined 혹은 yymore_used_but_not_detected undefined - 이러한 에러는 컴파일시에 일어납니다. 스캐너가 REJECT 혹은 yymore() (을)를 사용하고 있습니다만 flex 하지만 그것을 눈치채지 못했다고 하는 것입니다. 즉, flex (은)는 최초의 2 개의 부분을 찾아도 이러한 액션의 출현을 찾아낼 수 없었습니다만, 실제로는 어떠한 방법 (예를 들면 #include 파일을 개입시켜)(으)로 이것들이 기술되고 있었다는 일입니다. %option reject 인가 %option yymore (을)를 사용해, flex 에 이러한 기능을 실제로 사용하고 있는 것을 가르쳐 주세요.

flex scanner jammed - -s 그리고 컴파일 된 스캐너가, 어느 룰에도 매치 하지 않는다 입력 캐릭터 라인에 조우했습니다. 내부적인 문제에 기인해 이 에러가 일어나는 일도 있습니다.

token too large, exceeds YYLMAX - 스캐너가 %array (을)를 사용하고 있는 경우에, 어느 룰이 정수 YYLMAX (디폴트로 8K 바이트)보다 큰 캐릭터 라인과 매치 했습니다. flex 의 입력 파일의 정의부에서 YYLMAX (을)를 #define 하는 것으로 값을 크게 할 수 있습니다.

scanner requires -8 flag to use the character 'x' - 스캐너의 기술에 8 비트의 캐릭터 'x' (을)를 식별하는 부분이 있어, -Cf 혹은 -CF 의 테이블 압축 옵션을 위해서(때문에) 디폴트의 7 비트가 되어 있다 그럼에도 불구하고, -8 옵션을 붙이지 않다고 하는 것입니다. 자세한 것은 -7 플래그의 옵션의 논의를 참조해 주세요.

flex scanner push-back overflow - unput() 그리고 텍스트를 너무 되돌렸기 때문에 , 스캐너의 버퍼는 되돌린 텍스트와 현토큰을 yytext 에 유지할 수 없습니다. 이 경우, 이상적이게는 스캐너가 동적으로 버퍼의 크기를 바꾸어야 합니다가, 현재로서는 그렇게 되고는 있지 않습니다.

input buffer overflow, can't enlarge buffer because scanner uses REJECT - 스캐너는 매우 큰 토큰의 매치을 조사하고 있어, 입력 버퍼를 확장할 필요가 일어났습니다. 그렇지만, 버퍼의 확장은 REJECT (을)를 사용하는 스캐너에서는 일하지 않습니다.

fatal flex scanner internal error--end of buffer missed - 스캐너가 사용하고 있는 프레임으로부터(를 넘어) 롱 점프 한 후, 재차 스캐너에 들어갔을 경우에 일어납니다. 재차 스캐너에 들어가기 전에:

    yyrestart( yyin );

too many start conditions in <> construct! - 존재하는 것보다 많은 개시 조건을 <> 안에 기재했습니다 (적어도 하나를 두 번 기재했습니다).

우문맥안에는, 실제로는 고정장인데 한다고는 해석되지 않는 것이 있어, 위에 말한 성능의 저하가 일어납니다. 특히, '|'나 {n} (예를 들면 "foo{3}")는 항상 가변장이다고 해석됩니다.

우문맥과 특별한 액션 '|'를 조합하면(자) 고정의 우문맥이 보다 코스트가 든다 가변의 우문맥이 됩니다. 예를 들면, 다음과 같은 것입니다:

    %%
    abc      |
    xyz/def

%array 혹은 -l 옵션을 지정하지 않는 경우, unput() (을)를 사용하면(자) yytext 와 yyleng 를 파괴합니다.

NUL 의 패턴 매칭은 다른 캐릭터의 비교보다 꽤 늦어지고 있습니다.

입력 버퍼의 동적인 크기의 재조정은 시간이 걸립니다. 이것은 현토큰 (일반적으로 거대)까지의 매치 한 전텍스트의 재스캔을 수반하기 (위해)때문입니다.

입력의 버퍼링과 예측을 위해, <stdio.h> routine와 혼합해 사용할 수가 없습니다. 예를 들면, getchar() (와)과 flex 의 룰은 잘 되어가지 않습니다. 대신에 input() (을)를 사용해 주세요.

-v 옵션으로 표시되는 전테이블 엔트리에는, 어느 룰이 매치 했는지를 결정하는데 필요한 테이블 엔트리수가 포함되어 있지 않습니다. 엔트리의 수는 스캐너가 REJECT (을)를 사용하지 않을 때에는 DFA 상태수에 동일하고, 사용하고 있을 때는 DFA 상태수부터 얼마인가 커집니다.

REJECT 하지만 옵션 -f 혹은 -F (와)과 함께 사용할 수 없습니다.

flex 의 내부 알고리즘에 대한 문서가 필요합니다.

많은 flex 베타 테스타, 피드 바보, 콘트리뷰타, 특히 Francois Pinard, Casey Leedom, Robert Abramovitz, Stan Adermann, Terry Allen, David Barker-Plummer, John Basrai, Neal Becker, Nelson H.F. Beebe, benson@odi.com, Karl Berry, Peter A. Bigot, Simon Blanchard, Keith Bostic, Frederic Brehm, Ian Brockbank, Kin Cho, Nick Christopher, Brian Clapper, J.T. Conklin, Jason Coughlin, Bill Cox, Nick Cropper, Dave Curtis, Scott David Daniels, Chris G. Demetriou, Theo Deraadt, Mike Donahue, Chuck Doucette, Tom Epperly, Leo Eskin, Chris Faylor, Chris Flatters, Jon Forrest, Jeffrey Friedl, Joe Gayda, Kaveh R. Ghazi, Wolfgang Glunz, Eric Goldman, Christopher M. Gould, Ulrich Grepel, Peer Griebel, Jan Hajic, Charles Hemphill, NORO Hideo, Jarkko Hietaniemi, Scott Hofmann, Jeff Honig, Dana Hudes, Eric Hughes, John Interrante, Ceriel Jacobs, Michal Jaegermann, Sakari Jalovaara, Jeffrey R. Jones, Henry Juengst, Klaus Kaempf, Jonathan I. Kamens, Terrence O Kane, Amir Katz, ken@ken.hilco.com, Kevin B. Kenny, Steve Kirsch, Winfried Koenig, Marq Kole, Ronald Lamprecht, Greg Lee, Rohan Lenard, Craig Leres, John Levine, Steve Liddle, David Loffredo, Mike Long, Mohamed el Lozy, Brian Madsen, Malte, Joe Marshall, Bengt Martensson, Chris Metcalf, Luke Mewburn, Jim Meyering, R. Alexander Milowski, Erik Naggum, G.T. Nicol, Landon Noll, James Nordby, Marc Nozell, Richard Ohnemus, Karsten Pahnke, Sven Panne, Roland Pesch, Walter Pelissero, Gaumond Pierre, Esmond Pitt, Jef Poskanzer, Joe Rahmeh, Jarmo Raiha, Frederic Raimbault, Pat Rankin, Rick Richardson, Kevin Rodgers, Kai Uwe Rommel, Jim Roskind, Alberto Santini, Andreas Scherer, Darrell Schiebel, Raf Schietekat, Doug Schmidt, Philippe Schnoebelen, Andreas Schwab, Larry Schwimmer, Alex Siegel, Eckehard Stolz, Jan-Erik Strvmquist, Mike Stump, Paul Stuart, Dave Tallman, Ian Lance Taylor, Chris Thewalt, Richard M. Timoney, Jodi Tsai, Paul Tuinenga, Gary Weik, Frank Whaley, Gerhard Wilhelms, Kent Williams, Ken Yap, Ron Zellar, Nathan Zelle, David Zuhn, 및 나의 최저의 메일 아카이브(archive) 능력으로부터 미끄러져 떨어진 분들, 그러한 분들의 협력에도와 같이 감사합니다.

Keith Bostic, Jon Forrest, Noah Friedman, John Gilmore, Craig Leres, John Levine, Bob Mulcahy, G.T. Nicol, Francois Pinard, Rich Salz, Richard Stallman 에는 많은 고민의 분산에 관해서 감사합니다.

Esmond Pitt 와 Earle Horton 에는 8 비트 캐릭터 서포트에 관해서; Benson Margulies 와 Fred Burke 에는 C++ 서포트에 관해서; Kent Williams 와 Tom Epperly 에는 C++ 클래스 서포트에 관해서; Ove Ewerlid 에는 NUL 의 서포트에 관해서; Eric Hughes 에는 복수 버퍼의 서포트에 관해서, 각각 감사합니다.

이 작품은 당초, 내가 CA Berkeley 의 Lawrence Berkeley Laboratory 에 있어서의 Real Time Systems Group 에 있었을 때에 작성되었습니다. 나에게 협력해 준 분들에게 감사합니다.

코멘트는 vern@ee.lbl.gov 에 보내 주세요.