5일만에 뚝딱 스크립트 언어 만들기 PGLight (3/5)

어 벌써 3번째 글인데 아직 진도가 파싱밖에 못나가서 조금 당황스럽네요. 이거 길어질지도...

저번에 추상문법트리 구조체를 짜는것까지 했습니다. 이제 본격적으로 파서를 짜면 되는데요, 파서 짜는건 정말로 간단합니다. 1일차에서 짰던 BNF를 일부만 가지고 올게요.

<s> ::= <sentence>* <eof>

<sentence> ::= <if>
    | <for>

<if> ::= "if" "(" <expr> ")" "{" <sentence>* "}"
    ("else" "if" "(" <expr> ")" "{" <sentence>* "}")*
    ("else" "{" <sentence>* "}")?

<while> ::= "while" "(" <simple_sentence> ")"
    "{" <sentence>* "}"
    ("done" "{" <sentence>* "}")?
    ("else" "{" <sentence>* "}")?

전체 문법은 수 십개의 규칙으로 이루어질텐데요, 이 각각의 규칙은 하나의 함수로 바뀌게 됩니다. 그리고 제일 꼭대기에 있는 규칙에서부터 차례로 확장해 나가며 전체 토큰을 일치시키는 구조를 찾는것이죠. 이 방식을 Top-down방식(전체적인 구조에서 시작하여 세부적인 부분을 일치시켜나가는 기법. 짜기 쉬워요) 말로 설명하면 복잡할테니 이야기로 쓸게요. (길어서 닫아놓겠습니다. 볼사람만 펼쳐보세요)

예를 들어 소스코드를 tokenize한 결과가 다음처럼 나왔다고 해볼게요.

if, (, a, ==, 1, ), {,  }, else, {, while, (, 1, ), {, }, }, eof

그러면 제일 먼저 가장 꼭대기 규칙인 <s>에서 시작합니다.

<s>를 파싱하는 함수는 들어오는 토큰들이 <s>규칙에 합당한 놈이라고 가정하고, 0개 이상의 <sentence>를 일치시켜보려고 합니다. 그래서 바톤은 <sentence> 규칙으로 넘어옵니다. 

<sentence>규칙에서는 들어오는 토큰들이 <if>와 일치시켜보려고 하겠죠. 다시 바톤은 <if> 규칙으로.

<if>를 파싱하는 함수에서는 먼저 첫번째 토큰이 if인지 확인해요. 맞네요. 그러면 다음 토큰을 받아들입니다.

(, a, ==, 1, ), {,  }, else, {, while, (, 1, ), {, }, }, eof

 ( 도 일치하네요.

a, ==, 1, ), {,  }, else, {, while, (, 1, ), {, }, }, eof

그리고 뒷부분이 <expr>와 일치하는지 확인해요. 지면관계상 <expr> 규칙은 넣지 않았지만, <expr> 규칙에서는 구조를 a == 1에 성공적으로 일치시켰다고 가정합시다. 다시 일은 <if>로 돌아오겠죠.

), {,  }, else, {, while, (, 1, ), {, }, }, eof

<expr> 다음에 있는 )와 일치를 시도해봅니다. 또 성공이지요.

{,  }, else, {, while, (, 1, ), {, }, }, eof

{도 일치

<sentence>* 와 일치시도를 합니다. *이 있으니 0개 이상. 즉 없어도 되는겁니다.

<sentence>에게 바통을 넘겨요.

<sentence>는 <if>일수도, <while>일수도 있지만, 여기서는 <if>도 <while>도 모두 실패합니다. (어느것도 {로 시작하지는 않으니까요.) 그러면 결론은 <sentence>는 0개인걸로 결정지을수 있겠죠. 그래서 다시 <if> 규칙으로 돌아와서 다음 토큰을 일치시킵니다.
 

}, else, {, while, (, 1, ), {, }, }, eof

}도 일치했습니다.

else, {, while, (, 1, ), {, }, }, eof

다음에는 규칙 ("else" "if" "(" <expr> ")" "{" <sentence>* "}")* 와 일치시키는 부분입니다. *가 붙어있다는거. 0개 이상이 일치할수 있는거니깐, 하나도 일치안할수도 있는거죠.

먼저 else를 일치시도합니다. 성공했어요. 다음

{, while, (, 1, ), {, }, }, eof

if랑 일치시켜보려고 해요. 근데 {네요. 이건 맞지가 않네요. 그럼 이 부분은 실패입니다. 빠꾸.

두번째 줄의 규칙이 실패했지만, 없어도 되는 놈이니깐 다음으로 넘어오고 토큰은 원래대로 되돌려요. ("else" "{" <sentence>* "}")? 와 일치를 시도합니다.

else, {, while, (, 1, ), {, }, }, eof

처음에 else 일치했구요. 다음

{, while, (, 1, ), {, }, }, eof

{도 일치했습니다.

while, (, 1, ), {, }, }, eof

<sentence>* 이므로, <sentence>에게 바톤 터치.

<sentence>에서는 <if>인지 <while>인지 테스트 해봐요. 먼저 <if>는 실패할테니 생략..., <while>에게 바톤을 터치합니다.

while이 일치하네요. 다음

(, 1, ), {, }, }, eof

(도 일치합니다.

), {, }, }, eof

<expr>도 일치했다고 합시다. )도 일치했구요.

{, }, }, eof

}도 일치하네요.

}, }, eof

다음은 <sentence>*니깐 <sentence>에게 바톤 패스.

하지만 <sentence>는 모두 실패할겁니다. 결국 <sentence>는 0번반복된다는 결론이 나겠죠.

<while>로 돌아와서 }를 일치시킵니다.

<while> 규칙 전체와 성공적으로 일치가 되었네요. <while>규칙은 지금까지 파싱한게 성공적이었다고 알려주면서 끝납니다.

}, eof

<sentence> 규칙으로 돌아오겠죠. <while>규칙이 성공적으로 일치했으므로, <sentence>도 안심하고 자기가 성공적으로 일치했다는걸 알려주면서 끝내면 됩니다. 그러면 <sentence>규칙과 일치를 시키려고 했던 <if>규칙으로 돌아오겠죠. <if>는 일단 <sentence> 1개가 일치에 성공했다는걸 알수있어요. <sentence>를 한번 더 일치시키려고 시도합니다. (*가 붙어있으니, 되도록이면 많은수가 일치하도록 실패하기 전까지는 계속 시도해봐야하는거죠) 하지만 다시 <sentence>를 일치시키려는 시도는 처참하게 실패합니다. 그러면 확실하게 <sentence>가 1번만 반복된다는 것을 알게되었으니 다음으로 넘어갑니다.

다음 토큰은 }입니다. 규칙과 맞으므로 패스.

eof

이로써 <if>문도 성공적으로 일치했어요. 상부에게 자신이 일치했음을 알려줍니다. 그러면 <if>는 자기를 불렀던 <sentence>로 돌아가고요, <sentence>도 <if>가 성공했으니 자기도 성공한거라고 자기를 불러냈던 <s>에게 알려주겠죠. <s>는 <sentence>가 하나 일치했다는것을 확인했으니, 하나 더 일치시켜보려고 하겠지만 실패겠죠? 그러면 eof를 일치시키려고 할겁니다. 넹 일치하네요.

토큰 전체가 <s>규칙과 일치하네요. 남은 토큰이 없다는걸 보면 확실하게 알수 있죠. 만약에 토큰이 남는다면 뭔가 구문에 문제가 있다는거겠죠.

위 설명을 보면 알수 있듯이, 파싱단계는 규칙이 다른 규칙을 부르면서 토큰을 확인하는 과정으로 이루어집니다. 규칙을 함수로 생각하고, 토큰 목록을 인자로 생각하면, 파싱이란 작업은 토큰 목록을 인수로하는 함수들의 재귀적인 호출로 치환될수 있다는거죠.

각각의 규칙을 함수로 만들어 볼까요?

