lexer: 어휘 분석 구현과 ASI 함정 하나 정정
grammar.ebnf의 어휘 절을 구현한다. 렉서는 선읽기를 요구하지 않고, 문법과 얽히는 유일한 부분인 NEWLINE 삽입은 can_end_statement 하나로 판정한다. 모든 토큰이 위치를 들고 다닌다 — 진단 품질이 헌법급이므로 나중에 붙이지 않는다. 샘플을 실제로 렉싱해 함정을 하나 잡았다. effects 절이 줄 끝에 오면 "}"가 값 종료 토큰이라 NEWLINE이 삽입되어 다음 줄의 "->"와 끊긴다(Go ASI와 같은 형태). 렉서에 문맥을 주는 대신 — 렉서 피드백은 철학 2가 배제한다 — 시그니처 머리의 흡수 위치를 프로덕션에 명시적으로 적어 닫았다. 파서가 임의로 건너뛰는 것이 아니라 문법에 적힌 자리에서만 흡수한다. 다중 줄 목록의 후행 콤마 필수도 함께 명시(콤마로 끝난 줄은 NEWLINE을 만들지 않으므로 목록이 자연히 이어진다). cool check는 어휘 분석을 돌리되 통과했다고 말하지 않는다. 파이프라인의 나머지가 없는 이상 그 파일은 검사된 것이 아니다. 디버깅용 cool tokens 추가. 테스트 30건: 키워드, 두 글자 연산자 우선, NEWLINE 삽입 6가지 경우, 리터럴과 이스케이프, 오류 7종과 오류 위치, 그리고 samples/*.cool 전체가 어휘 분석을 통과하는지. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_019ZVDeU6KLuUVL3gs18Hm3E
This commit is contained in:
Claude Opus 5
+49
-7
@@ -1,17 +1,59 @@
|
||||
(* v0 파이프라인의 자리표시자.
|
||||
(* v0 파이프라인.
|
||||
parse -> name resolution -> type check -> effect/capability check
|
||||
-> interface artifact + hash -> (cool run 시) 얇은 typed IR -> interpreter
|
||||
|
||||
각 단계는 별도 모듈로 분리해 들어온다. 지금은 CLI 형태만 고정한다. *)
|
||||
현재 구현된 단계: 어휘 분석. *)
|
||||
|
||||
type error = { file : string; message : string }
|
||||
type error = { file : string; line : int; col : int; message : string }
|
||||
|
||||
let string_of_error { file; message } = Printf.sprintf "%s: %s" file message
|
||||
let string_of_error { file; line; col; message } =
|
||||
Printf.sprintf "%s:%d:%d: %s" file line col message
|
||||
|
||||
let read_file file =
|
||||
try
|
||||
let ic = open_in_bin file in
|
||||
let n = in_channel_length ic in
|
||||
let s = really_input_string ic n in
|
||||
close_in ic;
|
||||
Ok s
|
||||
with Sys_error msg -> Error { file; line = 0; col = 0; message = msg }
|
||||
|
||||
let lex_file file =
|
||||
match read_file file with
|
||||
| Error e -> Error e
|
||||
| Ok src -> (
|
||||
match Lexer.lex_result src with
|
||||
| Ok tokens -> Ok tokens
|
||||
| Error { pos; msg } ->
|
||||
Error { file; line = pos.line; col = pos.col; message = msg })
|
||||
|
||||
let tokens (file : string) : (Token.t list, error list) result =
|
||||
match lex_file file with Ok ts -> Ok ts | Error e -> Error [ e ]
|
||||
|
||||
let check (files : string list) : (unit, error list) result =
|
||||
match files with
|
||||
| [] -> Error [ { file = "<none>"; message = "검사할 파일이 없습니다" } ]
|
||||
| file :: _ -> Error [ { file; message = "check 파이프라인이 아직 구현되지 않았습니다" } ]
|
||||
| [] ->
|
||||
Error [ { file = "<none>"; line = 0; col = 0; message = "검사할 파일이 없습니다" } ]
|
||||
| _ ->
|
||||
let errors =
|
||||
List.filter_map
|
||||
(fun f -> match lex_file f with Ok _ -> None | Error e -> Some e)
|
||||
files
|
||||
in
|
||||
if errors <> [] then Error errors
|
||||
else
|
||||
(* 어휘 분석은 통과했다. 통과했다고 말하지 않는다 — 파이프라인의
|
||||
나머지가 아직 없으므로 검사되지 않은 것이다. *)
|
||||
Error
|
||||
(List.map
|
||||
(fun f ->
|
||||
{
|
||||
file = f;
|
||||
line = 0;
|
||||
col = 0;
|
||||
message = "어휘 분석까지 통과. 파서가 아직 구현되지 않았습니다";
|
||||
})
|
||||
files)
|
||||
|
||||
let run (file : string) : (unit, error list) result =
|
||||
Error [ { file; message = "interpreter가 아직 구현되지 않았습니다" } ]
|
||||
Error [ { file; line = 0; col = 0; message = "interpreter가 아직 구현되지 않았습니다" } ]
|
||||
|
||||
+192
@@ -0,0 +1,192 @@
|
||||
(* 렉서. grammar.ebnf의 어휘 절을 그대로 구현한다.
|
||||
유일하게 문법과 얽히는 부분은 NEWLINE 삽입인데, 그 판정은
|
||||
Token.can_end_statement 하나로 끝나며 선읽기를 요구하지 않는다. *)
|
||||
|
||||
type error = { pos : Token.pos; msg : string }
|
||||
|
||||
exception Error of error
|
||||
|
||||
type state = {
|
||||
src : string;
|
||||
len : int;
|
||||
mutable i : int;
|
||||
mutable line : int;
|
||||
mutable bol : int; (* 현재 줄의 시작 offset *)
|
||||
mutable out : Token.t list; (* 역순 누적 *)
|
||||
}
|
||||
|
||||
let pos st : Token.pos = { line = st.line; col = st.i - st.bol + 1 }
|
||||
let fail st msg = raise (Error { pos = pos st; msg })
|
||||
let fail_at p msg = raise (Error { pos = p; msg })
|
||||
let peek st = if st.i < st.len then Some st.src.[st.i] else None
|
||||
let peek2 st = if st.i + 1 < st.len then Some st.src.[st.i + 1] else None
|
||||
let emit st p kind = st.out <- { Token.kind; pos = p } :: st.out
|
||||
let last_kind st = match st.out with [] -> None | t :: _ -> Some t.Token.kind
|
||||
|
||||
(* 줄 끝에 도달했을 때만 호출된다. 직전 토큰이 값으로 끝날 수 있으면 삽입.
|
||||
이미 Newline을 넣었거나 아무것도 없으면 넣지 않으므로,
|
||||
빈 줄과 주석만 있는 줄은 구분자를 만들지 않는다. *)
|
||||
let maybe_newline st =
|
||||
match last_kind st with
|
||||
| Some k when Token.can_end_statement k -> emit st (pos st) Token.Newline
|
||||
| _ -> ()
|
||||
|
||||
let is_letter c = (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')
|
||||
let is_digit c = c >= '0' && c <= '9'
|
||||
let is_ident_rest c = is_letter c || is_digit c || c = '_'
|
||||
|
||||
let lex_ident st =
|
||||
let p = pos st in
|
||||
let start = st.i in
|
||||
while st.i < st.len && is_ident_rest st.src.[st.i] do
|
||||
st.i <- st.i + 1
|
||||
done;
|
||||
let s = String.sub st.src start (st.i - start) in
|
||||
match Token.keyword s with
|
||||
| Some k -> emit st p k
|
||||
| None -> emit st p (Token.Ident s)
|
||||
|
||||
let lex_int st =
|
||||
let p = pos st in
|
||||
let start = st.i in
|
||||
while st.i < st.len && (is_digit st.src.[st.i] || st.src.[st.i] = '_') do
|
||||
st.i <- st.i + 1
|
||||
done;
|
||||
(* 숫자 바로 뒤에 글자가 붙으면 오타일 가능성이 높다. 조용히 넘기지 않는다. *)
|
||||
if st.i < st.len && is_letter st.src.[st.i] then
|
||||
fail st "정수 리터럴 뒤에 글자가 올 수 없습니다";
|
||||
emit st p (Token.Int (String.sub st.src start (st.i - start)))
|
||||
|
||||
let lex_string st =
|
||||
let p = pos st in
|
||||
st.i <- st.i + 1;
|
||||
let buf = Buffer.create 16 in
|
||||
let rec go () =
|
||||
if st.i >= st.len then fail_at p "문자열이 닫히지 않았습니다"
|
||||
else
|
||||
match st.src.[st.i] with
|
||||
| '"' -> st.i <- st.i + 1
|
||||
| '\n' -> fail_at p "문자열이 닫히지 않았습니다 (줄바꿈 전에 닫아야 합니다)"
|
||||
| '\\' ->
|
||||
st.i <- st.i + 1;
|
||||
if st.i >= st.len then fail_at p "문자열이 닫히지 않았습니다";
|
||||
let c = st.src.[st.i] in
|
||||
let decoded =
|
||||
match c with
|
||||
| 'n' -> '\n'
|
||||
| 't' -> '\t'
|
||||
| '\\' -> '\\'
|
||||
| '"' -> '"'
|
||||
| _ -> fail st (Printf.sprintf "알 수 없는 이스케이프 \\%c" c)
|
||||
in
|
||||
Buffer.add_char buf decoded;
|
||||
st.i <- st.i + 1;
|
||||
go ()
|
||||
| c ->
|
||||
Buffer.add_char buf c;
|
||||
st.i <- st.i + 1;
|
||||
go ()
|
||||
in
|
||||
go ();
|
||||
emit st p (Token.Str (Buffer.contents buf))
|
||||
|
||||
let skip_line_comment st =
|
||||
while st.i < st.len && st.src.[st.i] <> '\n' do
|
||||
st.i <- st.i + 1
|
||||
done
|
||||
|
||||
(* 한 글자 또는 두 글자 연산자. 두 글자를 항상 먼저 본다. *)
|
||||
let lex_punct st =
|
||||
let p = pos st in
|
||||
let one k =
|
||||
st.i <- st.i + 1;
|
||||
emit st p k
|
||||
in
|
||||
let two k =
|
||||
st.i <- st.i + 2;
|
||||
emit st p k
|
||||
in
|
||||
match (st.src.[st.i], peek2 st) with
|
||||
| '-', Some '>' -> two Token.Arrow
|
||||
| '=', Some '>' -> two Token.FatArrow
|
||||
| '=', Some '=' -> two Token.EqEq
|
||||
| '!', Some '=' -> two Token.BangEq
|
||||
| '<', Some '=' -> two Token.Le
|
||||
| '>', Some '=' -> two Token.Ge
|
||||
| '&', Some '&' -> two Token.AmpAmp
|
||||
| '|', Some '|' -> two Token.PipePipe
|
||||
| '(', _ -> one Token.LParen
|
||||
| ')', _ -> one Token.RParen
|
||||
| '{', _ -> one Token.LBrace
|
||||
| '}', _ -> one Token.RBrace
|
||||
| '[', _ -> one Token.LBracket
|
||||
| ']', _ -> one Token.RBracket
|
||||
| ',', _ -> one Token.Comma
|
||||
| ':', _ -> one Token.Colon
|
||||
| '.', _ -> one Token.Dot
|
||||
| '?', _ -> one Token.Question
|
||||
| '=', _ -> one Token.Eq
|
||||
| '!', _ -> one Token.Bang
|
||||
| '<', _ -> one Token.Lt
|
||||
| '>', _ -> one Token.Gt
|
||||
| '+', _ -> one Token.Plus
|
||||
| '-', _ -> one Token.Minus
|
||||
| '*', _ -> one Token.Star
|
||||
| '/', _ -> one Token.Slash
|
||||
| '%', _ -> one Token.Percent
|
||||
| '|', _ -> one Token.Pipe
|
||||
| '&', _ -> fail st "& 연산자는 없습니다 (&&를 의도했습니까?)"
|
||||
| c, _ -> fail st (Printf.sprintf "예상치 못한 문자 %C" c)
|
||||
|
||||
let lex (src : string) : Token.t list =
|
||||
let st =
|
||||
{ src; len = String.length src; i = 0; line = 1; bol = 0; out = [] }
|
||||
in
|
||||
let rec go () =
|
||||
if st.i >= st.len then (
|
||||
maybe_newline st;
|
||||
emit st (pos st) Token.Eof)
|
||||
else
|
||||
let c = st.src.[st.i] in
|
||||
match c with
|
||||
| ' ' | '\t' | '\r' ->
|
||||
st.i <- st.i + 1;
|
||||
go ()
|
||||
| '\n' ->
|
||||
maybe_newline st;
|
||||
st.i <- st.i + 1;
|
||||
st.line <- st.line + 1;
|
||||
st.bol <- st.i;
|
||||
go ()
|
||||
| '/' when peek2 st = Some '/' ->
|
||||
skip_line_comment st;
|
||||
go ()
|
||||
| '_' ->
|
||||
let p = pos st in
|
||||
if st.i + 1 < st.len && is_ident_rest st.src.[st.i + 1] then
|
||||
fail st "이름은 문자로 시작해야 합니다"
|
||||
else (
|
||||
st.i <- st.i + 1;
|
||||
emit st p Token.Underscore;
|
||||
go ())
|
||||
| c when is_letter c ->
|
||||
lex_ident st;
|
||||
go ()
|
||||
| c when is_digit c ->
|
||||
lex_int st;
|
||||
go ()
|
||||
| '"' ->
|
||||
lex_string st;
|
||||
go ()
|
||||
| _ ->
|
||||
lex_punct st;
|
||||
go ()
|
||||
in
|
||||
go ();
|
||||
List.rev st.out
|
||||
|
||||
let lex_result src =
|
||||
match lex src with tokens -> Ok tokens | exception Error e -> Error e
|
||||
|
||||
(* peek는 lex_punct 안에서만 쓰이지 않으므로 경고를 피한다 *)
|
||||
let _ = peek
|
||||
+162
@@ -0,0 +1,162 @@
|
||||
(* 토큰 정의. 위치는 진단 품질이 헌법급이므로 모든 토큰이 들고 다닌다. *)
|
||||
|
||||
type pos = { line : int; col : int }
|
||||
|
||||
type kind =
|
||||
(* 리터럴과 이름 *)
|
||||
| Ident of string
|
||||
| Int of string
|
||||
| Str of string
|
||||
(* 키워드 *)
|
||||
| Kw_pub
|
||||
| Kw_fn
|
||||
| Kw_struct
|
||||
| Kw_enum
|
||||
| Kw_capability
|
||||
| Kw_const
|
||||
| Kw_import
|
||||
| Kw_as
|
||||
| Kw_reexport
|
||||
| Kw_let
|
||||
| Kw_mut
|
||||
| Kw_own
|
||||
| Kw_affine
|
||||
| Kw_copyable
|
||||
| Kw_effects
|
||||
| Kw_return
|
||||
| Kw_if
|
||||
| Kw_else
|
||||
| Kw_match
|
||||
| Kw_scope
|
||||
| Kw_true
|
||||
| Kw_false
|
||||
(* 구두점 *)
|
||||
| LParen
|
||||
| RParen
|
||||
| LBrace
|
||||
| RBrace
|
||||
| LBracket
|
||||
| RBracket
|
||||
| Comma
|
||||
| Colon
|
||||
| Dot
|
||||
| Arrow
|
||||
| FatArrow
|
||||
| Question
|
||||
| Underscore
|
||||
| Eq
|
||||
| EqEq
|
||||
| Bang
|
||||
| BangEq
|
||||
| Lt
|
||||
| Le
|
||||
| Gt
|
||||
| Ge
|
||||
| Plus
|
||||
| Minus
|
||||
| Star
|
||||
| Slash
|
||||
| Percent
|
||||
| AmpAmp
|
||||
| PipePipe
|
||||
| Pipe
|
||||
(* 렉서가 삽입하는 문 구분자 *)
|
||||
| Newline
|
||||
| Eof
|
||||
|
||||
type t = { kind : kind; pos : pos }
|
||||
|
||||
let keyword = function
|
||||
| "pub" -> Some Kw_pub
|
||||
| "fn" -> Some Kw_fn
|
||||
| "struct" -> Some Kw_struct
|
||||
| "enum" -> Some Kw_enum
|
||||
| "capability" -> Some Kw_capability
|
||||
| "const" -> Some Kw_const
|
||||
| "import" -> Some Kw_import
|
||||
| "as" -> Some Kw_as
|
||||
| "reexport" -> Some Kw_reexport
|
||||
| "let" -> Some Kw_let
|
||||
| "mut" -> Some Kw_mut
|
||||
| "own" -> Some Kw_own
|
||||
| "affine" -> Some Kw_affine
|
||||
| "copyable" -> Some Kw_copyable
|
||||
| "effects" -> Some Kw_effects
|
||||
| "return" -> Some Kw_return
|
||||
| "if" -> Some Kw_if
|
||||
| "else" -> Some Kw_else
|
||||
| "match" -> Some Kw_match
|
||||
| "scope" -> Some Kw_scope
|
||||
| "true" -> Some Kw_true
|
||||
| "false" -> Some Kw_false
|
||||
| _ -> None
|
||||
|
||||
let show_kind = function
|
||||
| Ident s -> Printf.sprintf "이름 %s" s
|
||||
| Int s -> Printf.sprintf "정수 %s" s
|
||||
| Str _ -> "문자열"
|
||||
| Kw_pub -> "pub"
|
||||
| Kw_fn -> "fn"
|
||||
| Kw_struct -> "struct"
|
||||
| Kw_enum -> "enum"
|
||||
| Kw_capability -> "capability"
|
||||
| Kw_const -> "const"
|
||||
| Kw_import -> "import"
|
||||
| Kw_as -> "as"
|
||||
| Kw_reexport -> "reexport"
|
||||
| Kw_let -> "let"
|
||||
| Kw_mut -> "mut"
|
||||
| Kw_own -> "own"
|
||||
| Kw_affine -> "affine"
|
||||
| Kw_copyable -> "copyable"
|
||||
| Kw_effects -> "effects"
|
||||
| Kw_return -> "return"
|
||||
| Kw_if -> "if"
|
||||
| Kw_else -> "else"
|
||||
| Kw_match -> "match"
|
||||
| Kw_scope -> "scope"
|
||||
| Kw_true -> "true"
|
||||
| Kw_false -> "false"
|
||||
| LParen -> "("
|
||||
| RParen -> ")"
|
||||
| LBrace -> "{"
|
||||
| RBrace -> "}"
|
||||
| LBracket -> "["
|
||||
| RBracket -> "]"
|
||||
| Comma -> ","
|
||||
| Colon -> ":"
|
||||
| Dot -> "."
|
||||
| Arrow -> "->"
|
||||
| FatArrow -> "=>"
|
||||
| Question -> "?"
|
||||
| Underscore -> "_"
|
||||
| Eq -> "="
|
||||
| EqEq -> "=="
|
||||
| Bang -> "!"
|
||||
| BangEq -> "!="
|
||||
| Lt -> "<"
|
||||
| Le -> "<="
|
||||
| Gt -> ">"
|
||||
| Ge -> ">="
|
||||
| Plus -> "+"
|
||||
| Minus -> "-"
|
||||
| Star -> "*"
|
||||
| Slash -> "/"
|
||||
| Percent -> "%"
|
||||
| AmpAmp -> "&&"
|
||||
| PipePipe -> "||"
|
||||
| Pipe -> "|"
|
||||
| Newline -> "줄바꿈"
|
||||
| Eof -> "파일 끝"
|
||||
|
||||
let show { kind; pos } =
|
||||
Printf.sprintf "%d:%d %s" pos.line pos.col (show_kind kind)
|
||||
|
||||
(* 줄 끝에서 문 구분자를 삽입할지 결정한다 (grammar.ebnf 어휘 절).
|
||||
값으로 끝날 수 있는 토큰 뒤에서만 삽입하므로, 연산자나 여는 괄호로
|
||||
끝나는 줄은 다음 줄로 이어진다. *)
|
||||
let can_end_statement = function
|
||||
| Ident _ | Int _ | Str _ | RParen | RBracket | RBrace | Question | Kw_return
|
||||
| Kw_true | Kw_false ->
|
||||
true
|
||||
| _ -> false
|
||||
Reference in New Issue
Block a user