typedef vector<Token>::const_iterator Tokit; /*P_* 함수들 begin에서 end범위의 토큰을 가지고 파싱을 시도한다. 성공했을 경우 out으로 트리를 내보내고, 사용한 토큰의 개수를 반환한다. 실패했을경우에는 음수를 반환한다.*/ PGL_whole Parse(const string& str, ErrorCnt& err); int P_s(Tokit begin, Tokit end, PGL_whole& out, ErrorCnt& err); int P_expr(Tokit begin, Tokit end, shared_ptr<PGL_expr>& out, ErrorCnt& err); int P_not_expr(Tokit begin, Tokit end, shared_ptr<PGL_expr>& out, ErrorCnt& err); int P_or_expr(Tokit begin, Tokit end, shared_ptr<PGL_expr>& out, ErrorCnt& err); int P_and_expr(Tokit begin, Tokit end, shared_ptr<PGL_expr>& out, ErrorCnt& err); int P_cmp_expr(Tokit begin, Tokit end, shared_ptr<PGL_expr>& out, ErrorCnt& err); int P_add_expr(Tokit begin, Tokit end, shared_ptr<PGL_expr>& out, ErrorCnt& err); int P_mul_expr(Tokit begin, Tokit end, shared_ptr<PGL_expr>& out, ErrorCnt& err); int P_sign_expr(Tokit begin, Tokit end, shared_ptr<PGL_expr>& out, ErrorCnt& err); int P_pow_expr(Tokit begin, Tokit end, shared_ptr<PGL_expr>& out, ErrorCnt& err); int P_a_expr(Tokit begin, Tokit end, shared_ptr<PGL_expr>& out, ErrorCnt& err); int P_dot_expr(Tokit begin, Tokit end, shared_ptr<PGL_expr>& out, ErrorCnt& err); int P_par_expr(Tokit begin, Tokit end, shared_ptr<PGL_expr>& out, ErrorCnt& err); int P_literal(Tokit begin, Tokit end, shared_ptr<PGL_expr>& out, ErrorCnt& err); int P_simple_literal(Tokit begin, Tokit end, shared_ptr<PGLFirstData>& out, ErrorCnt& err); int P_array_literal(Tokit begin, Tokit end, shared_ptr<PGL_expr>& out, ErrorCnt& err); int P_key_val(Tokit begin, Tokit end, PGL_key_val& out, ErrorCnt& err); int P_dict_literal(Tokit begin, Tokit end, shared_ptr<PGL_expr>& out, ErrorCnt& err); int P_lambda_expr(Tokit begin, Tokit end, shared_ptr<PGL_expr>& out, ErrorCnt& err); int P_function_expr(Tokit begin, Tokit end, shared_ptr<PGL_expr>& out, ErrorCnt& err); int P_lexpr(Tokit begin, Tokit end, shared_ptr<PGL_lexpr>& out, ErrorCnt& err); int P_par_lexpr(Tokit begin, Tokit end, shared_ptr<PGL_lexpr>& out, ErrorCnt& err); int P_block(Tokit begin, Tokit end, PGL_block& out, ErrorCnt& err); int P_sentence(Tokit begin, Tokit end, shared_ptr<PGL_sentence>& out, ErrorCnt& err); int P_simple_sentence(Tokit begin, Tokit end, shared_ptr<PGL_sentence>& out, ErrorCnt& err); int P_simple_sentence_semicolon(Tokit begin, Tokit end, shared_ptr<PGL_sentence>& out, ErrorCnt& err); int P_assign(Tokit begin, Tokit end, shared_ptr<PGL_sentence>& out, ErrorCnt& err); int P_call(Tokit begin, Tokit end, shared_ptr<PGL_sentence>& out, ErrorCnt& err); int P_for(Tokit begin, Tokit end, shared_ptr<PGL_sentence>& out, ErrorCnt& err); int P_for_in(Tokit begin, Tokit end, shared_ptr<PGL_sentence>& out, ErrorCnt& err); int P_if(Tokit begin, Tokit end, shared_ptr<PGL_sentence>& out, ErrorCnt& err); int P_while(Tokit begin, Tokit end, shared_ptr<PGL_sentence>& out, ErrorCnt& err); int P_return(Tokit begin, Tokit end, shared_ptr<PGL_sentence>& out, ErrorCnt& err); int P_yield(Tokit begin, Tokit end, shared_ptr<PGL_sentence>& out, ErrorCnt& err); int P_continue(Tokit begin, Tokit end, shared_ptr<PGL_sentence>& out, ErrorCnt& err); int P_break(Tokit begin, Tokit end, shared_ptr<PGL_sentence>& out, ErrorCnt& err); int P_decl_var(Tokit begin, Tokit end, shared_ptr<PGL_sentence>& out, ErrorCnt& err); int P_decl_var_semicolon(Tokit begin, Tokit end, shared_ptr<PGL_sentence>& out, ErrorCnt& err); int P_param(Tokit begin, Tokit end, PGL_param& out, ErrorCnt& err); int P_decl_func(Tokit begin, Tokit end, shared_ptr<PGL_sentence>& out, ErrorCnt& err);

함수를 무지 많이 선언했어요.

Tokit은 vector<Token>의 이터레이터 타입입니다. 자주 쓸거니깐 짧게 줄여놓은거죠. 하나의 규칙은 대게 하나의 함수와 대응돼요. P_s는 <s>를 파싱하고, P_sentence는 <sentence>를 파싱하며, P_if는 <if>를 파싱하는 식인거죠.

인자로 넘겨주는 놈은 죄다 같습니다. Tokit begin, Tokit end는 토큰의 시작과 끝을 넘겨주는 거에요. (토큰 목록 전체를 vector로 넘겨주고 받으면 낭비가 심하니깐 이렇게 한거에요.) 세번째 인자 out은 파싱의 결과로 뱉어내는 추상문법트리이구요, 마지막 err는 파싱이 실패했을때 에러메세지를 모아두는 것입니다. 에러 메세지가 친절해야 코딩할 맛이나니깐요.

그리고 이 함수들은 성공하면 일치한 토큰의 개수를 반환하고, 실패하면 음수를 반환한다고 약속을 잡아놨습니다.

/* <s> ::= <sentence>* <eof> */ int P_s(Tokit begin, Tokit end, PGL_whole& out, ErrorCnt& err) { int i = 0; // 사용한 토큰 수 int t; shared_ptr<PGL_sentence> ret; // begin i 부터의 토큰이 <sentence> 규칙에 맞는지 확인합니다. while((t = P_sentence(begin + i, end, ret, err)) >= 0) { // t >= 0이면 일치한것. 토큰 사용수를 t만큼 늘리고 i = t; // 결과로 받은 놈을 트리 안에 추가해요. out.sents.push_back(ret); } // 끝이 eof와 일치하면 성공 if(begin[i].type == TokenType::eof) { ++i; } else { // 아니면 실패 return -1; } return i; }

/* <if> ::= "if" "(" <expr> ")" "{" <sentence>* "}" ( "else" (<if> | "{" <sentence>* "}") )? */ // 잘보면 규칙이 앞에꺼랑은 달라요. // else if문 자체를 else 문 안에 if문이 들어가있는 형식으로 보는겁니다. // 이게 함수 짤때는 더 편하더라구요. int P_if(Tokit begin, Tokit end, shared_ptr<PGL_sentence>& out, ErrorCnt& err) { int i = 0; // 사용한 토큰 수 int t; ErrorCnt e; // 임시 에러목록 // 첫번째는 if로 시작해야죠 if(begin[i].type == TokenType::_if) { ++i; // 사용된 토큰수 늘리고 } // 아니면 실패. else return -1; // 다음에는 여는 괄호가 나와야해요 if(begin[i].type == TokenType::lparen) { ++i; } else { // 안 나왔으면 에러인거죠. err에 expect_paren(괄호가 예상됨)이라는 에러를 추가합니다. err.Push(Error(ErrorType::expect_paren, begin[i].line, begin[i].str)); return -1; } // <expr>가 나와야하죠 shared_ptr<PGL_expr> cond; if((t = P_expr(begin i, end, cond, e)) >= 0) { // 성공적으로 나왔으면 i += t; // 사용한 토큰수를 t개만큼 늘리고 } else { // 안 나왔으면 e 에러목록을 err에 합칩니다. // 이렇게 한 이유는 성공했는데도 에러가 쌓이는 경우가 있는데 // 실패한 경우에만 에러가 나와야하니깐. err.Merge(e); // 표현식이 예상된다는 에러를 추가합니다. err.Push(Error(ErrorType::expect_expression, begin[i].line, begin[i].str)); return -1; } // 닫는 괄호가 나와야해요 if(begin[i].type == TokenType::rparen) { ++i; } else { // 안 나오면 에러인겁니다. // 닫는 괄호가 예상된다는 에러를 추가합니다. err.Merge(e); err.Push(Error(ErrorType::expect_rparen, begin[i].line, begin[i].str)); return -1; } // 임시 에러목록을 비우고 e = ErrorCnt(); PGL_block block; // <block>이랑 일치를 시도합니다. // <block>은 "{" <sentence>* "}"가 자주 쓰이길래 // 아예 <block> ::= "{" <sentence>* "}" 라는 규칙으로 // 새로 만들었습니다. 처음에 세운 BNF규칙이랑 달라서 죄송해요꾸벅 if((t = P_block(begin i, end, block, e)) >= 0) { i += t; } else { // 역시나 실패했을경우에만 // 에러에 추가합니다. err.Merge(e); err.Push(Error(ErrorType::unexpected, begin[i].line, begin[i].str)); return -1; } // 여기까지만 와도 일단은 성공한겁니다. // 왜냐면 뒤의 부분은 있어도 그만 없어도 그만이니까요 // 추상구문트리를 만들고 auto ret = make_shared<PGL_if>(); ret->cond = cond; ret->trueSents = block; // 지금까지 파싱한 결과를 넣습니다. // else가 있으면 뒷부분도 파싱을 시도하는겁니다. if(begin[i].type == TokenType::_else) { ++i; // 그 다음에 if가 등장하면 <if>와 일치시도를 하구요 if(begin[i].type == TokenType::_if) { shared_ptr<PGL_sentence> elif; if((t = P_if(begin i, end, elif, err)) >= 0) { i += t; ret->falseSents.sents.push_back(elif); } else { err.Push(Error(ErrorType::unexpected, begin[i].line, begin[i].str)); return -1; } } else // 아니면 <block>과 일치시도를 합니다. { if((t = P_block(begin i, end, ret->falseSents, err)) >= 0) { i += t; } else { err.Push(Error(ErrorType::unexpected, begin[i].line, begin[i].str)); return -1; } } } out = ret; //최종적으로 out에 추상구문트리를 넣고, 사용한 토큰수를 반환하면 끝 return i; }

이런 구조로 파싱이 이뤄지는 겁니다.

각각의 규칙을 짤때는 그 규칙만 생각하면 됩니다. <if>짤때 아 <expr>도 파싱해야하는데.. 이런 고민말고, 그냥 P_expr를 호출해서 expr를 파싱할 책임을 넘겨버리는 센스가 필요해요. 함수만 잘 분할하면, 파싱에서 하는 일이 그저 if문으로 토큰 타입이 일치하는지 확인하고, 아니면 에러 메세지 추가하고 실패하는게 전부가 됩니다. 할일은 많지만 단순한 작업들이지요.

/* <add_expr> ::= <mul_expr> ((" " | "-") <mul_expr>)* */ // 물론 다음과 같은 규칙도 가능합니다. /* <add_expr> ::= (<add_expr> ("+" | "-"))? <mul_expr> 혹은 <add_expr> ::= <mul_expr> (("+" | "-") <add_expr>)? 하지만 윗쪽 규칙과 아래쪽 규칙의 차이는 1 + 2 - 3이 위쪽 규칙에서는 (1 + 2) 3으로 아래쪽에서는 1 + (2 - 3) 으로 파싱된다는 겁니다. 보통 연산자는 왼쪽부터 결합되는게 일반적이므로, 윗쪽 규칙을 써야겠지만, 이럴 경우 P_add_expr 함수가 P_add_expr를 무한호출하는 결과를 가져옵니다. 그렇기에 <add_expr> ::= <mul_expr> (("+" | "-") <mul_expr>)* 라고 한거죠. */ int P_add_expr(Tokit begin, Tokit end, shared_ptr<PGL_expr>& out, ErrorCnt& err) { int i = 0; // 사용한 토큰 수 int t; shared_ptr<PGL_expr> lexp; // <mul_expr>과 일치하는지 확인하구요 if((t = P_mul_expr(begin i, end, lexp, err)) >= 0) { i += t; // 사용한 토큰을 t개 늘리고 } // 실패할 경우는 쿨하게 끝냅니다. // 에러메세지를 추가하지 않는 이유는 // 애초에 이 놈이 <add_expr>에 일치하지 않는 구문 // (예를 들어 return 1; 같은) 일수도 있기 때문이죠. // 반드시 <add_expr>가 요구되는 경우라면 // <add_expr>에서 에러메세지를 추가하는 것이 아니라 // <add_expr>를 호출하는 쪽에서 에러인 경우에 // 메세지를 추가하는게 좋습니다. else return -1; // - 이면 while(begin[i].type == TokenType::plus || begin[i].type == TokenType::minus) { TokenType s = begin[i].type; ++i; shared_ptr<PGL_expr> rexp; // <mul_expr>과 다시 일치시도 if((t = P_mul_expr(begin i, end, rexp, err)) >= 0) { i += t; // 사용한 토큰을 t개 늘리고 switch(s) { // 라면, 덧셈을 하는 추상구문 트리를 case TokenType::plus: lexp = make_shared<PGL_add_expr>(lexp, rexp); break; // - 라면, 뺄셈을 하는 추상구문 트리를 만듭니다. case TokenType::minus: lexp = make_shared<PGL_sub_expr>(lexp, rexp); break; } } else { // <mul_expr>과 일치하지 않는다면 사용한 토큰수를 원래대로 돌리고 // 반복문을 빠져나와야합니다. --i; break; } } // 결과 반환 out = lexp; return i; }

또다른 함수로 <add_expr>를 파싱하는 코드입니다.

주석에도 나와있듯이 <add_expr> ::= (<add_expr> (" " | "-"))? <mul_expr> 에 따라 함수를 작성할 경우, Top-down 방식에 왼쪽에서부터 토큰을 일치시켜나간다는 특징때문에, 무한루프에 빠지게 됩니다. 이해가 안되면 아래를 펼쳐보세요.

<add_expr> ::= (<add_expr> (" " | "-"))? <mul_expr> 을 일치시키기 위해서는

먼저 첫번째 요소인 <add_expr>를 일치시켜보려고 하겠죠.

그러면 그 <add_expr>에서는 또 다시 첫번째 요소인 <add_expr>를 일치시켜보려고 할겁니다.

그 <add_expr>은 또다시 <add_expr>를 일치시켜보려고 할것이고....

물론 이것은 1개 이상의 다음 토큰을 미리 내다보는 방식을 이용하면 해결할 수 있지만, 구현 난이도가 상승하므로 패스.

그래서 연산자 우선순위와 결합 순서를 반영해서 규칙을 세울때 유의할 필요가 있습니다. 다음 BNF 규칙은 연산자 우선순위를 [] () . 연산 > ^ 연산 > - 연산(부호) > * / % 연산 > - 연산 > 비교연산 > and 연산 > or 연산 > not 연산로 하여 작성된겁니다. 참고하시면 좋을거에요.

<expr> ::= <not_expr>

<not_expr> ::= <or_expr>
    | "not" <not_expr>

<or_expr> ::= <and_expr> ("or" <and_expr>)*

<and_expr> ::= <cmp_expr> ("and" <cmp_expr>)*

<cmp_op> ::= "=="
    | "!="
    | ">"
    | "<"
    | ">="
    | "<="

<cmp_expr> ::= <add_expr> ( <cmp_op> <add_expr>)?

<add_expr> ::= <mul_expr> ( (" " | "-") <mul_expr>)*

<mul_expr> ::= <sign_expr> ( ("*" | "/" | "%")  <sign_expr>)*

<sign_expr> ::= <pow_expr>
    | "-"? <sign_exp>

<pow_expr> ::= (<a_expr> "^")* <a_expr>

<a_expr> ::= <par_expr>
    ( ("[" <expr> "]") | ("." <identifier>) | ( "(" ( <expr> ("," <expr>)* )? ")" ))*

<par_expr> ::= <literal> | <identifier> | "this"
    | '(' <expr> ')' | <lambda_expr> | <function_expr>

아, 설명안하고 지나왔는데 에러 메세지를 담는 ErrorCnt클래스는 그냥 단순하게 vector를 래핑한 클래스입니다.

enum class ErrorType { none, unexpected, expect_rparen, comma_no_exp, expect_rbracket, expect_semicolon, expect_id, expect_string, redef_id, unidentified, break_withoutloop, continue_withoutloop, this_withoutfunc, // ... MAX, }; // 에러 구조체입니다. // 에러 타입과 줄번호, 에러가 난 토큰에 대한 정보를 가지고 있어요 struct Error { ErrorType type; int line; string inf; Error(ErrorType _type, int _line, string _inf = string()) : type(_type), line(_line), inf(_inf) { } }; // 별거 없고 Error들을 모아두는 클래스죠. class ErrorCnt { protected: static const char* GetErrMsg(ErrorType e); vector<Error> errs; public: void Push(Error err); void Merge(const ErrorCnt& ec); string GetErrMsg() const; size_t GetErrCnt() const {return errs.size();} };

지금와서 생각해보니, 굳이 만들필요 없었던거같기도해요. 그냥 vector<Error>를 써도 될법합니다.

전체 코드가 보고 싶은 분들 계시겠지요? 주석도 안 달리고 난잡하지만, 혹시나 해서 올려둡니다. (대따길어요)

#include "stdafx.h" #include "PGLParser.h" bool ishex(char c) { if('0' <= c && c <= '9') return true; if('A' <= c && c <= 'F') return true; if('a' <= c && c <= 'f') return true; return false; } int hexToInt(char c) { if('0' <= c && c <= '9') return c - '0'; if('A' <= c && c <= 'F') return c - 'A' + 10; if('a' <= c && c <= 'f') return c - 'a' + 10; return -1; } /* '\'로 Escape되어있는 문자열을 원래값으로 해석하여 반환한다 it에서 시작해서 end에서 끝나는 문자열. Escape이 끝나는 지점으로 it로 옮기고, 실패했을 경우 error를 true설정한다*/ wchar_t DecodeEscape(string::const_iterator& it, string::const_iterator end, bool& error) { if(it == end || *it != '\\') { error = true; return 0; } it; error = false; switch(*it) { case '\\': it; return '\\'; case 't': it; return '\t'; case 'n': it; return '\n'; case 'r': it; return '\r'; case '\'': it; return '\''; case '"': it; return '\"'; case '0': it; return '\0'; case 'x': { it; int h = 0; for(int i = 0; i < 2; i) { if(!ishex(*it)) { error = true; return 0; } h = h * 16 hexToInt(*it); it; } return h; } } error = true; return '\\'; } /* c 문자가 토큰을 경계짓는 문자이면 참을 반환, 아니면 거짓을 반환한다 */ bool IsCutCharacter(wchar_t c) { switch(c) { case ' ': case '\t': case '\r': case '\n': case '<': case '>': case '[': case ']': case '=': case '!': case ' ': case '-': case '*': case '/': case '%': case '^': case '?': case '.': case ':': case ';': case ',': case '{': case '}': case '(': case ')': case '|': return true; } return false; } vector<Token> Tokenize(const string& str) { vector<Token> ret; auto it = str.begin(); auto marker = str.begin(); TokenType stage = TokenType::none; int line = 1; string s; for(;it != str.end(); it) { switch(stage) { case TokenType::none: switch(*it) { case '\n': line; case ' ': case '\t': case '\r': break; case '\"': stage = TokenType::string; s.clear(); break; case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': stage = TokenType::integer; marker = it; break; case '<': if(it 1 != str.end() && it[1] == '=') { ret.push_back(Token("<=", TokenType::lessequal, line)); it; } else { ret.push_back(Token("<", TokenType::less, line)); } break; case '>': if(it 1 != str.end() && it[1] == '=') { ret.push_back(Token(">=", TokenType::greaterequal, line)); it; } else { ret.push_back(Token(">", TokenType::greater, line)); } break; case '[': ret.push_back(Token("[", TokenType::lsbracket, line)); break; case ']': ret.push_back(Token("]", TokenType::rsbracket, line)); break; case '!': if(it 1 != str.end() && it[1] == '=') { ret.push_back(Token("!=", TokenType::notequal, line)); it; } else { ret.push_back(Token("!", TokenType::error, line)); } break; case '=': if(it 1 != str.end() && it[1] == '=') { ret.push_back(Token("==", TokenType::equal, line)); it; } else { ret.push_back(Token("=", TokenType::assign, line)); } break; case ' ': ret.push_back(Token(string(it, it 1), TokenType::plus, line)); break; case '-': ret.push_back(Token(string(it, it 1), TokenType::minus, line)); break; case '*': ret.push_back(Token(string(it, it 1), TokenType::asterisk, line)); break; case '/': if(it 1 != str.end() && it[1] == '/') { stage = TokenType::comment1; it; } else if(it 1 != str.end() && it[1] == '*') { stage = TokenType::comment2; it; } else { ret.push_back(Token(string(it, it 1), TokenType::divide, line)); } break; case '%': ret.push_back(Token(string(it, it 1), TokenType::percent, line)); break; case '^': ret.push_back(Token(string(it, it 1), TokenType::hat, line)); break; case '?': ret.push_back(Token(string(it, it 1), TokenType::question, line)); break; case '.': ret.push_back(Token(string(it, it 1), TokenType::dot, line)); break; case ':': ret.push_back(Token(string(it, it 1), TokenType::colon, line)); break; case ';': ret.push_back(Token(string(it, it 1), TokenType::semicolon, line)); break; case ',': ret.push_back(Token(string(it, it 1), TokenType::comma, line)); break; case '{': ret.push_back(Token(string(it, it 1), TokenType::lbracket, line)); break; case '}': ret.push_back(Token(string(it, it 1), TokenType::rbracket, line)); break; case '(': ret.push_back(Token(string(it, it 1), TokenType::lparen, line)); break; case ')': ret.push_back(Token(string(it, it 1), TokenType::rparen, line)); break; case '|': ret.push_back(Token(string(it, it 1), TokenType::bar, line)); break; default: stage = TokenType::identifier; marker = it; break; } break; case TokenType::string: for(;*it != '\"'; it) { if(it == str.end() || *it == '\n' || *it == '\r') { stage = TokenType::none; ret.push_back(Token(s, TokenType::error, line)); break; } else if(*it == '\\') { bool err; s.push_back(DecodeEscape(it, str.end(), err)); if(err) { stage = TokenType::none; ret.push_back(Token(s, TokenType::error, line)); break; } --it; } else { s.push_back(*it); } } stage = TokenType::none; ret.push_back(Token(s, TokenType::string, line)); break; case TokenType::integer: if(*it == '.') { stage = TokenType::real; } else if(IsCutCharacter(*it)) { stage = TokenType::none; ret.push_back(Token(string(marker, it--), TokenType::integer, line)); } else if(!isdigit(*it)) { stage = TokenType::none; ret.push_back(Token(string(marker, it), TokenType::error, line)); --it; } break; case TokenType::real: if(IsCutCharacter(*it)) { stage = TokenType::none; ret.push_back(Token(string(marker, it--), TokenType::real, line)); } else if(!isdigit(*it)) { stage = TokenType::none; ret.push_back(Token(string(marker, it), TokenType::error, line)); --it; } break; case TokenType::identifier: if(IsCutCharacter(*it)) { stage = TokenType::none; string s(marker, it--); if(s == "and") ret.push_back(Token(s, TokenType::_and, line)); else if(s == "or") ret.push_back(Token(s, TokenType::_or, line)); else if(s == "not") ret.push_back(Token(s, TokenType::_not, line)); else if(s == "function") ret.push_back(Token(s, TokenType::_function, line)); else if(s == "var") ret.push_back(Token(s, TokenType::_var, line)); else if(s == "as") ret.push_back(Token(s, TokenType::_as, line)); else if(s == "if") ret.push_back(Token(s, TokenType::_if, line)); else if(s == "else") ret.push_back(Token(s, TokenType::_else, line)); else if(s == "for") ret.push_back(Token(s, TokenType::_for, line)); else if(s == "while") ret.push_back(Token(s, TokenType::_while, line)); else if(s == "do") ret.push_back(Token(s, TokenType::_do, line)); else if(s == "true") ret.push_back(Token(s, TokenType::_true, line)); else if(s == "false") ret.push_back(Token(s, TokenType::_false, line)); else if(s == "null") ret.push_back(Token(s, TokenType::_null, line)); else if(s == "return") ret.push_back(Token(s, TokenType::_return, line)); else if(s == "break") ret.push_back(Token(s, TokenType::_break, line)); else if(s == "continue") ret.push_back(Token(s, TokenType::_continue, line)); else if(s == "done") ret.push_back(Token(s, TokenType::_done, line)); else if(s == "in") ret.push_back(Token(s, TokenType::_in, line)); else if(s == "yield") ret.push_back(Token(s, TokenType::_yield, line)); else if(s == "this") ret.push_back(Token(s, TokenType::_this, line)); else ret.push_back(Token(s, TokenType::identifier, line)); } break; case TokenType::comment1: if(*it == '\n') { line; stage = TokenType::none; } break; case TokenType::comment2: switch(*it) { case '\n': line; break; case '*': if(it 1 != str.end() && it[1] == '/') { it; stage = TokenType::none; } break; } break; } } ret.push_back(Token("", TokenType::eof, line)); return ret; } /* 입력 받은 str 문자열을 정수로 변환한다. 정수인 부분까지 변환하여 반환하고, 정수가 아닌 문자열일 경우 0을 반환한다. */ int ParseInt(string str) { int sum = 0; for(auto it = str.begin(); it != str.end(); it) { if(!isdigit(*it)) return sum; sum = sum * 10 (*it - '0'); } return sum; } int P_expr(Tokit begin, Tokit end, shared_ptr<PGL_expr>& out, ErrorCnt& err) { return P_not_expr(begin, end, out, err); } int P_not_expr(Tokit begin, Tokit end, shared_ptr<PGL_expr>& out, ErrorCnt& err) { int i = 0; int t; shared_ptr<PGL_expr> ret; if(begin[i].type == TokenType::_not) { i; shared_ptr<PGL_expr> not; if((t = P_not_expr(begin i, end, not, err)) >= 0) { i = t; } else { err.Push(Error(ErrorType::none, begin[i].line, begin[i].str)); return -1; } ret = make_shared<PGL_not_expr>(not); } else { if((t = P_or_expr(begin i, end, ret, err)) >= 0) { i = t; } else { return -1; } } out = ret; return i; } int P_or_expr(Tokit begin, Tokit end, shared_ptr<PGL_expr>& out, ErrorCnt& err) { int i = 0; int t; shared_ptr<PGL_expr> lexp; if((t = P_and_expr(begin i, end, lexp, err)) >= 0) { i = t; } else return -1; while(begin[i].type == TokenType::_or) { i; shared_ptr<PGL_expr> rexp; if((t = P_and_expr(begin i, end, rexp, err)) >= 0) { i = t; lexp = make_shared<PGL_or_expr>(lexp, rexp); } else { --i; break; } } out = lexp; return i; } int P_and_expr(Tokit begin, Tokit end, shared_ptr<PGL_expr>& out, ErrorCnt& err) { int i = 0; int t; shared_ptr<PGL_expr> lexp; if((t = P_cmp_expr(begin i, end, lexp, err)) >= 0) { i = t; } else return -1; while(begin[i].type == TokenType::_and) { i; shared_ptr<PGL_expr> rexp; if((t = P_cmp_expr(begin i, end, rexp, err)) >= 0) { i = t; lexp = make_shared<PGL_and_expr>(lexp, rexp); } else { --i; break; } } out = lexp; return i; } int P_cmp_expr(Tokit begin, Tokit end, shared_ptr<PGL_expr>& out, ErrorCnt& err) { int i = 0; int t; shared_ptr<PGL_expr> lexp; if((t = P_add_expr(begin i, end, lexp, err)) >= 0) { i = t; } else return -1; TokenType s = begin[i].type; switch(s) { case TokenType::equal: case TokenType::notequal: case TokenType::greater: case TokenType::greaterequal: case TokenType::less: case TokenType::lessequal: i; break; default: out = lexp; return i; } shared_ptr<PGL_expr> rexp; if((t = P_add_expr(begin i, end, rexp, err)) >= 0) { i = t; switch(s) { case TokenType::equal: lexp = make_shared<PGL_equal_expr>(lexp, rexp); break; case TokenType::notequal: lexp = make_shared<PGL_notequal_expr>(lexp, rexp); break; case TokenType::greater: lexp = make_shared<PGL_greater_expr>(lexp, rexp); break; case TokenType::greaterequal: lexp = make_shared<PGL_greaterequal_expr>(lexp, rexp); break; case TokenType::less: lexp = make_shared<PGL_less_expr>(lexp, rexp); break; case TokenType::lessequal: lexp = make_shared<PGL_lessequal_expr>(lexp, rexp); break; } } else { err.Push(Error(ErrorType::none, begin[i].line, begin[i].str)); return -1; } out = lexp; return i; } int P_add_expr(Tokit begin, Tokit end, shared_ptr<PGL_expr>& out, ErrorCnt& err) { int i = 0; int t; shared_ptr<PGL_expr> lexp; if((t = P_mul_expr(begin i, end, lexp, err)) >= 0) { i = t; } else return -1; while(begin[i].type == TokenType::plus || begin[i].type == TokenType::minus) { TokenType s = begin[i].type; i; shared_ptr<PGL_expr> rexp; if((t = P_mul_expr(begin i, end, rexp, err)) >= 0) { i = t; switch(s) { case TokenType::plus: lexp = make_shared<PGL_add_expr>(lexp, rexp); break; case TokenType::minus: lexp = make_shared<PGL_sub_expr>(lexp, rexp); break; } } else { --i; break; } } out = lexp; return i; } int P_mul_expr(Tokit begin, Tokit end, shared_ptr<PGL_expr>& out, ErrorCnt& err) { int i = 0; int t; shared_ptr<PGL_expr> lexp; if((t = P_sign_expr(begin i, end, lexp, err)) >= 0) { i = t; } else return -1; while(begin[i].type == TokenType::asterisk || begin[i].type == TokenType::divide || begin[i].type == TokenType::percent) { TokenType s = begin[i].type; i; shared_ptr<PGL_expr> rexp; if((t = P_sign_expr(begin i, end, rexp, err)) >= 0) { i = t; switch(s) { case TokenType::asterisk: lexp = make_shared<PGL_mul_expr>(lexp, rexp); break; case TokenType::divide: lexp = make_shared<PGL_div_expr>(lexp, rexp); break; case TokenType::percent: lexp = make_shared<PGL_mod_expr>(lexp, rexp); break; } } else { --i; break; } } out = lexp; return i; } int P_sign_expr(Tokit begin, Tokit end, shared_ptr<PGL_expr>& out, ErrorCnt& err) { int i = 0; int t; shared_ptr<PGL_expr> ret; if(begin[i].type == TokenType::minus) { i; shared_ptr<PGL_expr> not; if((t = P_sign_expr(begin i, end, not, err)) >= 0) { i = t; } else { err.Push(Error(ErrorType::none, begin[i].line, begin[i].str)); return -1; } ret = make_shared<PGL_sign_expr>(not); } else { if((t = P_pow_expr(begin i, end, ret, err)) >= 0) { i = t; } else return -1; } out = ret; return i; } int P_pow_expr(Tokit begin, Tokit end, shared_ptr<PGL_expr>& out, ErrorCnt& err) { int i = 0; int t; shared_ptr<PGL_expr> lexp; if((t = P_a_expr(begin i, end, lexp, err)) >= 0) { i = t; } else return -1; while(begin[i].type == TokenType::hat) { i; shared_ptr<PGL_expr> rexp; if((t = P_a_expr(begin i, end, rexp, err)) >= 0) { i = t; lexp = make_shared<PGL_pow_expr>(lexp, rexp); } else { --i; break; } } out = lexp; return i; } int P_a_expr(Tokit begin, Tokit end, shared_ptr<PGL_expr>& out, ErrorCnt& err) { int i = 0; int t; shared_ptr<PGL_expr> lexp; if((t = P_par_expr(begin i, end, lexp, err)) >= 0) { i = t; } else return -1; while(begin[i].type == TokenType::dot || begin[i].type == TokenType::lsbracket || begin[i].type == TokenType::lparen) { if(begin[i].type == TokenType::dot) { i; if(begin[i].type == TokenType::identifier) { lexp = make_shared<PGL_dot_expr>(lexp, begin[i].str); i; } else { err.Push(Error(ErrorType::none, begin[i].line, begin[i].str)); return -1; } } else if(begin[i].type == TokenType::lsbracket) { i; shared_ptr<PGL_expr> rexp; if((t = P_expr(begin i, end, rexp, err)) >= 0) { i = t; } else { err.Push(Error(ErrorType::none, begin[i].line, begin[i].str)); return -1; } if(begin[i].type == TokenType::rsbracket) { i; } else { err.Push(Error(ErrorType::expect_rbracket, begin[i].line, begin[i].str)); return -1; } lexp = make_shared<PGL_ref_expr>(lexp, rexp); } else { i; vector<shared_ptr<PGL_expr>> params; shared_ptr<PGL_expr> p; if((t = P_expr(begin i, end, p, err)) >= 0) { i = t; params.push_back(p); while(begin[i].type == TokenType::comma) { i; if((t = P_expr(begin i, end, p, err)) >= 0) { i = t; params.push_back(p); } else { err.Push(Error(ErrorType::expect_rparen, begin[i].line, begin[i].str)); return -1; } } } if(begin[i].type == TokenType::rparen) { i; } else { err.Push(Error(ErrorType::expect_rparen, begin[i].line, begin[i].str)); return -1; } shared_ptr<PGL_functioncall_expr> ret = shared_ptr<PGL_functioncall_expr>(new PGL_functioncall_expr); ret->l = lexp; ret->params = params; lexp = ret; } } out = lexp; return i; } int P_par_expr(Tokit begin, Tokit end, shared_ptr<PGL_expr>& out, ErrorCnt& err) { int i = 0; int t; shared_ptr<PGL_expr> ret; if((t = P_function_expr(begin i, end, ret, err)) >= 0) { i = t; out = ret; return i; } else if((t = P_lambda_expr(begin i, end, ret, err)) >= 0) { i = t; out = ret; return i; } else if(begin[i].type == TokenType::lparen) { i; if((t = P_expr(begin i, end, ret, err)) >= 0) { i = t; } else { err.Push(Error(ErrorType::unexpected, begin[i].line, begin[i].str)); return -1; } if(begin[i].type == TokenType::rparen) { i; } else { err.Push(Error(ErrorType::expect_rparen, begin[i].line, begin[i].str)); return -1; } out = ret; return i; } else if(begin[i].type == TokenType::identifier) { ret = make_shared<PGL_identifier>(begin[i].str); i; out = ret; return i; } else if(begin[i].type == TokenType::_this) { ret = make_shared<PGL_this>(); i; out = ret; return i; } else if((t = P_literal(begin i, end, ret, err)) >= 0) { i = t; out = ret; return i; } else { return -1; } } int P_simple_literal(Tokit begin, Tokit end, shared_ptr<PGLFirstData>& out, ErrorCnt& err) { int i = 0; shared_ptr<PGLFirstData> data; if(begin[i].type == TokenType::integer) { data = make_shared<PGLIntData>(atoi(begin[i].str.c_str())); } else if(begin[i].type == TokenType::real) { data = make_shared<PGLRealData>((float)atof(begin[i].str.c_str())); } else if(begin[i].type == TokenType::string) { data = make_shared<PGLStringData>(begin[i].str); } else if(begin[i].type == TokenType::_true) { data = make_shared<PGLBooleanData>(true); } else if(begin[i].type == TokenType::_false) { data = make_shared<PGLBooleanData>(false); } else if(begin[i].type == TokenType::_null) { data = make_shared<PGLVoidData>(); } else return -1; i; out = data; return i; } int P_literal(Tokit begin, Tokit end, shared_ptr<PGL_expr>& out, ErrorCnt& err) { int i = 0; int t; shared_ptr<PGLFirstData> data; if((t = P_simple_literal(begin i, end, data, err)) >=0 ) { i = t; out = make_shared<PGL_literal>(data); } else if((t = P_array_literal(begin i, end, out, err)) >= 0) { i = t; } else if((t = P_dict_literal(begin i, end, out, err)) >= 0) { i = t; } else return -1; return i; } int P_array_literal(Tokit begin, Tokit end, shared_ptr<PGL_expr>& out, ErrorCnt& err) { int i = 0; int t; ErrorCnt e; auto a = shared_ptr<PGL_array_expr>(new PGL_array_expr); if(begin[i].type == TokenType::lsbracket) { i; } else return -1; shared_ptr<PGL_expr> p; if((t = P_expr(begin i, end, p, e)) >= 0) { i = t; a->elem.push_back(p); while(begin[i].type == TokenType::comma) { i; if((t = P_expr(begin i, end, p, e)) >= 0) { i = t; a->elem.push_back(p); } else { err.Merge(e); err.Push(Error(ErrorType::expect_rbracket, begin[i].line, begin[i].str)); return -1; } } } if(begin[i].type == TokenType::rsbracket) { i; } else { err.Merge(e); err.Push(Error(ErrorType::expect_rbracket, begin[i].line, begin[i].str)); return -1; } out = a; return i; } int P_key_val(Tokit begin, Tokit end, PGL_key_val& out, ErrorCnt& err) { int i = 0; int t; ErrorCnt e; shared_ptr<PGLFirstData> key; if((t = P_simple_literal(begin i, end, key, e)) >= 0) { i = t; out.key = make_shared<PGL_literal>(key); } else return -1; if(begin[i].type == TokenType::assign) { i; } else return -1; if((t = P_expr(begin i, end, out.val, e)) >= 0) { i = t; } else { err.Merge(e); err.Push(Error(ErrorType::unexpected, begin[i].line, begin[i].str)); return -1; } return i; } int P_dict_literal(Tokit begin, Tokit end, shared_ptr<PGL_expr>& out, ErrorCnt& err) { int i = 0; int t; ErrorCnt e; auto a = shared_ptr<PGL_dict_expr>(new PGL_dict_expr); if(begin[i].type == TokenType::lbracket) { i; } else return -1; PGL_key_val p; if((t = P_key_val(begin i, end, p, e)) >= 0) { i = t; a->elem.push_back(p); while(begin[i].type == TokenType::comma) { i; if((t = P_key_val(begin i, end, p, e)) >= 0) { i = t; a->elem.push_back(p); } else { err.Merge(e); err.Push(Error(ErrorType::expect_rbracket, begin[i].line, begin[i].str)); return -1; } } } if(begin[i].type == TokenType::rbracket) { i; } else { err.Merge(e); err.Push(Error(ErrorType::expect_rbracket, begin[i].line, begin[i].str)); return -1; } out = a; return i; } int P_lambda_expr(Tokit begin, Tokit end, shared_ptr<PGL_expr>& out, ErrorCnt& err) { int i = 0; int t; ErrorCnt e; PGL_param p; auto ret = shared_ptr<PGL_function_expr>(new PGL_function_expr); if(begin[i].type == TokenType::lparen) { i; if((t = P_param(begin i, end, p, err)) >= 0) { i = t; ret->params.push_back(p); while(begin[i].type == TokenType::comma) { i; if((t = P_param(begin i, end, p, err)) >= 0) { i = t; ret->params.push_back(p); } else { err.Push(Error(ErrorType::expect_id, begin[i].line, begin[i].str)); return -1; } } } e = ErrorCnt(); if(begin[i].type == TokenType::rparen) { i; } else { e.Push(Error(ErrorType::expect_rparen, begin[i].line, begin[i].str)); return -1; } } else if((t = P_param(begin i, end, p, e)) >=0 ) { i = t; ret->params.push_back(p); } else return -1; if(begin[i].type == TokenType::colon) { i; } else return -1; shared_ptr<PGL_expr> expr; if((t = P_expr(begin i, end, expr, e)) >= 0) { i = t; auto s = shared_ptr<PGL_return>(new PGL_return); s->ret = expr; ret->sents.sents.push_back(s); } else { e.Push(Error(ErrorType::unexpected, begin[i].line, begin[i].str)); return -1; } out = ret; return i; } int P_function_expr(Tokit begin, Tokit end, shared_ptr<PGL_expr>& out, ErrorCnt& err) { int i = 0; int t; ErrorCnt e; if(begin[i].type == TokenType::_function) { i; } else return -1; if(begin[i].type == TokenType::lparen) { i; } else return -1; auto var = shared_ptr<PGL_function_expr>(new PGL_function_expr); PGL_param param; if((t = P_param(begin i, end, param, e)) >= 0) { i = t; var->params.push_back(param); while(begin[i].type == TokenType::comma) { i; if((t = P_param(begin i, end, param, e)) >= 0) { i = t; var->params.push_back(param); } else { err.Merge(e); err.Push(Error(ErrorType::expect_id, begin[i].line, begin[i].str)); return -1; } } } if(begin[i].type == TokenType::rparen) { i; } else { err.Push(Error(ErrorType::expect_rparen, begin[i].line, begin[i].str)); return -1; } if(begin[i].type == TokenType::_as) { i; if(begin[i].type == TokenType::identifier) { var->type = begin[i].str; i; } else { err.Push(Error(ErrorType::expect_id, begin[i].line, begin[i].str)); return -1; } } if((t = P_block(begin i, end, var->sents, err)) >= 0) { i = t; } else { err.Push(Error(ErrorType::unexpected, begin[i].line, begin[i].str)); return -1; } out = var; return i; } int P_sentence(Tokit begin, Tokit end, shared_ptr<PGL_sentence>& out, ErrorCnt& err) { int i = 0; int t; if((t = P_if(begin i, end, out, err)) >= 0) { i = t; return i; } else if((t = P_for(begin i, end, out, err)) >= 0) { i = t; return i; } else if((t = P_for_in(begin i, end, out, err)) >= 0) { i = t; return i; } else if((t = P_while(begin i, end, out, err)) >= 0) { i = t; return i; } else if((t = P_return(begin i, end, out, err)) >= 0) { i = t; return i; } else if((t = P_yield(begin i, end, out, err)) >= 0) { i = t; return i; } else if((t = P_continue(begin i, end, out, err)) >= 0) { i = t; return i; } else if((t = P_break(begin i, end, out, err)) >= 0) { i = t; return i; } else if((t = P_decl_var_semicolon(begin i, end, out, err)) >= 0) { i = t; return i; } else if((t = P_decl_func(begin i, end, out, err)) >= 0) { i = t; return i; } else if((t = P_simple_sentence_semicolon(begin i, end, out, err)) >= 0) { i = t; return i; } else { err.Push(Error(ErrorType::unexpected, begin[i].line, begin[i].str)); return -1; } } int P_simple_sentence(Tokit begin, Tokit end, shared_ptr<PGL_sentence>& out, ErrorCnt& err) { int i = 0; int t; if((t = P_assign(begin i, end, out, err)) >= 0) { i = t; return i; } else if((t = P_call(begin i, end, out, err)) >= 0) { i = t; return i; } else { return -1; } } int P_simple_sentence_semicolon(Tokit begin, Tokit end, shared_ptr<PGL_sentence>& out, ErrorCnt& err) { int i = 0; int t; if((t = P_simple_sentence(begin i, end, out, err)) >= 0) { i = t; if(begin[i].type == TokenType::semicolon) { i; return i; } else { err.Push(Error(ErrorType::expect_semicolon, begin[i].line, begin[i].str)); return -1; } } return -1; } int P_block(Tokit begin, Tokit end, PGL_block& out, ErrorCnt& err) { int i = 0; int t; ErrorCnt e; if(begin[i].type == TokenType::lbracket) { i; } else return -1; shared_ptr<PGL_sentence> ret; bool exit = false; while(!exit) { if(begin[i].type == TokenType::rbracket) break; t = P_sentence(begin i, end, ret, e); if(t >= 0) { i = t; out.sents.push_back(ret); } else { int bracket = 1; for(;; i) { if(begin[i].type == TokenType::lbracket) { bracket; } else if(begin[i].type == TokenType::rbracket) { --bracket; if(bracket == 0) { exit = true; err.Merge(e); e = ErrorCnt(); break; } } else if(begin[i].type == TokenType::semicolon) { if(bracket == 1) { i; err.Merge(e); e = ErrorCnt(); break; } } else if(begin[i].type == TokenType::eof) { exit = true; break; } } } } if(begin[i].type == TokenType::rbracket) { i; } else { err.Merge(e); err.Push(Error(ErrorType::expect_rbracket, begin[i].line, begin[i].str)); return -1; } return i; } int P_if(Tokit begin, Tokit end, shared_ptr<PGL_sentence>& out, ErrorCnt& err) { int i = 0; int t; ErrorCnt e; if(begin[i].type == TokenType::_if) { i; } else return -1; if(begin[i].type == TokenType::lparen) { i; } else { err.Push(Error(ErrorType::unexpected, begin[i].line, begin[i].str)); return -1; } shared_ptr<PGL_expr> cond; if((t = P_expr(begin i, end, cond, e)) >= 0) { i = t; } else { err.Merge(e); err.Push(Error(ErrorType::unexpected, begin[i].line, begin[i].str)); return -1; } if(begin[i].type == TokenType::rparen) { i; } else { err.Merge(e); err.Push(Error(ErrorType::expect_rparen, begin[i].line, begin[i].str)); return -1; } e = ErrorCnt(); PGL_block block; if((t = P_block(begin i, end, block, e)) >= 0) { i = t; } else { err.Merge(e); err.Push(Error(ErrorType::unexpected, begin[i].line, begin[i].str)); return -1; } auto ret = shared_ptr<PGL_if>(new PGL_if); ret->cond = cond; ret->trueSents = block; if(begin[i].type == TokenType::_else) { i; if(begin[i].type == TokenType::_if) { shared_ptr<PGL_sentence> elif; if((t = P_if(begin i, end, elif, err)) >= 0) { i = t; ret->falseSents.sents.push_back(elif); } else { err.Push(Error(ErrorType::unexpected, begin[i].line, begin[i].str)); return -1; } } else { if((t = P_block(begin i, end, ret->falseSents, err)) >= 0) { i = t; } else { err.Push(Error(ErrorType::unexpected, begin[i].line, begin[i].str)); return -1; } } } out = ret; return i; } int P_while(Tokit begin, Tokit end, shared_ptr<PGL_sentence>& out, ErrorCnt& err) { int i = 0; int t; ErrorCnt e; if(begin[i].type == TokenType::_while) { i; } else return -1; if(begin[i].type == TokenType::lparen) { i; } else { err.Push(Error(ErrorType::unexpected, begin[i].line, begin[i].str)); return -1; } shared_ptr<PGL_expr> cond; if((t = P_expr(begin i, end, cond, e)) >= 0) { i = t; } else { err.Merge(e); err.Push(Error(ErrorType::unexpected, begin[i].line, begin[i].str)); return -1; } if(begin[i].type == TokenType::rparen) { i; } else { err.Merge(e); err.Push(Error(ErrorType::expect_rparen, begin[i].line, begin[i].str)); return -1; } e = ErrorCnt(); PGL_block block; if((t = P_block(begin i, end, block, e)) >= 0) { i = t; } else { err.Merge(e); err.Push(Error(ErrorType::unexpected, begin[i].line, begin[i].str)); return -1; } auto ret = shared_ptr<PGL_while>(new PGL_while); ret->cond = cond; ret->sents = block; if(begin[i].type == TokenType::_done) { i; if((t = P_block(begin i, end, ret->doneS, err)) >= 0) { i = t; } else { err.Push(Error(ErrorType::unexpected, begin[i].line, begin[i].str)); return -1; } } if(begin[i].type == TokenType::_else) { i; if((t = P_block(begin i, end, ret->elseS, err)) >= 0) { i = t; } else { err.Push(Error(ErrorType::unexpected, begin[i].line, begin[i].str)); return -1; } } out = ret; return i; } int P_for(Tokit begin, Tokit end, shared_ptr<PGL_sentence>& out, ErrorCnt& err) { int i = 0; int t; ErrorCnt e; shared_ptr<PGL_sentence> var; if(begin[i].type == TokenType::_for) { i; } else return -1; if(begin[i].type == TokenType::lparen) { i; } else { err.Push(Error(ErrorType::unexpected, begin[i].line, begin[i].str)); return -1; } if((t = P_decl_var(begin i, end, var, e)) >= 0) { i = t; } if(begin[i].type == TokenType::semicolon) { i; } else { /*err.Merge(e); err.Push(Error(ErrorType::expect_semicolon, begin[i].line, begin[i].str));*/ return -1; } shared_ptr<PGL_expr> cond; if((t = P_expr(begin i, end, cond, e)) >= 0) { i = t; } if(begin[i].type == TokenType::semicolon) { i; } else { err.Push(Error(ErrorType::expect_semicolon, begin[i].line, begin[i].str)); return -1; } shared_ptr<PGL_sentence> loop; if((t = P_simple_sentence(begin i, end, loop, e)) >= 0) { i = t; } auto ret = make_shared<PGL_for>(); ret->var = static_pointer_cast<PGL_decl_var>(var); ret->cond = cond; ret->loop = static_pointer_cast<PGL_simple_sentence>(loop); if(begin[i].type == TokenType::rparen) { i; } else { err.Merge(e); err.Push(Error(ErrorType::expect_rparen, begin[i].line, begin[i].str)); return -1; } e = ErrorCnt(); if((t = P_block(begin i, end, ret->sents, e)) >= 0) { i = t; } else { err.Merge(e); err.Push(Error(ErrorType::unexpected, begin[i].line, begin[i].str)); return -1; } if(begin[i].type == TokenType::_done) { i; if((t = P_block(begin i, end, ret->doneS, err)) >= 0) { i = t; } else { err.Push(Error(ErrorType::unexpected, begin[i].line, begin[i].str)); return -1; } } if(begin[i].type == TokenType::_else) { i; if((t = P_block(begin i, end, ret->elseS, err)) >= 0) { i = t; } else { err.Push(Error(ErrorType::unexpected, begin[i].line, begin[i].str)); return -1; } } out = ret; return i; } int P_for_in(Tokit begin, Tokit end, shared_ptr<PGL_sentence>& out, ErrorCnt& err) { int i = 0; int t; ErrorCnt e; if(begin[i].type == TokenType::_for) { i; } else return -1; if(begin[i].type == TokenType::lparen) { i; } else { err.Push(Error(ErrorType::unexpected, begin[i].line, begin[i].str)); return -1; } if(begin[i].type == TokenType::_var) { i; } else { return -1; } string key, val; if(begin[i].type == TokenType::identifier) { val = begin[i].str; i; } else { err.Push(Error(ErrorType::unexpected, begin[i].line, begin[i].str)); return -1; } if(begin[i].type == TokenType::comma) { i; key = move(val); if(begin[i].type == TokenType::identifier) { val = begin[i].str; i; } else { err.Push(Error(ErrorType::unexpected, begin[i].line, begin[i].str)); return -1; } } if(begin[i].type == TokenType::_in) { i; } else { err.Merge(e); err.Push(Error(ErrorType::expect_semicolon, begin[i].line, begin[i].str)); return -1; } shared_ptr<PGL_expr> con; if((t = P_expr(begin i, end, con, e)) >= 0) { i = t; } else { err.Merge(e); err.Push(Error(ErrorType::unexpected, begin[i].line, begin[i].str)); return -1; } auto ret = make_shared<PGL_for_in>(); ret->varKey = key; ret->varVal = val; ret->container = con; if(begin[i].type == TokenType::rparen) { i; } else { err.Merge(e); err.Push(Error(ErrorType::expect_rparen, begin[i].line, begin[i].str)); return -1; } e = ErrorCnt(); if((t = P_block(begin i, end, ret->sents, e)) >= 0) { i = t; } else { err.Merge(e); err.Push(Error(ErrorType::unexpected, begin[i].line, begin[i].str)); return -1; } if(begin[i].type == TokenType::_done) { i; if((t = P_block(begin i, end, ret->doneS, err)) >= 0) { i = t; } else { err.Push(Error(ErrorType::unexpected, begin[i].line, begin[i].str)); return -1; } } if(begin[i].type == TokenType::_else) { i; if((t = P_block(begin i, end, ret->elseS, err)) >= 0) { i = t; } else { err.Push(Error(ErrorType::unexpected, begin[i].line, begin[i].str)); return -1; } } out = ret; return i; } int P_return(Tokit begin, Tokit end, shared_ptr<PGL_sentence>& out, ErrorCnt& err) { int i = 0; int t; if(begin[i].type == TokenType::_return) { i; } else return -1; shared_ptr<PGL_expr> r; if((t = P_expr(begin i, end, r, err)) >= 0) { i = t; } else { err.Push(Error(ErrorType::unexpected, begin[i].line, begin[i].str)); return -1; } if(begin[i].type == TokenType::semicolon) { i; } else { err.Push(Error(ErrorType::expect_semicolon, begin[i].line, begin[i].str)); return -1; } auto ret = shared_ptr<PGL_return>(new PGL_return); ret->ret = r; out = ret; return i; } int P_yield(Tokit begin, Tokit end, shared_ptr<PGL_sentence>& out, ErrorCnt& err) { int i = 0; int t; if(begin[i].type == TokenType::_yield) { i; } else return -1; shared_ptr<PGL_expr> r; if((t = P_expr(begin i, end, r, err)) >= 0) { i = t; } else { err.Push(Error(ErrorType::unexpected, begin[i].line, begin[i].str)); return -1; } if(begin[i].type == TokenType::semicolon) { i; } else { err.Push(Error(ErrorType::expect_semicolon, begin[i].line, begin[i].str)); return -1; } auto ret = make_shared<PGL_yield>(); ret->ret = r; out = ret; return i; } int P_break(Tokit begin, Tokit end, shared_ptr<PGL_sentence>& out, ErrorCnt& err) { int i = 0; int t; if(begin[i].type == TokenType::_break) { i; } else return -1; if(begin[i].type == TokenType::semicolon) { i; } else { err.Push(Error(ErrorType::expect_semicolon, begin[i].line, begin[i].str)); return -1; } auto ret = shared_ptr<PGL_break>(new PGL_break); out = ret; return i; } int P_continue(Tokit begin, Tokit end, shared_ptr<PGL_sentence>& out, ErrorCnt& err) { int i = 0; int t; if(begin[i].type == TokenType::_continue) { i; } else return -1; if(begin[i].type == TokenType::semicolon) { i; } else { err.Push(Error(ErrorType::expect_semicolon, begin[i].line, begin[i].str)); return -1; } auto ret = shared_ptr<PGL_continue>(new PGL_continue); out = ret; return i; } int P_decl_var(Tokit begin, Tokit end, shared_ptr<PGL_sentence>& out, ErrorCnt& err) { int i = 0; int t; if(begin[i].type == TokenType::_var) { i; } else return -1; auto var = shared_ptr<PGL_decl_var>(new PGL_decl_var); if(begin[i].type == TokenType::identifier) { var->name = begin[i].str; i; } else { err.Push(Error(ErrorType::expect_id, begin[i].line, begin[i].str)); return -1; } if(begin[i].type == TokenType::_as) { i; if(begin[i].type == TokenType::identifier) { var->type = begin[i].str; i; } else { err.Push(Error(ErrorType::expect_id, begin[i].line, begin[i].str)); return -1; } } if(begin[i].type == TokenType::assign) { i; if((t = P_expr(begin i, end, var->init, err)) >= 0) { i = t; } else { err.Push(Error(ErrorType::unexpected, begin[i].line, begin[i].str)); return -1; } } out = var; return i; } int P_decl_var_semicolon(Tokit begin, Tokit end, shared_ptr<PGL_sentence>& out, ErrorCnt& err) { int i = 0; int t; shared_ptr<PGL_sentence> ret; if((t = P_decl_var(begin i, end, ret, err)) >= 0) { i = t; } else return -1; if(begin[i].type == TokenType::semicolon) { i; } else { err.Push(Error(ErrorType::expect_semicolon, begin[i].line, begin[i].str)); return -1; } out = ret; return i; } int P_param(Tokit begin, Tokit end, PGL_param& out, ErrorCnt& err) { int i = 0; int t; if(begin[i].type == TokenType::identifier) { out.name = begin[i].str; i; } else { return -1; } if(begin[i].type == TokenType::_as) { i; if(begin[i].type == TokenType::identifier) { out.type = begin[i].str; i; } else { err.Push(Error(ErrorType::expect_id, begin[i].line, begin[i].str)); return -1; } } return i; } int P_decl_func(Tokit begin, Tokit end, shared_ptr<PGL_sentence>& out, ErrorCnt& err) { int i = 0; int t; if(begin[i].type == TokenType::_function) { i; } else return -1; auto var = shared_ptr<PGL_decl_function>(new PGL_decl_function); if(begin[i].type == TokenType::identifier) { var->name = begin[i].str; i; } else return -1; if(begin[i].type == TokenType::lparen) { i; } else { err.Push(Error(ErrorType::expect_rparen, begin[i].line, begin[i].str)); return -1; } PGL_param param; if((t = P_param(begin i, end, param, err)) >= 0) { i = t; var->params.push_back(param); while(begin[i].type == TokenType::comma) { i; if((t = P_param(begin i, end, param, err)) >= 0) { i = t; var->params.push_back(param); } else { err.Push(Error(ErrorType::expect_id, begin[i].line, begin[i].str)); return -1; } } } if(begin[i].type == TokenType::rparen) { i; } else { err.Push(Error(ErrorType::expect_rparen, begin[i].line, begin[i].str)); return -1; } if(begin[i].type == TokenType::_as) { i; if(begin[i].type == TokenType::identifier) { var->type = begin[i].str; i; } else { err.Push(Error(ErrorType::expect_id, begin[i].line, begin[i].str)); return -1; } } if((t = P_block(begin i, end, var->sents, err)) >= 0) { i = t; } else { err.Push(Error(ErrorType::unexpected, begin[i].line, begin[i].str)); return -1; } out = var; return i; } int P_call(Tokit begin, Tokit end, shared_ptr<PGL_sentence>& out, ErrorCnt& err) { int i = 0; int t; auto ret = shared_ptr<PGL_call>(new PGL_call); if((t = P_expr(begin i, end, ret->l, err)) >= 0) { i = t; } else return -1; out = ret; return i; } int P_lexpr(Tokit begin, Tokit end, shared_ptr<PGL_lexpr>& out, ErrorCnt& err) { int i = 0; int t; shared_ptr<PGL_lexpr> lexp; if((t = P_par_lexpr(begin i, end, lexp, err)) >= 0) { i = t; } else return -1; while(begin[i].type == TokenType::dot || begin[i].type == TokenType::lsbracket) { if(begin[i].type == TokenType::dot) { i; if(begin[i].type == TokenType::identifier) { lexp = make_shared<PGL_dot_expr>(lexp, begin[i].str); i = t; } else { err.Push(Error(ErrorType::none, begin[i].line, begin[i].str)); return -1; } } else { i; shared_ptr<PGL_expr> rexp; if((t = P_expr(begin i, end, rexp, err)) >= 0) { i = t; } else { err.Push(Error(ErrorType::none, begin[i].line, begin[i].str)); return -1; } if(begin[i].type == TokenType::rsbracket) { i; } else { err.Push(Error(ErrorType::expect_rbracket, begin[i].line, begin[i].str)); return -1; } lexp = make_shared<PGL_ref_expr>(lexp, rexp); } } out = lexp; return i; } int P_par_lexpr(Tokit begin, Tokit end, shared_ptr<PGL_lexpr>& out, ErrorCnt& err) { int i = 0; int t; shared_ptr<PGL_lexpr> ret; if(begin[i].type == TokenType::lparen) { if((t = P_lexpr(begin i, end, ret, err)) >= 0) { i = t; } else { err.Push(Error(ErrorType::unexpected, begin[i].line, begin[i].str)); return -1; } if(begin[i].type == TokenType::rparen) { i; } else { err.Push(Error(ErrorType::expect_rparen, begin[i].line, begin[i].str)); return -1; } out = ret; return i; } else if(begin[i].type == TokenType::identifier) { ret = make_shared<PGL_identifier>(begin[i].str); i; out = ret; return i; } else if(begin[i].type == TokenType::_this) { ret = make_shared<PGL_this>(); i; out = ret; return i; } else { return -1; } } int P_assign(Tokit begin, Tokit end, shared_ptr<PGL_sentence>& out, ErrorCnt& err) { int i = 0; int t; auto ret = shared_ptr<PGL_assign>(new PGL_assign); if((t = P_lexpr(begin i, end, ret->l, err)) >= 0) { i = t; } else return -1; if(begin[i].type == TokenType::assign) { i; } else return -1; if((t = P_expr(begin i, end, ret->r, err)) >= 0) { i = t; } else { err.Push(Error(ErrorType::unexpected, begin[i].line, begin[i].str)); return -1; } out = ret; return i; } int P_top(Tokit begin, Tokit end, PGL_whole& out, ErrorCnt& err) { int i = 0; int t; shared_ptr<PGL_sentence> ret; while((t = P_sentence(begin i, end, ret, err)) >= 0) { i = t; out.sents.push_back(ret); if(begin[i].type == TokenType::eof) break; } return i; } PGL_whole Parse(const string& str, ErrorCnt& err) { auto toks = Tokenize(str); PGL_whole tree; P_top(toks.begin(), toks.end(), tree, err); return tree; }

자, 이렇게 단순하고도 긴 파싱작업을 마쳤습니다.

다음에는 기본적인 인터프리터(혹은 좀더 고급스럽게 가상머신)을 설계해보도록 할거에요.