libperl_macrogen/
parser.rs

1//! C言語パーサー
2//!
3//! tinyccのparser部分に相当。再帰下降パーサーで実装。
4
5use std::collections::{HashMap, HashSet};
6
7use crate::ast::*;
8use crate::error::{CompileError, ParseError, Result};
9use crate::intern::{InternedStr, StringInterner};
10use crate::macro_infer::detect_assert_kind;
11use crate::preprocessor::Preprocessor;
12use crate::lexer::{Lexer, LookupOnly};
13use crate::source::{FileId, SourceLocation};
14use crate::token::{MacroBeginInfo, MacroInvocationKind, Token, TokenId, TokenKind};
15use crate::token_source::{TokenSliceRef, TokenSource};
16
17/// マクロ展開コンテキスト
18///
19/// パース中のマクロ展開状態を追跡する。
20/// MacroBegin マーカーを見つけたらプッシュし、MacroEnd を見つけたらポップする。
21#[derive(Debug, Default)]
22pub struct MacroContext {
23    /// 現在のマクロ展開スタック（外側から内側へ）
24    stack: Vec<MacroBeginInfo>,
25}
26
27impl MacroContext {
28    /// 新しいコンテキストを作成
29    pub fn new() -> Self {
30        Self { stack: Vec::new() }
31    }
32
33    /// マクロ展開を開始
34    pub fn push(&mut self, info: MacroBeginInfo) {
35        self.stack.push(info);
36    }
37
38    /// マクロ展開を終了
39    pub fn pop(&mut self) -> Option<MacroBeginInfo> {
40        self.stack.pop()
41    }
42
43    /// 現在マクロ展開中かどうか
44    pub fn is_in_macro(&self) -> bool {
45        !self.stack.is_empty()
46    }
47
48    /// 現在のマクロ展開情報から MacroExpansionInfo を構築
49    pub fn build_macro_info(&self, interner: &StringInterner) -> Option<MacroExpansionInfo> {
50        if self.stack.is_empty() {
51            return None;
52        }
53
54        let mut info = MacroExpansionInfo::new();
55        for begin_info in &self.stack {
56            let args = match &begin_info.kind {
57                crate::token::MacroInvocationKind::Object => None,
58                crate::token::MacroInvocationKind::Function { args } => {
59                    // トークン列を文字列に変換
60                    Some(args.iter().map(|arg_tokens| {
61                        arg_tokens.iter()
62                            .map(|t| t.kind.format(interner))
63                            .collect::<Vec<_>>()
64                            .join(" ")
65                    }).collect())
66                }
67            };
68            info.push(MacroInvocation {
69                name: begin_info.macro_name,
70                call_loc: begin_info.call_loc.clone(),
71                args,
72            });
73        }
74        Some(info)
75    }
76
77    /// 展開スタックの深さ
78    pub fn depth(&self) -> usize {
79        self.stack.len()
80    }
81}
82
83/// パーサー
84///
85/// 汎用のトークンソースからC言語をパースする。
86/// `S` は `TokenSource` トレイトを実装する任意の型。
87pub struct Parser<'a, S: TokenSource> {
88    source: &'a mut S,
89    current: Token,
90    /// typedef名のセット
91    typedefs: HashSet<InternedStr>,
92    /// マクロ展開コンテキスト
93    macro_ctx: MacroContext,
94    /// マクロマーカーを処理するか（emit_markers=true の場合に true にする）
95    handle_macro_markers: bool,
96    /// do-while 文の末尾セミコロンを省略可能にするフラグ
97    allow_missing_semi: bool,
98    /// パース中に検出した関数呼び出しの数
99    pub function_call_count: usize,
100    /// パース中に検出したポインタデリファレンスの数
101    pub deref_count: usize,
102    /// マクロ仮引数の辞書（マクロ本体パース時のみ使用）
103    /// key: 仮引数名, value: パラメータインデックス
104    generic_params: HashMap<InternedStr, usize>,
105    /// パース中に型として使用が検出された generic param
106    detected_type_params: HashSet<InternedStr>,
107}
108
109/// Preprocessor 専用の後方互換コンストラクタ
110impl<'a> Parser<'a, Preprocessor> {
111    /// 新しいパーサーを作成（Preprocessor専用）
112    pub fn new(pp: &'a mut Preprocessor) -> Result<Self> {
113        Self::from_source(pp)
114    }
115
116    /// ストリーミング形式でパース
117    ///
118    /// 各宣言をパースするたびにコールバックを呼び出す。
119    /// パースエラーが発生した場合はコールバックを呼ばずにエラーを返す。
120    /// コールバックが `ControlFlow::Break(())` を返した場合はループを終了。
121    pub fn parse_each<F>(&mut self, mut callback: F) -> Result<()>
122    where
123        F: FnMut(&ExternalDecl, &crate::source::SourceLocation, &std::path::Path, &StringInterner) -> std::ops::ControlFlow<()>,
124    {
125        while !self.is_eof() {
126            let loc = self.current.loc.clone();
127            let decl = self.parse_external_decl()?;
128            let path = self.source.files().get_path(loc.file_id);
129            let interner = self.source.interner();
130            if callback(&decl, &loc, path, interner).is_break() {
131                break;
132            }
133        }
134        Ok(())
135    }
136
137    /// ストリーミング形式でパース（Preprocessor アクセス付き）
138    ///
139    /// `parse_each` と同様だが、コールバックに Preprocessor への可変参照も渡す。
140    /// マクロ呼び出しコールバック（MacroCallWatcher など）にアクセスする場合に使用。
141    /// パースエラーが発生した場合はコールバックを呼ばずにエラーを返す。
142    pub fn parse_each_with_pp<F>(&mut self, mut callback: F) -> Result<()>
143    where
144        F: FnMut(&ExternalDecl, &crate::source::SourceLocation, &std::path::Path, &mut Preprocessor) -> std::ops::ControlFlow<()>,
145    {
146        while !self.is_eof() {
147            let loc = self.current.loc.clone();
148            let decl = self.parse_external_decl()?;
149            let path = self.source.files().get_path(loc.file_id).to_path_buf();
150            if callback(&decl, &loc, &path, self.source).is_break() {
151                break;
152            }
153        }
154        Ok(())
155    }
156}
157
158/// 汎用のトークンソースに対するパーサー実装
159impl<'a, S: TokenSource> Parser<'a, S> {
160    /// トークンソースからパーサーを作成
161    pub fn from_source(source: &'a mut S) -> Result<Self> {
162        // GCC builtin types を事前登録
163        let mut typedefs = HashSet::new();
164        typedefs.insert(source.interner_mut().intern("__builtin_va_list"));
165
166        let mut parser = Self {
167            source,
168            current: Token::default(),
169            typedefs,
170            macro_ctx: MacroContext::new(),
171            handle_macro_markers: false,
172            allow_missing_semi: false,
173            function_call_count: 0,
174            deref_count: 0,
175            generic_params: HashMap::new(),
176            detected_type_params: HashSet::new(),
177        };
178        // マーカーをスキップして最初のトークンを取得
179        parser.current = parser.inner_next_token()?;
180
181        Ok(parser)
182    }
183
184    /// トークンソースからパーサーを作成（既存のtypedef情報を引き継ぐ）
185    pub fn from_source_with_typedefs(source: &'a mut S, typedefs: HashSet<InternedStr>) -> Result<Self> {
186        let mut parser = Self {
187            source,
188            current: Token::default(),
189            typedefs,
190            macro_ctx: MacroContext::new(),
191            handle_macro_markers: false,
192            allow_missing_semi: false,
193            function_call_count: 0,
194            deref_count: 0,
195            generic_params: HashMap::new(),
196            detected_type_params: HashSet::new(),
197        };
198        // マーカーをスキップして最初のトークンを取得
199        parser.current = parser.inner_next_token()?;
200
201        Ok(parser)
202    }
203
204    /// マクロマーカー処理を有効にする
205    ///
206    /// Note: 既に current にマーカートークンがある場合はスキップする
207    pub fn set_handle_macro_markers(&mut self, enabled: bool) -> Result<()> {
208        self.handle_macro_markers = enabled;
209
210        // 既に current にマーカートークンがある場合はスキップ
211        if enabled {
212            while matches!(
213                self.current.kind,
214                TokenKind::MacroBegin(_) | TokenKind::MacroEnd(_)
215            ) {
216                match &self.current.kind {
217                    TokenKind::MacroBegin(info) => {
218                        self.macro_ctx.push((**info).clone());
219                    }
220                    TokenKind::MacroEnd(_) => {
221                        self.macro_ctx.pop();
222                    }
223                    _ => {}
224                }
225                self.current = self.source.next_token()?;
226            }
227        }
228        Ok(())
229    }
230
231    /// StringInterner への参照を取得
232    pub fn interner(&self) -> &crate::intern::StringInterner {
233        self.source.interner()
234    }
235
236    /// typedef名のセットを取得
237    pub fn typedefs(&self) -> &HashSet<InternedStr> {
238        &self.typedefs
239    }
240
241    /// 翻訳単位をパース
242    pub fn parse(&mut self) -> Result<TranslationUnit> {
243        let mut decls = Vec::new();
244
245        while !self.is_eof() {
246            let decl = self.parse_external_decl()?;
247            decls.push(decl);
248        }
249
250        Ok(TranslationUnit { decls })
251    }
252
253    /// 式のみをパース
254    ///
255    /// マクロ本体など、式だけをパースしたい場合に使用
256    pub fn parse_expr_only(&mut self) -> Result<Expr> {
257        self.parse_expr()
258    }
259
260    /// 文をパース（末尾セミコロン省略可能）
261    ///
262    /// マクロ body のパースなど、do-while の末尾セミコロンが
263    /// 省略されている場合に使用する。
264    pub fn parse_stmt_allow_missing_semi(&mut self) -> Result<Stmt> {
265        self.allow_missing_semi = true;
266        let result = self.parse_stmt();
267        self.allow_missing_semi = false;
268        result
269    }
270
271    /// 外部宣言をパース
272    fn parse_external_decl(&mut self) -> Result<ExternalDecl> {
273        let comments = self.current.leading_comments.clone();
274        let loc = self.current.loc.clone();
275        let is_target = self.source.is_file_in_target(loc.file_id);
276
277        // 宣言指定子をパース
278        let specs = self.parse_decl_specs()?;
279
280        // ; のみの場合（構造体宣言など）
281        if self.check(&TokenKind::Semi) {
282            self.advance()?;
283            return Ok(ExternalDecl::Declaration(Declaration {
284                specs,
285                declarators: Vec::new(),
286                info: NodeInfo::new(loc),
287                comments,
288                is_target,
289            }));
290        }
291
292        // 宣言子をパース
293        let declarator = self.parse_declarator()?;
294
295        // __attribute__ をスキップ
296        self.try_skip_attribute()?;
297
298        // 関数定義かどうかを判定
299        // 関数定義: 宣言子の後に { が来る
300        if self.check(&TokenKind::LBrace) {
301            // 本体パース前のカウントを記録
302            let call_count_before = self.function_call_count;
303            let deref_count_before = self.deref_count;
304
305            let body = self.parse_compound_stmt()?;
306
307            // 差分が関数本体のカウント
308            let function_call_count = self.function_call_count - call_count_before;
309            let deref_count = self.deref_count - deref_count_before;
310
311            return Ok(ExternalDecl::FunctionDef(FunctionDef {
312                specs,
313                declarator,
314                body,
315                info: NodeInfo::new(loc),
316                comments,
317                is_target,
318                function_call_count,
319                deref_count,
320            }));
321        }
322
323        // 宣言の続きをパース
324        let mut declarators = Vec::new();
325
326        // 最初の宣言子（初期化子あり）
327        let init = if self.check(&TokenKind::Eq) {
328            self.advance()?;
329            Some(self.parse_initializer()?)
330        } else {
331            None
332        };
333        declarators.push(InitDeclarator { declarator, init });
334
335        // 追加の宣言子
336        while self.check(&TokenKind::Comma) {
337            self.advance()?;
338            let declarator = self.parse_declarator()?;
339            let init = if self.check(&TokenKind::Eq) {
340                self.advance()?;
341                Some(self.parse_initializer()?)
342            } else {
343                None
344            };
345            declarators.push(InitDeclarator { declarator, init });
346        }
347
348        // GCC拡張: 宣言の最後の __attribute__((...)) をスキップ
349        self.try_skip_attribute()?;
350
351        self.expect(&TokenKind::Semi)?;
352
353        // typedef の場合、名前を登録
354        if specs.storage == Some(StorageClass::Typedef) {
355            for d in &declarators {
356                if let Some(name) = d.declarator.name {
357                    self.typedefs.insert(name);
358                }
359            }
360        }
361
362        Ok(ExternalDecl::Declaration(Declaration {
363            specs,
364            declarators,
365            info: NodeInfo::new(loc),
366            comments,
367            is_target,
368        }))
369    }
370
371    /// 宣言指定子をパース
372    fn parse_decl_specs(&mut self) -> Result<DeclSpecs> {
373        let mut specs = DeclSpecs::default();
374
375        loop {
376            match &self.current.kind {
377                // GCC拡張: __extension__ は無視（TinyCC方式）
378                TokenKind::KwExtension => {
379                    self.advance()?;
380                    continue;
381                }
382                // C11/GCC: _Thread_local, __thread は無視（TinyCC方式）
383                TokenKind::KwThreadLocal | TokenKind::KwThread => {
384                    self.advance()?;
385                    continue;
386                }
387                // ストレージクラス
388                TokenKind::KwTypedef => {
389                    specs.storage = Some(StorageClass::Typedef);
390                    self.advance()?;
391                }
392                TokenKind::KwExtern => {
393                    specs.storage = Some(StorageClass::Extern);
394                    self.advance()?;
395                }
396                TokenKind::KwStatic => {
397                    specs.storage = Some(StorageClass::Static);
398                    self.advance()?;
399                }
400                TokenKind::KwAuto => {
401                    specs.storage = Some(StorageClass::Auto);
402                    self.advance()?;
403                }
404                TokenKind::KwRegister => {
405                    specs.storage = Some(StorageClass::Register);
406                    self.advance()?;
407                }
408                // inline
409                TokenKind::KwInline | TokenKind::KwInline2 | TokenKind::KwInline3 => {
410                    specs.is_inline = true;
411                    self.advance()?;
412                }
413                // 型修飾子
414                TokenKind::KwConst | TokenKind::KwConst2 | TokenKind::KwConst3 => {
415                    specs.qualifiers.is_const = true;
416                    self.advance()?;
417                }
418                TokenKind::KwVolatile | TokenKind::KwVolatile2 | TokenKind::KwVolatile3 => {
419                    specs.qualifiers.is_volatile = true;
420                    self.advance()?;
421                }
422                TokenKind::KwRestrict | TokenKind::KwRestrict2 | TokenKind::KwRestrict3 => {
423                    specs.qualifiers.is_restrict = true;
424                    self.advance()?;
425                }
426                TokenKind::KwAtomic => {
427                    specs.qualifiers.is_atomic = true;
428                    self.advance()?;
429                }
430                // 型指定子
431                TokenKind::KwVoid => {
432                    specs.type_specs.push(TypeSpec::Void);
433                    self.advance()?;
434                }
435                TokenKind::KwChar => {
436                    specs.type_specs.push(TypeSpec::Char);
437                    self.advance()?;
438                }
439                TokenKind::KwShort => {
440                    specs.type_specs.push(TypeSpec::Short);
441                    self.advance()?;
442                }
443                TokenKind::KwInt => {
444                    specs.type_specs.push(TypeSpec::Int);
445                    self.advance()?;
446                }
447                TokenKind::KwLong => {
448                    specs.type_specs.push(TypeSpec::Long);
449                    self.advance()?;
450                }
451                TokenKind::KwFloat => {
452                    specs.type_specs.push(TypeSpec::Float);
453                    self.advance()?;
454                }
455                TokenKind::KwDouble => {
456                    specs.type_specs.push(TypeSpec::Double);
457                    self.advance()?;
458                }
459                TokenKind::KwSigned | TokenKind::KwSigned2 => {
460                    specs.type_specs.push(TypeSpec::Signed);
461                    self.advance()?;
462                }
463                TokenKind::KwUnsigned => {
464                    specs.type_specs.push(TypeSpec::Unsigned);
465                    self.advance()?;
466                }
467                TokenKind::KwBool | TokenKind::KwBool2 => {
468                    specs.type_specs.push(TypeSpec::Bool);
469                    self.advance()?;
470                }
471                TokenKind::KwComplex => {
472                    specs.type_specs.push(TypeSpec::Complex);
473                    self.advance()?;
474                }
475                // GCC拡張浮動小数点型
476                TokenKind::KwFloat16 => {
477                    specs.type_specs.push(TypeSpec::Float16);
478                    self.advance()?;
479                }
480                TokenKind::KwFloat32 => {
481                    specs.type_specs.push(TypeSpec::Float32);
482                    self.advance()?;
483                }
484                TokenKind::KwFloat64 => {
485                    specs.type_specs.push(TypeSpec::Float64);
486                    self.advance()?;
487                }
488                TokenKind::KwFloat128 => {
489                    specs.type_specs.push(TypeSpec::Float128);
490                    self.advance()?;
491                }
492                TokenKind::KwFloat32x => {
493                    specs.type_specs.push(TypeSpec::Float32x);
494                    self.advance()?;
495                }
496                TokenKind::KwFloat64x => {
497                    specs.type_specs.push(TypeSpec::Float64x);
498                    self.advance()?;
499                }
500                // GCC拡張: 128ビット整数
501                TokenKind::KwInt128 => {
502                    specs.type_specs.push(TypeSpec::Int128);
503                    self.advance()?;
504                }
505                // typeof
506                TokenKind::KwTypeof | TokenKind::KwTypeof2 | TokenKind::KwTypeof3 => {
507                    self.advance()?;
508                    self.expect(&TokenKind::LParen)?;
509                    let expr = self.parse_expr()?;
510                    self.expect(&TokenKind::RParen)?;
511                    specs.type_specs.push(TypeSpec::TypeofExpr(Box::new(expr)));
512                }
513                // 構造体・共用体・列挙
514                TokenKind::KwStruct => {
515                    specs.type_specs.push(self.parse_struct_or_union(true)?);
516                }
517                TokenKind::KwUnion => {
518                    specs.type_specs.push(self.parse_struct_or_union(false)?);
519                }
520                TokenKind::KwEnum => {
521                    specs.type_specs.push(self.parse_enum()?);
522                }
523                // GCC拡張: __attribute__((...)) をスキップ
524                TokenKind::KwAttribute | TokenKind::KwAttribute2 => {
525                    self.skip_attribute()?;
526                }
527                // typedef名 or 検出済みの generic 型パラメータ
528                TokenKind::Ident(id) if self.typedefs.contains(id) || self.detected_type_params.contains(id) => {
529                    let id = *id;
530                    specs.type_specs.push(TypeSpec::TypedefName(id));
531                    self.advance()?;
532                }
533                // それ以外はループ終了
534                _ => break,
535            }
536        }
537
538        Ok(specs)
539    }
540
541    /// 構造体/共用体をパース
542    fn parse_struct_or_union(&mut self, is_struct: bool) -> Result<TypeSpec> {
543        let loc = self.current.loc.clone();
544        self.advance()?; // struct/union
545
546        // GCC拡張: struct __attribute__((...)) name { ... }
547        self.try_skip_attribute()?;
548
549        // 名前（オプション）
550        let name = self.current_ident();
551        if name.is_some() {
552            self.advance()?;
553        }
554
555        // メンバーリスト（オプション）
556        let members = if self.check(&TokenKind::LBrace) {
557            self.advance()?;
558            let mut members = Vec::new();
559            while !self.check(&TokenKind::RBrace) {
560                members.push(self.parse_struct_member()?);
561            }
562            self.expect(&TokenKind::RBrace)?;
563            Some(members)
564        } else {
565            None
566        };
567
568        let spec = StructSpec { name, members, loc };
569        if is_struct {
570            Ok(TypeSpec::Struct(spec))
571        } else {
572            Ok(TypeSpec::Union(spec))
573        }
574    }
575
576    /// 構造体メンバーをパース
577    fn parse_struct_member(&mut self) -> Result<StructMember> {
578        let specs = self.parse_decl_specs()?;
579        let mut declarators = Vec::new();
580
581        loop {
582            let declarator = if self.check(&TokenKind::Colon) {
583                None
584            } else if self.check(&TokenKind::Semi) {
585                None
586            } else {
587                Some(self.parse_declarator()?)
588            };
589
590            // GCC拡張: 宣言子の後の __attribute__ をスキップ
591            self.try_skip_attribute()?;
592
593            let bitfield = if self.check(&TokenKind::Colon) {
594                self.advance()?;
595                Some(Box::new(self.parse_conditional_expr()?))
596            } else {
597                None
598            };
599
600            declarators.push(StructDeclarator { declarator, bitfield });
601
602            if !self.check(&TokenKind::Comma) {
603                break;
604            }
605            self.advance()?;
606        }
607
608        self.expect(&TokenKind::Semi)?;
609
610        Ok(StructMember { specs, declarators })
611    }
612
613    /// 列挙型をパース
614    fn parse_enum(&mut self) -> Result<TypeSpec> {
615        let loc = self.current.loc.clone();
616        self.advance()?; // enum
617
618        // 名前（オプション）
619        let name = self.current_ident();
620        if name.is_some() {
621            self.advance()?;
622        }
623
624        // 列挙子リスト（オプション）
625        let enumerators = if self.check(&TokenKind::LBrace) {
626            self.advance()?;
627            let mut enums = Vec::new();
628            while !self.check(&TokenKind::RBrace) {
629                let eloc = self.current.loc.clone();
630                let ename = self.expect_ident()?;
631                let value = if self.check(&TokenKind::Eq) {
632                    self.advance()?;
633                    Some(Box::new(self.parse_conditional_expr()?))
634                } else {
635                    None
636                };
637                enums.push(Enumerator {
638                    name: ename,
639                    value,
640                    loc: eloc,
641                });
642                if !self.check(&TokenKind::Comma) {
643                    break;
644                }
645                self.advance()?;
646            }
647            self.expect(&TokenKind::RBrace)?;
648            Some(enums)
649        } else {
650            None
651        };
652
653        Ok(TypeSpec::Enum(EnumSpec {
654            name,
655            enumerators,
656            loc,
657        }))
658    }
659
660    /// 宣言子をパース
661    fn parse_declarator(&mut self) -> Result<Declarator> {
662        let loc = self.current.loc.clone();
663        let mut derived = Vec::new();
664
665        // ポインタ
666        while self.check(&TokenKind::Star) {
667            self.advance()?;
668            let qualifiers = self.parse_type_qualifiers()?;
669            derived.push(DerivedDecl::Pointer(qualifiers));
670        }
671
672        // 直接宣言子
673        let (name, inner_derived) = self.parse_direct_declarator()?;
674        derived.extend(inner_derived);
675
676        Ok(Declarator {
677            name,
678            derived,
679            loc,
680        })
681    }
682
683    /// 直接宣言子をパース
684    fn parse_direct_declarator(&mut self) -> Result<(Option<InternedStr>, Vec<DerivedDecl>)> {
685        let mut derived = Vec::new();
686
687        // 識別子または ( declarator )
688        let name = if self.check(&TokenKind::LParen) {
689            self.advance()?;
690            let inner = self.parse_declarator()?;
691            self.expect(&TokenKind::RParen)?;
692            // 内側の派生型を先頭に追加
693            derived = inner.derived;
694            inner.name
695        } else if let Some(id) = self.current_ident() {
696            // 識別子（キーワードはTokenKind::Kw*なのでここには来ない）
697            self.advance()?;
698            Some(id)
699        } else {
700            None
701        };
702
703        // 配列・関数の後置修飾
704        loop {
705            if self.check(&TokenKind::LBracket) {
706                derived.push(self.parse_array_declarator()?);
707            } else if self.check(&TokenKind::LParen) {
708                derived.push(self.parse_function_declarator()?);
709            } else {
710                break;
711            }
712        }
713
714        Ok((name, derived))
715    }
716
717    /// 配列宣言子をパース
718    fn parse_array_declarator(&mut self) -> Result<DerivedDecl> {
719        self.advance()?; // [
720
721        let mut qualifiers = TypeQualifiers::default();
722        let mut is_static = false;
723        let mut is_vla = false;
724
725        // static と型修飾子
726        loop {
727            match &self.current.kind {
728                TokenKind::KwStatic => {
729                    is_static = true;
730                    self.advance()?;
731                }
732                TokenKind::KwConst | TokenKind::KwConst2 | TokenKind::KwConst3 => {
733                    qualifiers.is_const = true;
734                    self.advance()?;
735                }
736                TokenKind::KwVolatile | TokenKind::KwVolatile2 | TokenKind::KwVolatile3 => {
737                    qualifiers.is_volatile = true;
738                    self.advance()?;
739                }
740                TokenKind::KwRestrict | TokenKind::KwRestrict2 | TokenKind::KwRestrict3 => {
741                    qualifiers.is_restrict = true;
742                    self.advance()?;
743                }
744                _ => break,
745            }
746        }
747
748        // サイズ式
749        let size = if self.check(&TokenKind::RBracket) {
750            None
751        } else if self.check(&TokenKind::Star) {
752            is_vla = true;
753            self.advance()?;
754            None
755        } else {
756            Some(Box::new(self.parse_assignment_expr()?))
757        };
758
759        self.expect(&TokenKind::RBracket)?;
760
761        Ok(DerivedDecl::Array(ArrayDecl {
762            size,
763            qualifiers,
764            is_static,
765            is_vla,
766        }))
767    }
768
769    /// 関数宣言子をパース
770    fn parse_function_declarator(&mut self) -> Result<DerivedDecl> {
771        self.advance()?; // (
772
773        if self.check(&TokenKind::RParen) {
774            self.advance()?;
775            return Ok(DerivedDecl::Function(ParamList {
776                params: Vec::new(),
777                is_variadic: false,
778            }));
779        }
780
781        let mut params = Vec::new();
782        let mut is_variadic = false;
783
784        loop {
785            if self.check(&TokenKind::Ellipsis) {
786                is_variadic = true;
787                self.advance()?;
788                break;
789            }
790
791            let loc = self.current.loc.clone();
792            let specs = self.parse_decl_specs()?;
793            let declarator = if self.check(&TokenKind::Comma) || self.check(&TokenKind::RParen) {
794                None
795            } else {
796                Some(self.parse_declarator()?)
797            };
798
799            // GCC拡張: パラメータ後の __attribute__((...)) をスキップ
800            self.try_skip_attribute()?;
801
802            params.push(ParamDecl {
803                specs,
804                declarator,
805                loc,
806            });
807
808            if !self.check(&TokenKind::Comma) {
809                break;
810            }
811            self.advance()?;
812        }
813
814        self.expect(&TokenKind::RParen)?;
815
816        Ok(DerivedDecl::Function(ParamList { params, is_variadic }))
817    }
818
819    /// 型修飾子をパース
820    fn parse_type_qualifiers(&mut self) -> Result<TypeQualifiers> {
821        let mut qualifiers = TypeQualifiers::default();
822
823        loop {
824            match &self.current.kind {
825                TokenKind::KwConst | TokenKind::KwConst2 | TokenKind::KwConst3 => {
826                    qualifiers.is_const = true;
827                    self.advance()?;
828                }
829                TokenKind::KwVolatile | TokenKind::KwVolatile2 | TokenKind::KwVolatile3 => {
830                    qualifiers.is_volatile = true;
831                    self.advance()?;
832                }
833                TokenKind::KwRestrict | TokenKind::KwRestrict2 | TokenKind::KwRestrict3 => {
834                    qualifiers.is_restrict = true;
835                    self.advance()?;
836                }
837                TokenKind::KwAtomic => {
838                    qualifiers.is_atomic = true;
839                    self.advance()?;
840                }
841                _ => break,
842            }
843        }
844
845        Ok(qualifiers)
846    }
847
848    /// 初期化子をパース
849    fn parse_initializer(&mut self) -> Result<Initializer> {
850        if self.check(&TokenKind::LBrace) {
851            self.advance()?;
852            let mut items = Vec::new();
853
854            while !self.check(&TokenKind::RBrace) {
855                let designation = self.parse_designation()?;
856                let init = self.parse_initializer()?;
857                items.push(InitializerItem { designation, init });
858
859                if !self.check(&TokenKind::Comma) {
860                    break;
861                }
862                self.advance()?;
863            }
864            self.expect(&TokenKind::RBrace)?;
865
866            Ok(Initializer::List(items))
867        } else {
868            Ok(Initializer::Expr(Box::new(self.parse_assignment_expr()?)))
869        }
870    }
871
872    /// 指示子列をパース
873    fn parse_designation(&mut self) -> Result<Vec<Designator>> {
874        let mut designators = Vec::new();
875
876        loop {
877            if self.check(&TokenKind::LBracket) {
878                self.advance()?;
879                let index = self.parse_conditional_expr()?;
880                self.expect(&TokenKind::RBracket)?;
881                designators.push(Designator::Index(Box::new(index)));
882            } else if self.check(&TokenKind::Dot) {
883                self.advance()?;
884                let name = self.expect_ident()?;
885                designators.push(Designator::Member(name));
886            } else {
887                break;
888            }
889        }
890
891        if !designators.is_empty() {
892            self.expect(&TokenKind::Eq)?;
893        }
894
895        Ok(designators)
896    }
897
898    /// 型名をパース
899    pub fn parse_type_name(&mut self) -> Result<TypeName> {
900        let specs = self.parse_decl_specs()?;
901        let declarator = if self.check(&TokenKind::RParen) {
902            None
903        } else {
904            Some(self.parse_abstract_declarator()?)
905        };
906        Ok(TypeName { specs, declarator })
907    }
908
909    /// 抽象宣言子をパース
910    fn parse_abstract_declarator(&mut self) -> Result<AbstractDeclarator> {
911        let mut derived = Vec::new();
912
913        // ポインタ
914        while self.check(&TokenKind::Star) {
915            self.advance()?;
916            let qualifiers = self.parse_type_qualifiers()?;
917            derived.push(DerivedDecl::Pointer(qualifiers));
918        }
919
920        // 直接抽象宣言子
921        if self.check(&TokenKind::LParen) {
922            // ( abstract-declarator ) または ( parameter-list )
923            // 先読みで判定が必要だが、簡略化のためここでは単純に処理
924            self.advance()?;
925            if !self.check(&TokenKind::RParen) && !self.is_type_start() {
926                let inner = self.parse_abstract_declarator()?;
927                self.expect(&TokenKind::RParen)?;
928                derived.extend(inner.derived);
929            } else {
930                // パラメータリストとして処理
931                let params = self.parse_param_list_inner()?;
932                derived.push(DerivedDecl::Function(params));
933            }
934        }
935
936        // 配列・関数の後置修飾
937        loop {
938            if self.check(&TokenKind::LBracket) {
939                derived.push(self.parse_array_declarator()?);
940            } else if self.check(&TokenKind::LParen) {
941                derived.push(self.parse_function_declarator()?);
942            } else {
943                break;
944            }
945        }
946
947        Ok(AbstractDeclarator { derived })
948    }
949
950    /// パラメータリストの内部をパース（RParen消費済み前提ではない）
951    fn parse_param_list_inner(&mut self) -> Result<ParamList> {
952        if self.check(&TokenKind::RParen) {
953            self.advance()?;
954            return Ok(ParamList {
955                params: Vec::new(),
956                is_variadic: false,
957            });
958        }
959
960        let mut params = Vec::new();
961        let mut is_variadic = false;
962
963        loop {
964            if self.check(&TokenKind::Ellipsis) {
965                is_variadic = true;
966                self.advance()?;
967                break;
968            }
969
970            let loc = self.current.loc.clone();
971            let specs = self.parse_decl_specs()?;
972            let declarator = if self.check(&TokenKind::Comma) || self.check(&TokenKind::RParen) {
973                None
974            } else if self.check(&TokenKind::Star) || self.check(&TokenKind::LParen) || self.check(&TokenKind::LBracket) {
975                Some(self.parse_declarator()?)
976            } else if let Some(id) = self.current_ident() {
977                // 識別子（キーワードはTokenKind::Kw*なのでここには来ない）
978                // typedef名でなければ宣言子
979                if !self.typedefs.contains(&id) {
980                    Some(self.parse_declarator()?)
981                } else {
982                    None
983                }
984            } else {
985                None
986            };
987
988            // GCC拡張: パラメータ後の __attribute__((...)) をスキップ
989            self.try_skip_attribute()?;
990
991            params.push(ParamDecl {
992                specs,
993                declarator,
994                loc,
995            });
996
997            if !self.check(&TokenKind::Comma) {
998                break;
999            }
1000            self.advance()?;
1001        }
1002
1003        self.expect(&TokenKind::RParen)?;
1004
1005        Ok(ParamList { params, is_variadic })
1006    }
1007
1008    // ==================== 文のパース ====================
1009
1010    /// 複合文をパース
1011    fn parse_compound_stmt(&mut self) -> Result<CompoundStmt> {
1012        let loc = self.current.loc.clone();
1013        self.expect(&TokenKind::LBrace)?;
1014
1015        let mut items = Vec::new();
1016        while !self.check(&TokenKind::RBrace) {
1017            items.push(self.parse_block_item()?);
1018        }
1019
1020        self.expect(&TokenKind::RBrace)?;
1021
1022        Ok(CompoundStmt { items, info: NodeInfo::new(loc) })
1023    }
1024
1025    /// ブロック項目をパース
1026    pub(crate) fn parse_block_item(&mut self) -> Result<BlockItem> {
1027        if self.is_declaration_start() {
1028            Ok(BlockItem::Decl(self.parse_declaration()?))
1029        } else {
1030            Ok(BlockItem::Stmt(self.parse_stmt()?))
1031        }
1032    }
1033
1034    /// 宣言をパース
1035    fn parse_declaration(&mut self) -> Result<Declaration> {
1036        let comments = self.current.leading_comments.clone();
1037        let loc = self.current.loc.clone();
1038        let is_target = self.source.is_file_in_target(loc.file_id);
1039        let specs = self.parse_decl_specs()?;
1040
1041        if self.check(&TokenKind::Semi) {
1042            self.advance()?;
1043            return Ok(Declaration {
1044                specs,
1045                declarators: Vec::new(),
1046                info: NodeInfo::new(loc),
1047                comments,
1048                is_target,
1049            });
1050        }
1051
1052        let mut declarators = Vec::new();
1053
1054        loop {
1055            let declarator = self.parse_declarator()?;
1056
1057            // GCC拡張: 宣言子の後の __attribute__((...)) をスキップ
1058            self.try_skip_attribute()?;
1059
1060            let init = if self.check(&TokenKind::Eq) {
1061                self.advance()?;
1062                Some(self.parse_initializer()?)
1063            } else {
1064                None
1065            };
1066            declarators.push(InitDeclarator { declarator, init });
1067
1068            if !self.check(&TokenKind::Comma) {
1069                break;
1070            }
1071            self.advance()?;
1072        }
1073
1074        // GCC拡張: 宣言の最後の __attribute__((...)) をスキップ
1075        self.try_skip_attribute()?;
1076
1077        self.expect(&TokenKind::Semi)?;
1078
1079        // typedef の場合、名前を登録
1080        if specs.storage == Some(StorageClass::Typedef) {
1081            for d in &declarators {
1082                if let Some(name) = d.declarator.name {
1083                    self.typedefs.insert(name);
1084                }
1085            }
1086        }
1087
1088        Ok(Declaration {
1089            specs,
1090            declarators,
1091            info: NodeInfo::new(loc),
1092            comments,
1093            is_target,
1094        })
1095    }
1096
1097    /// 文をパース
1098    fn parse_stmt(&mut self) -> Result<Stmt> {
1099        let loc = self.current.loc.clone();
1100
1101        // キーワードに基づく文のパース
1102        match &self.current.kind {
1103            // ラベル文
1104            TokenKind::KwCase => return self.parse_case_stmt(),
1105            TokenKind::KwDefault => return self.parse_default_stmt(),
1106            // 複合文
1107            TokenKind::LBrace => return Ok(Stmt::Compound(self.parse_compound_stmt()?)),
1108            // 制御フロー文
1109            TokenKind::KwIf => return self.parse_if_stmt(),
1110            TokenKind::KwSwitch => return self.parse_switch_stmt(),
1111            TokenKind::KwWhile => return self.parse_while_stmt(),
1112            TokenKind::KwDo => return self.parse_do_while_stmt(),
1113            TokenKind::KwFor => return self.parse_for_stmt(),
1114            TokenKind::KwGoto => {
1115                self.advance()?;
1116                let name = self.expect_ident()?;
1117                self.expect(&TokenKind::Semi)?;
1118                return Ok(Stmt::Goto(name, loc));
1119            }
1120            TokenKind::KwContinue => {
1121                self.advance()?;
1122                self.expect(&TokenKind::Semi)?;
1123                return Ok(Stmt::Continue(loc));
1124            }
1125            TokenKind::KwBreak => {
1126                self.advance()?;
1127                self.expect(&TokenKind::Semi)?;
1128                return Ok(Stmt::Break(loc));
1129            }
1130            TokenKind::KwReturn => {
1131                self.advance()?;
1132                let expr = if self.check(&TokenKind::Semi) {
1133                    None
1134                } else {
1135                    Some(Box::new(self.parse_expr()?))
1136                };
1137                self.expect(&TokenKind::Semi)?;
1138                return Ok(Stmt::Return(expr, loc));
1139            }
1140            // __asm__ 文
1141            TokenKind::KwAsm | TokenKind::KwAsm2 | TokenKind::KwAsm3 => {
1142                return self.parse_asm_stmt();
1143            }
1144            _ => {}
1145        }
1146
1147        // 式文
1148        if self.check(&TokenKind::Semi) {
1149            self.advance()?;
1150            return Ok(Stmt::Expr(None, loc));
1151        }
1152
1153        let expr = self.parse_expr()?;
1154
1155        // ラベルのチェック（識別子 : の場合）
1156        if self.check(&TokenKind::Colon) {
1157            if let ExprKind::Ident(name) = expr.kind {
1158                self.advance()?;
1159                let stmt = self.parse_stmt()?;
1160                return Ok(Stmt::Label {
1161                    name,
1162                    stmt: Box::new(stmt),
1163                    loc,
1164                });
1165            }
1166        }
1167
1168        self.expect(&TokenKind::Semi)?;
1169        Ok(Stmt::Expr(Some(Box::new(expr)), loc))
1170    }
1171
1172    fn parse_if_stmt(&mut self) -> Result<Stmt> {
1173        let loc = self.current.loc.clone();
1174        self.advance()?; // if
1175        self.expect(&TokenKind::LParen)?;
1176        let cond = Box::new(self.parse_expr()?);
1177        self.expect(&TokenKind::RParen)?;
1178        let then_stmt = Box::new(self.parse_stmt()?);
1179
1180        let else_stmt = if matches!(self.current.kind, TokenKind::KwElse) {
1181            self.advance()?;
1182            Some(Box::new(self.parse_stmt()?))
1183        } else {
1184            None
1185        };
1186
1187        Ok(Stmt::If {
1188            cond,
1189            then_stmt,
1190            else_stmt,
1191            loc,
1192        })
1193    }
1194
1195    fn parse_switch_stmt(&mut self) -> Result<Stmt> {
1196        let loc = self.current.loc.clone();
1197        self.advance()?; // switch
1198        self.expect(&TokenKind::LParen)?;
1199        let expr = Box::new(self.parse_expr()?);
1200        self.expect(&TokenKind::RParen)?;
1201        let body = Box::new(self.parse_stmt()?);
1202
1203        Ok(Stmt::Switch { expr, body, loc })
1204    }
1205
1206    fn parse_while_stmt(&mut self) -> Result<Stmt> {
1207        let loc = self.current.loc.clone();
1208        self.advance()?; // while
1209        self.expect(&TokenKind::LParen)?;
1210        let cond = Box::new(self.parse_expr()?);
1211        self.expect(&TokenKind::RParen)?;
1212        let body = Box::new(self.parse_stmt()?);
1213
1214        Ok(Stmt::While { cond, body, loc })
1215    }
1216
1217    fn parse_do_while_stmt(&mut self) -> Result<Stmt> {
1218        let loc = self.current.loc.clone();
1219        self.advance()?; // do
1220        let body = Box::new(self.parse_stmt()?);
1221        // expect 'while' keyword
1222        if !matches!(self.current.kind, TokenKind::KwWhile) {
1223            return Err(CompileError::Parse {
1224                loc: self.current.loc.clone(),
1225                kind: ParseError::UnexpectedToken {
1226                    expected: "while".to_string(),
1227                    found: self.current.kind.clone(),
1228                },
1229            });
1230        }
1231        self.advance()?;
1232        self.expect(&TokenKind::LParen)?;
1233        let cond = Box::new(self.parse_expr()?);
1234        self.expect(&TokenKind::RParen)?;
1235
1236        // allow_missing_semi が true の場合、; は任意
1237        if self.allow_missing_semi {
1238            if self.check(&TokenKind::Semi) {
1239                self.advance()?;
1240            }
1241        } else {
1242            self.expect(&TokenKind::Semi)?;
1243        }
1244
1245        Ok(Stmt::DoWhile { body, cond, loc })
1246    }
1247
1248    fn parse_for_stmt(&mut self) -> Result<Stmt> {
1249        let loc = self.current.loc.clone();
1250        self.advance()?; // for
1251        self.expect(&TokenKind::LParen)?;
1252
1253        // 初期化部
1254        let init = if self.check(&TokenKind::Semi) {
1255            self.advance()?;
1256            None
1257        } else if self.is_declaration_start() {
1258            let decl = self.parse_declaration()?;
1259            Some(ForInit::Decl(decl))
1260        } else {
1261            let expr = self.parse_expr()?;
1262            self.expect(&TokenKind::Semi)?;
1263            Some(ForInit::Expr(Box::new(expr)))
1264        };
1265
1266        // 条件部
1267        let cond = if self.check(&TokenKind::Semi) {
1268            None
1269        } else {
1270            Some(Box::new(self.parse_expr()?))
1271        };
1272        self.expect(&TokenKind::Semi)?;
1273
1274        // 更新部
1275        let step = if self.check(&TokenKind::RParen) {
1276            None
1277        } else {
1278            Some(Box::new(self.parse_expr()?))
1279        };
1280        self.expect(&TokenKind::RParen)?;
1281
1282        let body = Box::new(self.parse_stmt()?);
1283
1284        Ok(Stmt::For {
1285            init,
1286            cond,
1287            step,
1288            body,
1289            loc,
1290        })
1291    }
1292
1293    fn parse_case_stmt(&mut self) -> Result<Stmt> {
1294        let loc = self.current.loc.clone();
1295        self.advance()?; // case
1296        let expr = Box::new(self.parse_conditional_expr()?);
1297        self.expect(&TokenKind::Colon)?;
1298        let stmt = Box::new(self.parse_stmt()?);
1299
1300        Ok(Stmt::Case { expr, stmt, loc })
1301    }
1302
1303    fn parse_default_stmt(&mut self) -> Result<Stmt> {
1304        let loc = self.current.loc.clone();
1305        self.advance()?; // default
1306        self.expect(&TokenKind::Colon)?;
1307        let stmt = Box::new(self.parse_stmt()?);
1308
1309        Ok(Stmt::Default { stmt, loc })
1310    }
1311
1312    fn parse_asm_stmt(&mut self) -> Result<Stmt> {
1313        let loc = self.current.loc.clone();
1314        self.advance()?; // asm / __asm / __asm__
1315
1316        // volatile / __volatile__ はスキップ
1317        while matches!(
1318            self.current.kind,
1319            TokenKind::KwVolatile | TokenKind::KwVolatile2 | TokenKind::KwVolatile3
1320        ) {
1321            self.advance()?;
1322        }
1323
1324        // 括弧内をスキップ
1325        self.expect(&TokenKind::LParen)?;
1326        self.skip_balanced_parens()?;
1327
1328        self.expect(&TokenKind::Semi)?;
1329        Ok(Stmt::Asm { loc })
1330    }
1331
1332    // ==================== 式のパース ====================
1333
1334    /// 式をパース（コンマ式を含む）
1335    fn parse_expr(&mut self) -> Result<Expr> {
1336        let lhs = self.parse_assignment_expr()?;
1337
1338        if self.check(&TokenKind::Comma) {
1339            let loc = self.current.loc.clone();
1340            self.advance()?;
1341            let rhs = self.parse_expr()?;
1342            return Ok(Expr::new(
1343                ExprKind::Comma {
1344                    lhs: Box::new(lhs),
1345                    rhs: Box::new(rhs),
1346                },
1347                loc,
1348            ));
1349        }
1350
1351        Ok(lhs)
1352    }
1353
1354    /// 代入式をパース
1355    fn parse_assignment_expr(&mut self) -> Result<Expr> {
1356        let lhs = self.parse_conditional_expr()?;
1357
1358        let op = match &self.current.kind {
1359            TokenKind::Eq => Some(AssignOp::Assign),
1360            TokenKind::StarEq => Some(AssignOp::MulAssign),
1361            TokenKind::SlashEq => Some(AssignOp::DivAssign),
1362            TokenKind::PercentEq => Some(AssignOp::ModAssign),
1363            TokenKind::PlusEq => Some(AssignOp::AddAssign),
1364            TokenKind::MinusEq => Some(AssignOp::SubAssign),
1365            TokenKind::LtLtEq => Some(AssignOp::ShlAssign),
1366            TokenKind::GtGtEq => Some(AssignOp::ShrAssign),
1367            TokenKind::AmpEq => Some(AssignOp::AndAssign),
1368            TokenKind::CaretEq => Some(AssignOp::XorAssign),
1369            TokenKind::PipeEq => Some(AssignOp::OrAssign),
1370            _ => None,
1371        };
1372
1373        if let Some(op) = op {
1374            let loc = self.current.loc.clone();
1375            self.advance()?;
1376            let rhs = self.parse_assignment_expr()?;
1377            return Ok(Expr::new(
1378                ExprKind::Assign {
1379                    op,
1380                    lhs: Box::new(lhs),
1381                    rhs: Box::new(rhs),
1382                },
1383                loc,
1384            ));
1385        }
1386
1387        Ok(lhs)
1388    }
1389
1390    /// 条件式をパース
1391    fn parse_conditional_expr(&mut self) -> Result<Expr> {
1392        let cond = self.parse_logical_or_expr()?;
1393
1394        if self.check(&TokenKind::Question) {
1395            let loc = self.current.loc.clone();
1396            self.advance()?;
1397            let then_expr = self.parse_expr()?;
1398            self.expect(&TokenKind::Colon)?;
1399            let else_expr = self.parse_conditional_expr()?;
1400            return Ok(Expr::new(
1401                ExprKind::Conditional {
1402                    cond: Box::new(cond),
1403                    then_expr: Box::new(then_expr),
1404                    else_expr: Box::new(else_expr),
1405                },
1406                loc,
1407            ));
1408        }
1409
1410        Ok(cond)
1411    }
1412
1413    /// 論理OR式をパース
1414    fn parse_logical_or_expr(&mut self) -> Result<Expr> {
1415        let mut lhs = self.parse_logical_and_expr()?;
1416
1417        while self.check(&TokenKind::PipePipe) {
1418            let loc = self.current.loc.clone();
1419            self.advance()?;
1420            let rhs = self.parse_logical_and_expr()?;
1421            lhs = Expr::new(
1422                ExprKind::Binary {
1423                    op: BinOp::LogOr,
1424                    lhs: Box::new(lhs),
1425                    rhs: Box::new(rhs),
1426                },
1427                loc,
1428            );
1429        }
1430
1431        Ok(lhs)
1432    }
1433
1434    /// 論理AND式をパース
1435    fn parse_logical_and_expr(&mut self) -> Result<Expr> {
1436        let mut lhs = self.parse_bitwise_or_expr()?;
1437
1438        while self.check(&TokenKind::AmpAmp) {
1439            let loc = self.current.loc.clone();
1440            self.advance()?;
1441            let rhs = self.parse_bitwise_or_expr()?;
1442            lhs = Expr::new(
1443                ExprKind::Binary {
1444                    op: BinOp::LogAnd,
1445                    lhs: Box::new(lhs),
1446                    rhs: Box::new(rhs),
1447                },
1448                loc,
1449            );
1450        }
1451
1452        Ok(lhs)
1453    }
1454
1455    /// ビットOR式をパース
1456    fn parse_bitwise_or_expr(&mut self) -> Result<Expr> {
1457        let mut lhs = self.parse_bitwise_xor_expr()?;
1458
1459        while self.check(&TokenKind::Pipe) {
1460            let loc = self.current.loc.clone();
1461            self.advance()?;
1462            let rhs = self.parse_bitwise_xor_expr()?;
1463            lhs = Expr::new(
1464                ExprKind::Binary {
1465                    op: BinOp::BitOr,
1466                    lhs: Box::new(lhs),
1467                    rhs: Box::new(rhs),
1468                },
1469                loc,
1470            );
1471        }
1472
1473        Ok(lhs)
1474    }
1475
1476    /// ビットXOR式をパース
1477    fn parse_bitwise_xor_expr(&mut self) -> Result<Expr> {
1478        let mut lhs = self.parse_bitwise_and_expr()?;
1479
1480        while self.check(&TokenKind::Caret) {
1481            let loc = self.current.loc.clone();
1482            self.advance()?;
1483            let rhs = self.parse_bitwise_and_expr()?;
1484            lhs = Expr::new(
1485                ExprKind::Binary {
1486                    op: BinOp::BitXor,
1487                    lhs: Box::new(lhs),
1488                    rhs: Box::new(rhs),
1489                },
1490                loc,
1491            );
1492        }
1493
1494        Ok(lhs)
1495    }
1496
1497    /// ビットAND式をパース
1498    fn parse_bitwise_and_expr(&mut self) -> Result<Expr> {
1499        let mut lhs = self.parse_equality_expr()?;
1500
1501        while self.check(&TokenKind::Amp) {
1502            let loc = self.current.loc.clone();
1503            self.advance()?;
1504            let rhs = self.parse_equality_expr()?;
1505            lhs = Expr::new(
1506                ExprKind::Binary {
1507                    op: BinOp::BitAnd,
1508                    lhs: Box::new(lhs),
1509                    rhs: Box::new(rhs),
1510                },
1511                loc,
1512            );
1513        }
1514
1515        Ok(lhs)
1516    }
1517
1518    /// 等価式をパース
1519    fn parse_equality_expr(&mut self) -> Result<Expr> {
1520        let mut lhs = self.parse_relational_expr()?;
1521
1522        loop {
1523            let op = match &self.current.kind {
1524                TokenKind::EqEq => BinOp::Eq,
1525                TokenKind::BangEq => BinOp::Ne,
1526                _ => break,
1527            };
1528            let loc = self.current.loc.clone();
1529            self.advance()?;
1530            let rhs = self.parse_relational_expr()?;
1531            lhs = Expr::new(
1532                ExprKind::Binary {
1533                    op,
1534                    lhs: Box::new(lhs),
1535                    rhs: Box::new(rhs),
1536                },
1537                loc,
1538            );
1539        }
1540
1541        Ok(lhs)
1542    }
1543
1544    /// 関係式をパース
1545    fn parse_relational_expr(&mut self) -> Result<Expr> {
1546        let mut lhs = self.parse_shift_expr()?;
1547
1548        loop {
1549            let op = match &self.current.kind {
1550                TokenKind::Lt => BinOp::Lt,
1551                TokenKind::Gt => BinOp::Gt,
1552                TokenKind::LtEq => BinOp::Le,
1553                TokenKind::GtEq => BinOp::Ge,
1554                _ => break,
1555            };
1556            let loc = self.current.loc.clone();
1557            self.advance()?;
1558            let rhs = self.parse_shift_expr()?;
1559            lhs = Expr::new(
1560                ExprKind::Binary {
1561                    op,
1562                    lhs: Box::new(lhs),
1563                    rhs: Box::new(rhs),
1564                },
1565                loc,
1566            );
1567        }
1568
1569        Ok(lhs)
1570    }
1571
1572    /// シフト式をパース
1573    fn parse_shift_expr(&mut self) -> Result<Expr> {
1574        let mut lhs = self.parse_additive_expr()?;
1575
1576        loop {
1577            let op = match &self.current.kind {
1578                TokenKind::LtLt => BinOp::Shl,
1579                TokenKind::GtGt => BinOp::Shr,
1580                _ => break,
1581            };
1582            let loc = self.current.loc.clone();
1583            self.advance()?;
1584            let rhs = self.parse_additive_expr()?;
1585            lhs = Expr::new(
1586                ExprKind::Binary {
1587                    op,
1588                    lhs: Box::new(lhs),
1589                    rhs: Box::new(rhs),
1590                },
1591                loc,
1592            );
1593        }
1594
1595        Ok(lhs)
1596    }
1597
1598    /// 加減式をパース
1599    fn parse_additive_expr(&mut self) -> Result<Expr> {
1600        let mut lhs = self.parse_multiplicative_expr()?;
1601
1602        loop {
1603            let op = match &self.current.kind {
1604                TokenKind::Plus => BinOp::Add,
1605                TokenKind::Minus => BinOp::Sub,
1606                _ => break,
1607            };
1608            let loc = self.current.loc.clone();
1609            self.advance()?;
1610            let rhs = self.parse_multiplicative_expr()?;
1611            lhs = Expr::new(
1612                ExprKind::Binary {
1613                    op,
1614                    lhs: Box::new(lhs),
1615                    rhs: Box::new(rhs),
1616                },
1617                loc,
1618            );
1619        }
1620
1621        Ok(lhs)
1622    }
1623
1624    /// 乗除式をパース
1625    fn parse_multiplicative_expr(&mut self) -> Result<Expr> {
1626        let mut lhs = self.parse_cast_expr()?;
1627
1628        loop {
1629            let op = match &self.current.kind {
1630                TokenKind::Star => BinOp::Mul,
1631                TokenKind::Slash => BinOp::Div,
1632                TokenKind::Percent => BinOp::Mod,
1633                _ => break,
1634            };
1635            let loc = self.current.loc.clone();
1636            self.advance()?;
1637            let rhs = self.parse_cast_expr()?;
1638            lhs = Expr::new(
1639                ExprKind::Binary {
1640                    op,
1641                    lhs: Box::new(lhs),
1642                    rhs: Box::new(rhs),
1643                },
1644                loc,
1645            );
1646        }
1647
1648        Ok(lhs)
1649    }
1650
1651    /// キャスト式をパース
1652    fn parse_cast_expr(&mut self) -> Result<Expr> {
1653        // ( type-name ) cast-expression のみをここで処理
1654        // ( expr ) は parse_primary_expr で処理し、postfix操作を許可する
1655        if self.check(&TokenKind::LParen) {
1656            let loc = self.current.loc.clone();
1657            self.advance()?; // (
1658
1659            // 1. 確定的な型名（キーワード/typedef/既検出の generic param）
1660            if self.is_type_start() {
1661                return self.finish_parse_cast_or_compound_lit(loc);
1662            }
1663
1664            // 2. 未検出の generic param → 先読みで判定
1665            if let Some(id) = self.current_ident() {
1666                if self.generic_params.contains_key(&id)
1667                    && self.looks_like_generic_cast()
1668                {
1669                    // 型パラメータとして記録
1670                    self.detected_type_params.insert(id);
1671                    return self.finish_parse_cast_or_compound_lit(loc);
1672                }
1673            }
1674
1675            if self.check(&TokenKind::LBrace) {
1676                // GCC拡張: ステートメント式 ({ ... })
1677                let stmt = self.parse_compound_stmt()?;
1678                self.expect(&TokenKind::RParen)?;
1679                // ステートメント式の後もpostfixを許可する
1680                let stmt_expr = Expr::new(ExprKind::StmtExpr(stmt), loc);
1681                return self.parse_postfix_on(stmt_expr);
1682            } else {
1683                // 括弧で囲まれた式 - parse_primary_exprに任せる
1684                // いったん戻してparse_unary_exprに任せる
1685                // 注: ここではadvanceを巻き戻す代わりに、式をパースしてからpostfixを処理
1686                let expr = self.parse_expr()?;
1687                self.expect(&TokenKind::RParen)?;
1688                // postfix操作を許可する（->や.など）
1689                return self.parse_postfix_on(expr);
1690            }
1691        }
1692
1693        self.parse_unary_expr()
1694    }
1695
1696    /// キャスト式または複合リテラルのパースを完了する
1697    ///
1698    /// `parse_cast_expr` で `(` を消費し、current が型名の先頭にある状態で呼ぶ。
1699    fn finish_parse_cast_or_compound_lit(&mut self, loc: SourceLocation) -> Result<Expr> {
1700        let type_name = self.parse_type_name()?;
1701        self.expect(&TokenKind::RParen)?;
1702
1703        // 複合リテラルのチェック
1704        if self.check(&TokenKind::LBrace) {
1705            self.advance()?;
1706            let mut items = Vec::new();
1707            while !self.check(&TokenKind::RBrace) {
1708                let designation = self.parse_designation()?;
1709                let init = self.parse_initializer()?;
1710                items.push(InitializerItem { designation, init });
1711                if !self.check(&TokenKind::Comma) {
1712                    break;
1713                }
1714                self.advance()?;
1715            }
1716            self.expect(&TokenKind::RBrace)?;
1717            return Ok(Expr::new(
1718                ExprKind::CompoundLit {
1719                    type_name: Box::new(type_name),
1720                    init: items,
1721                },
1722                loc,
1723            ));
1724        }
1725
1726        let expr = self.parse_cast_expr()?;
1727        Ok(Expr::new(
1728            ExprKind::Cast {
1729                type_name: Box::new(type_name),
1730                expr: Box::new(expr),
1731            },
1732            loc,
1733        ))
1734    }
1735
1736    /// generic param がキャスト式の型として使われているかを先読みで判定
1737    ///
1738    /// 呼び出し時点: current = generic param の Ident
1739    /// TokenSource::next_token + unget_token で先読み
1740    fn looks_like_generic_cast(&mut self) -> bool {
1741        // 先読み1: param の次のトークン
1742        let next1 = match self.source.next_token() {
1743            Ok(t) => t,
1744            Err(_) => return false,
1745        };
1746
1747        let result = match &next1.kind {
1748            // (PARAM *...) — ポインタキャスト
1749            TokenKind::Star => true,
1750
1751            // (PARAM) — 値キャスト候補、後続の文脈で判定
1752            TokenKind::RParen => {
1753                let next2 = match self.source.next_token() {
1754                    Ok(t) => t,
1755                    Err(_) => {
1756                        self.source.unget_token(next1);
1757                        return false;
1758                    }
1759                };
1760                // ) の後に式の開始トークンが続くならキャスト
1761                let is_cast = match &next2.kind {
1762                    TokenKind::LParen       // (PARAM)(expr)
1763                    | TokenKind::Ident(_)   // (PARAM)ident
1764                    | TokenKind::IntLit(_) | TokenKind::UIntLit(_)
1765                    | TokenKind::FloatLit(_)
1766                    | TokenKind::StringLit(_) | TokenKind::CharLit(_)
1767                    | TokenKind::Star       // (PARAM)*ptr (deref)
1768                    | TokenKind::Amp        // (PARAM)&x
1769                    | TokenKind::Bang       // (PARAM)!x
1770                    | TokenKind::Tilde      // (PARAM)~x
1771                    | TokenKind::KwSizeof   // (PARAM)sizeof(x)
1772                    => true,
1773
1774                    // (PARAM)-x: 3トークン先読みで判定
1775                    // `-` の次が数値リテラルなら cast (e.g. (T)-1)
1776                    // それ以外なら二項減算 (e.g. (val) - func(...))
1777                    TokenKind::Minus => {
1778                        let next3 = match self.source.next_token() {
1779                            Ok(t) => t,
1780                            Err(_) => {
1781                                self.source.unget_token(next2);
1782                                self.source.unget_token(next1);
1783                                return false;
1784                            }
1785                        };
1786                        let is_numeric = matches!(&next3.kind,
1787                            TokenKind::IntLit(_)
1788                            | TokenKind::UIntLit(_)
1789                            | TokenKind::FloatLit(_)
1790                        );
1791                        self.source.unget_token(next3);
1792                        is_numeric
1793                    }
1794
1795                    _ => false,
1796                };
1797                self.source.unget_token(next2);
1798                is_cast
1799            }
1800
1801            // (PARAM + ...) など — 括弧付き式
1802            _ => false,
1803        };
1804
1805        self.source.unget_token(next1);
1806        result
1807    }
1808
1809    /// 既存の式に対してpostfix操作をパース
1810    fn parse_postfix_on(&mut self, mut expr: Expr) -> Result<Expr> {
1811        loop {
1812            let loc = self.current.loc.clone();
1813            match &self.current.kind {
1814                TokenKind::LBracket => {
1815                    self.advance()?;
1816                    let index = self.parse_expr()?;
1817                    self.expect(&TokenKind::RBracket)?;
1818                    expr = Expr::new(
1819                        ExprKind::Index {
1820                            expr: Box::new(expr),
1821                            index: Box::new(index),
1822                        },
1823                        loc,
1824                    );
1825                }
1826                TokenKind::LParen => {
1827                    self.advance()?;
1828                    let mut args = Vec::new();
1829                    while !self.check(&TokenKind::RParen) {
1830                        args.push(self.parse_assignment_expr()?);
1831                        if !self.check(&TokenKind::Comma) {
1832                            break;
1833                        }
1834                        self.advance()?;
1835                    }
1836                    self.expect(&TokenKind::RParen)?;
1837                    self.function_call_count += 1;
1838                    expr = Expr::new(
1839                        ExprKind::Call {
1840                            func: Box::new(expr),
1841                            args,
1842                        },
1843                        loc,
1844                    );
1845                }
1846                TokenKind::Dot => {
1847                    self.advance()?;
1848                    let member = self.expect_ident()?;
1849                    expr = Expr::new(
1850                        ExprKind::Member {
1851                            expr: Box::new(expr),
1852                            member,
1853                        },
1854                        loc,
1855                    );
1856                }
1857                TokenKind::Arrow => {
1858                    self.advance()?;
1859                    let member = self.expect_ident()?;
1860                    self.deref_count += 1;
1861                    expr = Expr::new(
1862                        ExprKind::PtrMember {
1863                            expr: Box::new(expr),
1864                            member,
1865                        },
1866                        loc,
1867                    );
1868                }
1869                TokenKind::PlusPlus => {
1870                    self.advance()?;
1871                    expr = Expr::new(ExprKind::PostInc(Box::new(expr)), loc);
1872                }
1873                TokenKind::MinusMinus => {
1874                    self.advance()?;
1875                    expr = Expr::new(ExprKind::PostDec(Box::new(expr)), loc);
1876                }
1877                _ => break,
1878            }
1879        }
1880        Ok(expr)
1881    }
1882
1883    /// 単項式をパース
1884    fn parse_unary_expr(&mut self) -> Result<Expr> {
1885        let loc = self.current.loc.clone();
1886
1887        match &self.current.kind {
1888            TokenKind::PlusPlus => {
1889                self.advance()?;
1890                let expr = self.parse_unary_expr()?;
1891                Ok(Expr::new(ExprKind::PreInc(Box::new(expr)), loc))
1892            }
1893            TokenKind::MinusMinus => {
1894                self.advance()?;
1895                let expr = self.parse_unary_expr()?;
1896                Ok(Expr::new(ExprKind::PreDec(Box::new(expr)), loc))
1897            }
1898            TokenKind::Amp => {
1899                self.advance()?;
1900                let expr = self.parse_cast_expr()?;
1901                Ok(Expr::new(ExprKind::AddrOf(Box::new(expr)), loc))
1902            }
1903            TokenKind::Star => {
1904                self.advance()?;
1905                let expr = self.parse_cast_expr()?;
1906                self.deref_count += 1;
1907                Ok(Expr::new(ExprKind::Deref(Box::new(expr)), loc))
1908            }
1909            TokenKind::Plus => {
1910                self.advance()?;
1911                let expr = self.parse_cast_expr()?;
1912                Ok(Expr::new(ExprKind::UnaryPlus(Box::new(expr)), loc))
1913            }
1914            TokenKind::Minus => {
1915                self.advance()?;
1916                let expr = self.parse_cast_expr()?;
1917                Ok(Expr::new(ExprKind::UnaryMinus(Box::new(expr)), loc))
1918            }
1919            TokenKind::Tilde => {
1920                self.advance()?;
1921                let expr = self.parse_cast_expr()?;
1922                Ok(Expr::new(ExprKind::BitNot(Box::new(expr)), loc))
1923            }
1924            TokenKind::Bang => {
1925                self.advance()?;
1926                let expr = self.parse_cast_expr()?;
1927                Ok(Expr::new(ExprKind::LogNot(Box::new(expr)), loc))
1928            }
1929            TokenKind::KwSizeof => {
1930                self.advance()?;
1931                if self.check(&TokenKind::LParen) {
1932                    self.advance()?; // (
1933                    if self.is_type_start() {
1934                        // sizeof(type)
1935                        let type_name = self.parse_type_name()?;
1936                        self.expect(&TokenKind::RParen)?;
1937                        Ok(Expr::new(ExprKind::SizeofType(Box::new(type_name)), loc))
1938                    } else {
1939                        // sizeof(expr) - 括弧付きの式
1940                        let expr = self.parse_expr()?;
1941                        self.expect(&TokenKind::RParen)?;
1942                        Ok(Expr::new(ExprKind::Sizeof(Box::new(expr)), loc))
1943                    }
1944                } else {
1945                    let expr = self.parse_unary_expr()?;
1946                    Ok(Expr::new(ExprKind::Sizeof(Box::new(expr)), loc))
1947                }
1948            }
1949            TokenKind::KwAlignof | TokenKind::KwAlignof2 | TokenKind::KwAlignof3 => {
1950                self.advance()?;
1951                self.expect(&TokenKind::LParen)?;
1952                let type_name = self.parse_type_name()?;
1953                self.expect(&TokenKind::RParen)?;
1954                Ok(Expr::new(ExprKind::Alignof(Box::new(type_name)), loc))
1955            }
1956            // GCC拡張: __extension__ は無視して続行（TinyCC方式）
1957            TokenKind::KwExtension => {
1958                self.advance()?;
1959                self.parse_unary_expr()
1960            }
1961            _ => self.parse_postfix_expr(),
1962        }
1963    }
1964
1965    /// 後置式をパース
1966    fn parse_postfix_expr(&mut self) -> Result<Expr> {
1967        let mut expr = self.parse_primary_expr()?;
1968
1969        loop {
1970            let loc = self.current.loc.clone();
1971            match &self.current.kind {
1972                TokenKind::LBracket => {
1973                    self.advance()?;
1974                    let index = self.parse_expr()?;
1975                    self.expect(&TokenKind::RBracket)?;
1976                    expr = Expr::new(
1977                        ExprKind::Index {
1978                            expr: Box::new(expr),
1979                            index: Box::new(index),
1980                        },
1981                        loc,
1982                    );
1983                }
1984                TokenKind::LParen => {
1985                    // ビルトイン呼び出し判定
1986                    if let ExprKind::Ident(name) = &expr.kind {
1987                        if self.is_type_arg_builtin(*name) {
1988                            let builtin_name = *name;
1989                            self.advance()?; // (
1990                            let args = self.parse_builtin_args()?;
1991                            self.expect(&TokenKind::RParen)?;
1992                            self.function_call_count += 1;
1993                            expr = Expr::new(
1994                                ExprKind::BuiltinCall { name: builtin_name, args },
1995                                loc,
1996                            );
1997                            continue;
1998                        }
1999                    }
2000                    // 通常の関数呼び出し
2001                    self.advance()?;
2002                    let mut args = Vec::new();
2003                    if !self.check(&TokenKind::RParen) {
2004                        loop {
2005                            args.push(self.parse_assignment_expr()?);
2006                            if !self.check(&TokenKind::Comma) {
2007                                break;
2008                            }
2009                            self.advance()?;
2010                        }
2011                    }
2012                    self.expect(&TokenKind::RParen)?;
2013                    self.function_call_count += 1;
2014                    expr = Expr::new(
2015                        ExprKind::Call {
2016                            func: Box::new(expr),
2017                            args,
2018                        },
2019                        loc,
2020                    );
2021                }
2022                TokenKind::Dot => {
2023                    self.advance()?;
2024                    let member = self.expect_ident()?;
2025                    expr = Expr::new(
2026                        ExprKind::Member {
2027                            expr: Box::new(expr),
2028                            member,
2029                        },
2030                        loc,
2031                    );
2032                }
2033                TokenKind::Arrow => {
2034                    self.advance()?;
2035                    let member = self.expect_ident()?;
2036                    self.deref_count += 1;
2037                    expr = Expr::new(
2038                        ExprKind::PtrMember {
2039                            expr: Box::new(expr),
2040                            member,
2041                        },
2042                        loc,
2043                    );
2044                }
2045                TokenKind::PlusPlus => {
2046                    self.advance()?;
2047                    expr = Expr::new(ExprKind::PostInc(Box::new(expr)), loc);
2048                }
2049                TokenKind::MinusMinus => {
2050                    self.advance()?;
2051                    expr = Expr::new(ExprKind::PostDec(Box::new(expr)), loc);
2052                }
2053                _ => break,
2054            }
2055        }
2056
2057        Ok(expr)
2058    }
2059
2060    /// 一次式をパース
2061    fn parse_primary_expr(&mut self) -> Result<Expr> {
2062        let loc = self.current.loc.clone();
2063
2064        match &self.current.kind {
2065            TokenKind::Ident(id) => {
2066                let id = *id;
2067                self.advance()?;
2068                Ok(Expr::new(ExprKind::Ident(id), loc))
2069            }
2070            TokenKind::IntLit(n) => {
2071                let n = *n;
2072                self.advance()?;
2073                Ok(Expr::new(ExprKind::IntLit(n), loc))
2074            }
2075            TokenKind::UIntLit(n) => {
2076                let n = *n;
2077                self.advance()?;
2078                Ok(Expr::new(ExprKind::UIntLit(n), loc))
2079            }
2080            TokenKind::FloatLit(f) => {
2081                let f = *f;
2082                self.advance()?;
2083                Ok(Expr::new(ExprKind::FloatLit(f), loc))
2084            }
2085            TokenKind::CharLit(c) => {
2086                let c = *c;
2087                self.advance()?;
2088                Ok(Expr::new(ExprKind::CharLit(c), loc))
2089            }
2090            TokenKind::StringLit(s) => {
2091                let mut bytes = s.clone();
2092                self.advance()?;
2093                // 連続した文字列リテラルを結合
2094                while let TokenKind::StringLit(s2) = &self.current.kind {
2095                    bytes.extend_from_slice(s2);
2096                    self.advance()?;
2097                }
2098                Ok(Expr::new(ExprKind::StringLit(bytes), loc))
2099            }
2100            TokenKind::LParen => {
2101                self.advance()?;
2102                // GCC拡張: ステートメント式 ({ ... })
2103                if self.check(&TokenKind::LBrace) {
2104                    let stmt = self.parse_compound_stmt()?;
2105                    self.expect(&TokenKind::RParen)?;
2106                    Ok(Expr::new(ExprKind::StmtExpr(stmt), loc))
2107                } else {
2108                    let expr = self.parse_expr()?;
2109                    self.expect(&TokenKind::RParen)?;
2110                    Ok(expr)
2111                }
2112            }
2113            TokenKind::MacroBegin(info) if info.is_wrapped => {
2114                // wrapped マクロ（assert 等）を処理
2115                self.parse_wrapped_macro_expr()
2116            }
2117            TokenKind::MacroBegin(info) if info.preserve_call => {
2118                // preserve_call マクロを MacroCall ノードとして処理
2119                self.parse_macro_call_expr()
2120            }
2121            TokenKind::KwGeneric => {
2122                self.advance()?;
2123                self.parse_generic_selection(loc)
2124            }
2125            _ => Err(CompileError::Parse {
2126                loc,
2127                kind: ParseError::UnexpectedToken {
2128                    expected: "primary expression".to_string(),
2129                    found: self.current.kind.clone(),
2130                },
2131            }),
2132        }
2133    }
2134
2135    /// C11 ジェネリック選択 (_Generic) をパースし、選択枝の式へ脱糖する
2136    ///
2137    /// 制御式は未評価オペランド (C11 6.5.1.1) なので AST には残さない。
2138    /// 本来の選択は制御式の型で決まるが、パース段階では型情報が無いため
2139    /// default 枝（無ければ先頭の枝）を採用する。実世界での主用途である
2140    /// glibc の __glibc_const_generic (C23 の const 修飾ジェネリック関数、
2141    /// 全枝が const キャストの有無を除いて同値) ではこの近似で正しい値になる。
2142    fn parse_generic_selection(&mut self, loc: SourceLocation) -> Result<Expr> {
2143        self.expect(&TokenKind::LParen)?;
2144        // 制御式（未評価なので捨てる）
2145        let _controlling = self.parse_assignment_expr()?;
2146
2147        let mut default_expr: Option<Expr> = None;
2148        let mut first_expr: Option<Expr> = None;
2149
2150        while self.check(&TokenKind::Comma) {
2151            self.advance()?;
2152            let is_default = if self.check(&TokenKind::KwDefault) {
2153                self.advance()?;
2154                true
2155            } else {
2156                let _type_name = self.parse_type_name()?;
2157                false
2158            };
2159            self.expect(&TokenKind::Colon)?;
2160            let expr = self.parse_assignment_expr()?;
2161            if is_default {
2162                if default_expr.is_none() {
2163                    default_expr = Some(expr);
2164                }
2165            } else if first_expr.is_none() {
2166                first_expr = Some(expr);
2167            }
2168        }
2169        self.expect(&TokenKind::RParen)?;
2170
2171        default_expr.or(first_expr).ok_or_else(|| CompileError::Parse {
2172            loc,
2173            kind: ParseError::UnexpectedToken {
2174                expected: "generic association".to_string(),
2175                found: self.current.kind.clone(),
2176            },
2177        })
2178    }
2179
2180    /// wrapped マクロ（assert 等）を Assert 式としてパース
2181    ///
2182    /// MacroBegin(is_wrapped=true) から args を取得し、condition をパースして
2183    /// Assert 式を生成する。その後 MacroEnd までスキップ。
2184    ///
2185    /// `assert_` や `__ASSERT_` は末尾カンマ形式で、式の前に付ける修飾子として使用される。
2186    /// 空展開時はカンマがないため、後続の式があれば暗黙的にカンマ式を形成する。
2187    fn parse_wrapped_macro_expr(&mut self) -> Result<Expr> {
2188        let loc = self.current.loc.clone();
2189
2190        // MacroBegin から情報を取得
2191        let (marker_id, macro_name, args) = match &self.current.kind {
2192            TokenKind::MacroBegin(info) if info.is_wrapped => {
2193                let args = match &info.kind {
2194                    MacroInvocationKind::Function { args } => args.clone(),
2195                    MacroInvocationKind::Object => {
2196                        let name = self.source.interner().get(info.macro_name).to_string();
2197                        return Err(CompileError::Parse {
2198                            loc,
2199                            kind: ParseError::AssertNotFunctionMacro { macro_name: name },
2200                        });
2201                    }
2202                };
2203                (info.marker_id, info.macro_name, args)
2204            }
2205            _ => unreachable!("parse_wrapped_macro_expr called without wrapped MacroBegin"),
2206        };
2207
2208        // 引数数チェック（assert は 1 引数）
2209        if args.len() != 1 {
2210            let name = self.source.interner().get(macro_name).to_string();
2211            return Err(CompileError::Parse {
2212                loc,
2213                kind: ParseError::InvalidAssertArgs {
2214                    macro_name: name,
2215                    arg_count: args.len(),
2216                },
2217            });
2218        }
2219
2220        // args[0] から condition をパース
2221        let condition = self.parse_expr_from_tokens(&args[0], &loc)?;
2222
2223        // AssertKind を判定
2224        let macro_name_str = self.source.interner().get(macro_name);
2225        let kind = detect_assert_kind(macro_name_str).unwrap_or(AssertKind::Assert);
2226
2227        // MacroBegin を消費して MacroEnd までスキップ
2228        // 注意: advance() は inner_next_token() を使うため MacroEnd をスキップしてしまう
2229        // そのため、ここでは skip_to_macro_end() を使って直接ソースから読み取る
2230        self.skip_to_macro_end(marker_id)?;
2231
2232        let assert_expr = Expr::new(ExprKind::Assert {
2233            kind,
2234            condition: Box::new(condition),
2235        }, loc.clone());
2236
2237        // 末尾カンマ形式（assert_, __ASSERT_）の場合、後続の式と暗黙的にカンマ式を形成
2238        // 次のトークンが式の開始（別の Assert 含む）であれば結合
2239        if self.is_expression_start() {
2240            // 後続の式をパース（再帰的に Assert もパースされる）
2241            let next_expr = self.parse_assignment_expr()?;
2242            Ok(Expr::new(
2243                ExprKind::Comma {
2244                    lhs: Box::new(assert_expr),
2245                    rhs: Box::new(next_expr),
2246                },
2247                loc,
2248            ))
2249        } else {
2250            Ok(assert_expr)
2251        }
2252    }
2253
2254    /// preserve_call マクロを MacroCall 式としてパース
2255    ///
2256    /// MacroBegin(preserve_call=true) から元の引数を取得し、
2257    /// 展開結果をパースして MacroCall ノードを生成する。
2258    ///
2259    /// MacroCall は元のマクロ呼び出し情報と展開結果を両方保持することで：
2260    /// - 展開結果で型推論を実行
2261    /// - コード生成時にマクロ呼び出し形式で出力可能
2262    fn parse_macro_call_expr(&mut self) -> Result<Expr> {
2263        let loc = self.current.loc.clone();
2264
2265        // MacroBegin から情報を取得
2266        let (marker_id, macro_name, raw_args, call_loc) = match &self.current.kind {
2267            TokenKind::MacroBegin(info) if info.preserve_call => {
2268                let args = match &info.kind {
2269                    MacroInvocationKind::Function { args } => args.clone(),
2270                    MacroInvocationKind::Object => Vec::new(),
2271                };
2272                (info.marker_id, info.macro_name, args, info.call_loc.clone())
2273            }
2274            _ => unreachable!("parse_macro_call_expr called without preserve_call MacroBegin"),
2275        };
2276
2277        // MacroBegin を消費（advance は inner_next_token を使うため MacroEnd もスキップされる可能性がある）
2278        // そのため、ここでは source から直接読み取って展開トークンを収集
2279        let expanded_tokens = self.collect_tokens_until_macro_end(marker_id)?;
2280
2281        // 展開トークンから式をパース
2282        let expanded = if expanded_tokens.is_empty() {
2283            // 空展開の場合は 0 を返す（void 式として扱う）
2284            Expr::new(ExprKind::IntLit(0), loc.clone())
2285        } else {
2286            crate::parser::parse_expression_from_tokens_ref(
2287                expanded_tokens,
2288                self.source.interner(),
2289                self.source.files(),
2290                &self.typedefs,
2291            )?
2292        };
2293
2294        // 元の引数トークン列を式としてパース
2295        let parsed_args: Result<Vec<Expr>> = raw_args.iter()
2296            .map(|arg_tokens| {
2297                if arg_tokens.is_empty() {
2298                    // 空引数の場合
2299                    Ok(Expr::new(ExprKind::IntLit(0), loc.clone()))
2300                } else {
2301                    crate::parser::parse_expression_from_tokens_ref(
2302                        arg_tokens.clone(),
2303                        self.source.interner(),
2304                        self.source.files(),
2305                        &self.typedefs,
2306                    )
2307                }
2308            })
2309            .collect();
2310        let args = parsed_args?;
2311
2312        // current を次のトークンで更新
2313        self.current = self.inner_next_token()?;
2314
2315        Ok(Expr::new(ExprKind::MacroCall {
2316            name: macro_name,
2317            args,
2318            expanded: Box::new(expanded),
2319            call_loc,
2320        }, loc))
2321    }
2322
2323    /// 指定した marker_id に対応する MacroEnd までのトークンを収集
2324    ///
2325    /// source から直接読み取り、MacroBegin/MacroEnd のネストを追跡する。
2326    fn collect_tokens_until_macro_end(&mut self, target_marker_id: TokenId) -> Result<Vec<Token>> {
2327        let mut tokens = Vec::new();
2328        let mut nested_depth = 0;
2329
2330        loop {
2331            let token = self.source.next_token()?;
2332
2333            match &token.kind {
2334                TokenKind::MacroBegin(_) => {
2335                    // ネストされたマクロ展開開始
2336                    nested_depth += 1;
2337                    tokens.push(token);
2338                }
2339                TokenKind::MacroEnd(info) => {
2340                    if nested_depth > 0 {
2341                        // ネストされたマクロ展開終了
2342                        nested_depth -= 1;
2343                        tokens.push(token);
2344                    } else if info.begin_marker_id == target_marker_id {
2345                        // 目標の MacroEnd を見つけた
2346                        return Ok(tokens);
2347                    } else {
2348                        // 異なる MacroEnd（これは起こらないはず）
2349                        tokens.push(token);
2350                    }
2351                }
2352                TokenKind::Eof => {
2353                    return Err(CompileError::Parse {
2354                        loc: token.loc,
2355                        kind: ParseError::UnexpectedToken {
2356                            expected: "MacroEnd".to_string(),
2357                            found: token.kind,
2358                        },
2359                    });
2360                }
2361                _ => {
2362                    tokens.push(token);
2363                }
2364            }
2365        }
2366    }
2367
2368    /// 現在のトークンが式の開始かどうかを判定
2369    fn is_expression_start(&self) -> bool {
2370        match &self.current.kind {
2371            // 式の開始になり得るトークン
2372            TokenKind::Ident(_)
2373            | TokenKind::IntLit(_)
2374            | TokenKind::UIntLit(_)
2375            | TokenKind::FloatLit(_)
2376            | TokenKind::CharLit(_)
2377            | TokenKind::WideCharLit(_)
2378            | TokenKind::StringLit(_)
2379            | TokenKind::WideStringLit(_)
2380            | TokenKind::LParen
2381            | TokenKind::Star      // 間接参照
2382            | TokenKind::Amp       // アドレス取得
2383            | TokenKind::Plus      // 単項プラス
2384            | TokenKind::Minus     // 単項マイナス
2385            | TokenKind::Bang      // 論理否定
2386            | TokenKind::Tilde     // ビット反転
2387            | TokenKind::PlusPlus  // 前置インクリメント
2388            | TokenKind::MinusMinus // 前置デクリメント
2389            | TokenKind::KwSizeof
2390            | TokenKind::KwAlignof
2391            | TokenKind::KwAlignof2
2392            | TokenKind::KwAlignof3
2393            | TokenKind::MacroBegin(_) => true, // 別の Assert も含む
2394            _ => false,
2395        }
2396    }
2397
2398    /// トークン列から式をパース
2399    ///
2400    /// args から取り出したトークン列を一時的なソースとして式をパースする。
2401    /// 入れ子の wrapped マクロがあればエラー。
2402    fn parse_expr_from_tokens(&self, tokens: &[Token], loc: &SourceLocation) -> Result<Expr> {
2403        // 入れ子チェック：tokens 内に wrapped MacroBegin があればエラー
2404        for token in tokens {
2405            if let TokenKind::MacroBegin(info) = &token.kind {
2406                if info.is_wrapped {
2407                    return Err(CompileError::Parse {
2408                        loc: loc.clone(),
2409                        kind: ParseError::NestedAssertNotSupported,
2410                    });
2411                }
2412            }
2413        }
2414
2415        // トークン列から式をパース
2416        crate::parser::parse_expression_from_tokens_ref(
2417            tokens.to_vec(),
2418            self.source.interner(),
2419            self.source.files(),
2420            &self.typedefs,
2421        )
2422    }
2423
2424    /// 指定した marker_id に対応する MacroEnd までスキップ
2425    ///
2426    /// inner_next_token は MacroEnd をスキップするため、
2427    /// ここでは source から直接読み取る。
2428    fn skip_to_macro_end(&mut self, target_marker_id: TokenId) -> Result<()> {
2429        // まず current をチェック（MacroBegin の直後なので通常は MacroEnd ではない）
2430        loop {
2431            // source から直接読み取る（inner_next_token は MacroEnd をスキップするため）
2432            let token = self.source.next_token()?;
2433
2434            match &token.kind {
2435                TokenKind::MacroEnd(info) if info.begin_marker_id == target_marker_id => {
2436                    // 目標の MacroEnd を見つけた
2437                    // current を次のトークンで更新（inner_next_token を使って正常なフローに戻す）
2438                    self.current = self.inner_next_token()?;
2439                    return Ok(());
2440                }
2441                TokenKind::Eof => {
2442                    return Err(CompileError::Parse {
2443                        loc: token.loc.clone(),
2444                        kind: ParseError::MacroEndNotFound,
2445                    });
2446                }
2447                _ => {
2448                    // 他のトークンはスキップ（MacroBegin/MacroEnd 含む）
2449                    continue;
2450                }
2451            }
2452        }
2453    }
2454
2455    // ==================== ユーティリティ ====================
2456
2457    /// 内部トークン取得メソッド（マーカーを透過的に処理）
2458    ///
2459    /// `handle_macro_markers` が true の場合、MacroBegin/MacroEnd マーカーを
2460    /// 処理してスキップし、通常のトークンのみを返す。
2461    /// ただし、以下の MacroBegin はスキップせず返す：
2462    /// - `is_wrapped=true`: assert 等の特殊処理用
2463    /// - `preserve_call=true`: MacroCall ノード生成用
2464    /// 空展開でもこれらの MacroBegin を返し、適切な AST ノードを生成する。
2465    fn inner_next_token(&mut self) -> Result<Token> {
2466        loop {
2467            let token = self.source.next_token()?;
2468
2469            if !self.handle_macro_markers {
2470                return Ok(token);
2471            }
2472
2473            match &token.kind {
2474                TokenKind::MacroBegin(info) => {
2475                    if info.is_wrapped {
2476                        // wrapped マクロ（assert 等）は常に返す
2477                        // 空展開でも Assert ノードとして AST に残す
2478                        return Ok(token);
2479                    }
2480                    if info.preserve_call {
2481                        // preserve_call マクロは常に返す
2482                        // MacroCall ノードとして AST に残す
2483                        return Ok(token);
2484                    }
2485                    // 通常のマクロ展開開始：コンテキストにプッシュ
2486                    self.macro_ctx.push((**info).clone());
2487                    continue; // マーカーはスキップ
2488                }
2489                TokenKind::MacroEnd(_info) => {
2490                    // マクロ展開終了：コンテキストからポップ
2491                    self.macro_ctx.pop();
2492                    continue; // マーカーはスキップ
2493                }
2494                _ => return Ok(token),
2495            }
2496        }
2497    }
2498
2499    fn advance(&mut self) -> Result<Token> {
2500        let next = self.inner_next_token()?;
2501        let old = std::mem::replace(&mut self.current, next);
2502        Ok(old)
2503    }
2504
2505    /// 現在のマクロコンテキストから NodeInfo を作成
2506    pub fn make_node_info(&self, loc: SourceLocation) -> NodeInfo {
2507        match self.macro_ctx.build_macro_info(self.source.interner()) {
2508            Some(macro_info) => NodeInfo::with_macro_info(loc, macro_info),
2509            None => NodeInfo::new(loc),
2510        }
2511    }
2512
2513    /// 現在マクロ展開中かどうか
2514    pub fn is_in_macro(&self) -> bool {
2515        self.macro_ctx.is_in_macro()
2516    }
2517
2518    /// マクロ展開の深さ
2519    pub fn macro_depth(&self) -> usize {
2520        self.macro_ctx.depth()
2521    }
2522
2523    fn expect(&mut self, kind: &TokenKind) -> Result<Token> {
2524        if self.check(kind) {
2525            self.advance()
2526        } else {
2527            Err(CompileError::Parse {
2528                loc: self.current.loc.clone(),
2529                kind: ParseError::UnexpectedToken {
2530                    expected: format!("{:?}", kind),
2531                    found: self.current.kind.clone(),
2532                },
2533            })
2534        }
2535    }
2536
2537    fn expect_ident(&mut self) -> Result<InternedStr> {
2538        if let TokenKind::Ident(id) = self.current.kind {
2539            self.advance()?;
2540            Ok(id)
2541        } else {
2542            Err(CompileError::Parse {
2543                loc: self.current.loc.clone(),
2544                kind: ParseError::UnexpectedToken {
2545                    expected: "identifier".to_string(),
2546                    found: self.current.kind.clone(),
2547                },
2548            })
2549        }
2550    }
2551
2552    fn check(&self, kind: &TokenKind) -> bool {
2553        std::mem::discriminant(&self.current.kind) == std::mem::discriminant(kind)
2554    }
2555
2556    fn is_eof(&self) -> bool {
2557        matches!(self.current.kind, TokenKind::Eof)
2558    }
2559
2560    fn current_ident(&self) -> Option<InternedStr> {
2561        if let TokenKind::Ident(id) = self.current.kind {
2562            Some(id)
2563        } else {
2564            None
2565        }
2566    }
2567
2568    /// 引数に型名を取りうるビルトイン関数名かどうか
2569    fn is_type_arg_builtin(&self, name: InternedStr) -> bool {
2570        let s = self.source.interner().get(name);
2571        matches!(s, "offsetof" | "__builtin_offsetof"
2572                  | "__builtin_types_compatible_p"
2573                  | "__builtin_va_arg"
2574                  | "STRUCT_OFFSET")
2575    }
2576
2577    /// ビルトイン関数の引数をパース（型名と式を自動判定）
2578    fn parse_builtin_args(&mut self) -> Result<Vec<BuiltinArg>> {
2579        let mut args = Vec::new();
2580        if !self.check(&TokenKind::RParen) {
2581            loop {
2582                if self.is_type_start() {
2583                    let type_name = self.parse_type_name()?;
2584                    args.push(BuiltinArg::TypeName(Box::new(type_name)));
2585                } else {
2586                    let expr = self.parse_assignment_expr()?;
2587                    args.push(BuiltinArg::Expr(Box::new(expr)));
2588                }
2589                if !self.check(&TokenKind::Comma) {
2590                    break;
2591                }
2592                self.advance()?;
2593            }
2594        }
2595        Ok(args)
2596    }
2597
2598    fn is_type_start(&self) -> bool {
2599        match &self.current.kind {
2600            // 型指定子キーワード
2601            TokenKind::KwVoid
2602            | TokenKind::KwChar
2603            | TokenKind::KwShort
2604            | TokenKind::KwInt
2605            | TokenKind::KwLong
2606            | TokenKind::KwFloat
2607            | TokenKind::KwDouble
2608            | TokenKind::KwSigned
2609            | TokenKind::KwSigned2
2610            | TokenKind::KwUnsigned
2611            | TokenKind::KwBool
2612            | TokenKind::KwBool2
2613            | TokenKind::KwComplex
2614            | TokenKind::KwFloat16
2615            | TokenKind::KwFloat32
2616            | TokenKind::KwFloat64
2617            | TokenKind::KwFloat128
2618            | TokenKind::KwFloat32x
2619            | TokenKind::KwFloat64x
2620            | TokenKind::KwInt128 => true,
2621            // 型修飾子キーワード
2622            TokenKind::KwConst
2623            | TokenKind::KwConst2
2624            | TokenKind::KwConst3
2625            | TokenKind::KwVolatile
2626            | TokenKind::KwVolatile2
2627            | TokenKind::KwVolatile3
2628            | TokenKind::KwRestrict
2629            | TokenKind::KwRestrict2
2630            | TokenKind::KwRestrict3
2631            | TokenKind::KwAtomic => true,
2632            // 構造体・共用体・列挙
2633            TokenKind::KwStruct | TokenKind::KwUnion | TokenKind::KwEnum => true,
2634            // typeof
2635            TokenKind::KwTypeof | TokenKind::KwTypeof2 | TokenKind::KwTypeof3 => true,
2636            // typedef名 or 検出済みの generic 型パラメータ
2637            TokenKind::Ident(id) => {
2638                self.typedefs.contains(id) || self.detected_type_params.contains(id)
2639            }
2640            _ => false,
2641        }
2642    }
2643
2644    fn is_declaration_start(&self) -> bool {
2645        match &self.current.kind {
2646            // ストレージクラス
2647            TokenKind::KwTypedef
2648            | TokenKind::KwExtern
2649            | TokenKind::KwStatic
2650            | TokenKind::KwAuto
2651            | TokenKind::KwRegister => true,
2652            // inline
2653            TokenKind::KwInline | TokenKind::KwInline2 | TokenKind::KwInline3 => true,
2654            // GCC拡張
2655            TokenKind::KwExtension => true,
2656            // thread-local
2657            TokenKind::KwThreadLocal | TokenKind::KwThread => true,
2658            _ => self.is_type_start(),
2659        }
2660    }
2661
2662    /// __attribute__ / __asm__ があればスキップ（複数連続も対応）
2663    fn try_skip_attribute(&mut self) -> Result<()> {
2664        loop {
2665            match &self.current.kind {
2666                TokenKind::KwAttribute | TokenKind::KwAttribute2 => {
2667                    self.skip_attribute()?;
2668                }
2669                TokenKind::KwAsm | TokenKind::KwAsm2 | TokenKind::KwAsm3 => {
2670                    self.try_skip_asm_label()?;
2671                }
2672                _ => break,
2673            }
2674        }
2675        Ok(())
2676    }
2677
2678    /// GCC拡張: __attribute__((...)) をスキップ
2679    fn skip_attribute(&mut self) -> Result<()> {
2680        self.advance()?; // __attribute__ / __attribute
2681
2682        // 外側の ( を期待
2683        if !self.check(&TokenKind::LParen) {
2684            return Ok(()); // 引数なしの場合
2685        }
2686        self.advance()?;
2687
2688        // 内側の ( を期待
2689        if !self.check(&TokenKind::LParen) {
2690            // 単一括弧の場合もある
2691            self.skip_balanced_parens()?;
2692            return Ok(());
2693        }
2694        self.advance()?;
2695
2696        // 内側の括弧の中身をスキップ
2697        self.skip_balanced_parens()?;
2698
2699        // 外側の ) を期待
2700        self.expect(&TokenKind::RParen)?;
2701
2702        Ok(())
2703    }
2704
2705    /// __asm__(label) があればスキップ
2706    fn try_skip_asm_label(&mut self) -> Result<()> {
2707        if matches!(
2708            self.current.kind,
2709            TokenKind::KwAsm | TokenKind::KwAsm2 | TokenKind::KwAsm3
2710        ) {
2711            self.advance()?; // asm / __asm / __asm__
2712            if self.check(&TokenKind::LParen) {
2713                self.advance()?; // (
2714                self.skip_balanced_parens()?; // 内容をスキップして ) を消費
2715            }
2716        }
2717        Ok(())
2718    }
2719
2720    /// 括弧のバランスを取りながらスキップ
2721    fn skip_balanced_parens(&mut self) -> Result<()> {
2722        let mut depth = 1;
2723        while depth > 0 {
2724            match &self.current.kind {
2725                TokenKind::LParen => depth += 1,
2726                TokenKind::RParen => depth -= 1,
2727                TokenKind::Eof => {
2728                    return Err(CompileError::Parse {
2729                        loc: self.current.loc.clone(),
2730                        kind: ParseError::UnexpectedToken {
2731                            expected: ")".to_string(),
2732                            found: TokenKind::Eof,
2733                        },
2734                    });
2735                }
2736                _ => {}
2737            }
2738            if depth > 0 {
2739                self.advance()?;
2740            }
2741        }
2742        self.advance()?; // 最後の )
2743        Ok(())
2744    }
2745}
2746
2747// ==================== ヘルパー関数 ====================
2748
2749use crate::source::FileRegistry;
2750use crate::token_source::TokenSlice;
2751
2752/// トークン列から式をパース
2753///
2754/// マクロ本体などのトークン列を式としてパースする際に使用。
2755///
2756/// # Arguments
2757/// * `tokens` - パースするトークン列
2758/// * `interner` - 文字列インターナー
2759/// * `files` - ファイルレジストリ
2760/// * `typedefs` - typedef名のセット（キャスト式の型名判定に使用）
2761pub fn parse_expression_from_tokens(
2762    tokens: Vec<Token>,
2763    interner: StringInterner,
2764    files: FileRegistry,
2765    typedefs: HashSet<InternedStr>,
2766) -> Result<Expr> {
2767    let mut source = TokenSlice::new(tokens, interner, files);
2768    let mut parser = Parser::from_source_with_typedefs(&mut source, typedefs)?;
2769    parser.parse_expr_only()
2770}
2771
2772/// トークン列から式をパース（参照ベース版）
2773///
2774/// `parse_expression_from_tokens` の参照ベース版。
2775/// interner, files, typedefs をクローンせずに借用することで、
2776/// 高頻度の呼び出し時のオーバーヘッドを削減する。
2777///
2778/// # Arguments
2779/// * `tokens` - パースするトークン列
2780/// * `interner` - 文字列インターナーへの参照
2781/// * `files` - ファイルレジストリへの参照
2782/// * `typedefs` - typedef名のセットへの参照
2783pub fn parse_expression_from_tokens_ref(
2784    tokens: Vec<Token>,
2785    interner: &StringInterner,
2786    files: &FileRegistry,
2787    typedefs: &HashSet<InternedStr>,
2788) -> Result<Expr> {
2789    let mut source = TokenSliceRef::new(tokens, interner, files);
2790    let mut parser = Parser::from_source_with_typedefs(&mut source, typedefs.clone())?;
2791    parser.parse_expr_only()
2792}
2793
2794/// トークン列を文としてパース（参照ベース版）
2795///
2796/// マクロ body のパースに使用。do-while の末尾セミコロンは省略可能。
2797///
2798/// # Arguments
2799/// * `tokens` - パースするトークン列
2800/// * `interner` - 文字列インターナーへの参照
2801/// * `files` - ファイルレジストリへの参照
2802/// * `typedefs` - typedef名のセットへの参照
2803pub fn parse_statement_from_tokens_ref(
2804    tokens: Vec<Token>,
2805    interner: &StringInterner,
2806    files: &FileRegistry,
2807    typedefs: &HashSet<InternedStr>,
2808) -> Result<Stmt> {
2809    let mut source = TokenSliceRef::new(tokens, interner, files);
2810    let mut parser = Parser::from_source_with_typedefs(&mut source, typedefs.clone())?;
2811    parser.parse_stmt_allow_missing_semi()
2812}
2813
2814/// パース結果に付随する統計情報
2815#[derive(Debug, Clone, Default)]
2816pub struct ParseStats {
2817    /// 関数呼び出しの数
2818    pub function_call_count: usize,
2819    /// ポインタデリファレンスの数
2820    pub deref_count: usize,
2821}
2822
2823impl ParseStats {
2824    /// unsafe 操作を含むか
2825    pub fn has_unsafe_ops(&self) -> bool {
2826        self.function_call_count > 0 || self.deref_count > 0
2827    }
2828}
2829
2830/// トークン列から式をパース（統計情報付き・参照ベース版）
2831///
2832/// `parse_expression_from_tokens_ref` と同様だが、
2833/// パース統計（関数呼び出し数など）も返す。
2834///
2835/// # Arguments
2836/// * `tokens` - パースするトークン列
2837/// * `interner` - 文字列インターナーへの参照
2838/// * `files` - ファイルレジストリへの参照
2839/// * `typedefs` - typedef名のセットへの参照
2840///
2841/// # Returns
2842/// (パースされた式, 統計情報)
2843pub fn parse_expression_from_tokens_ref_with_stats(
2844    tokens: Vec<Token>,
2845    interner: &StringInterner,
2846    files: &FileRegistry,
2847    typedefs: &HashSet<InternedStr>,
2848) -> Result<(Expr, ParseStats)> {
2849    let mut source = TokenSliceRef::new(tokens, interner, files);
2850    let mut parser = Parser::from_source_with_typedefs(&mut source, typedefs.clone())?;
2851    let expr = parser.parse_expr_only()?;
2852    let stats = ParseStats {
2853        function_call_count: parser.function_call_count,
2854        deref_count: parser.deref_count,
2855    };
2856    Ok((expr, stats))
2857}
2858
2859/// トークン列から式をパース（generic_params 付き）
2860///
2861/// マクロ本体のパースに使用。マクロの仮引数名を generic_params として渡し、
2862/// キャスト式での型パラメータ使用を自動検出する。
2863///
2864/// # Returns
2865/// (パースされた式, 統計情報, 検出された型パラメータ)
2866pub fn parse_expression_from_tokens_ref_with_generic_params(
2867    tokens: Vec<Token>,
2868    interner: &StringInterner,
2869    files: &FileRegistry,
2870    typedefs: &HashSet<InternedStr>,
2871    generic_params: HashMap<InternedStr, usize>,
2872) -> Result<(Expr, ParseStats, HashSet<InternedStr>)> {
2873    let mut source = TokenSliceRef::new(tokens, interner, files);
2874    let mut parser = Parser::from_source_with_typedefs(&mut source, typedefs.clone())?;
2875    parser.generic_params = generic_params;
2876    let expr = parser.parse_expr_only()?;
2877    let stats = ParseStats {
2878        function_call_count: parser.function_call_count,
2879        deref_count: parser.deref_count,
2880    };
2881    let detected = parser.detected_type_params;
2882    Ok((expr, stats, detected))
2883}
2884
2885/// トークン列を文としてパース（統計情報付き・参照ベース版）
2886///
2887/// `parse_statement_from_tokens_ref` と同様だが、
2888/// パース統計（関数呼び出し数など）も返す。
2889/// do-while の末尾セミコロンは省略可能。
2890///
2891/// # Arguments
2892/// * `tokens` - パースするトークン列
2893/// * `interner` - 文字列インターナーへの参照
2894/// * `files` - ファイルレジストリへの参照
2895/// * `typedefs` - typedef名のセットへの参照
2896///
2897/// # Returns
2898/// (パースされた文, 統計情報)
2899pub fn parse_statement_from_tokens_ref_with_stats(
2900    tokens: Vec<Token>,
2901    interner: &StringInterner,
2902    files: &FileRegistry,
2903    typedefs: &HashSet<InternedStr>,
2904) -> Result<(Stmt, ParseStats)> {
2905    let mut source = TokenSliceRef::new(tokens, interner, files);
2906    let mut parser = Parser::from_source_with_typedefs(&mut source, typedefs.clone())?;
2907    let stmt = parser.parse_stmt_allow_missing_semi()?;
2908    let stats = ParseStats {
2909        function_call_count: parser.function_call_count,
2910        deref_count: parser.deref_count,
2911    };
2912    Ok((stmt, stats))
2913}
2914
2915/// トークン列を文としてパース（generic_params 付き）
2916///
2917/// マクロ本体のパースに使用。マクロの仮引数名を generic_params として渡し、
2918/// キャスト式での型パラメータ使用を自動検出する。
2919///
2920/// # Returns
2921/// (パースされた文, 統計情報, 検出された型パラメータ)
2922pub fn parse_statement_from_tokens_ref_with_generic_params(
2923    tokens: Vec<Token>,
2924    interner: &StringInterner,
2925    files: &FileRegistry,
2926    typedefs: &HashSet<InternedStr>,
2927    generic_params: HashMap<InternedStr, usize>,
2928) -> Result<(Stmt, ParseStats, HashSet<InternedStr>)> {
2929    let mut source = TokenSliceRef::new(tokens, interner, files);
2930    let mut parser = Parser::from_source_with_typedefs(&mut source, typedefs.clone())?;
2931    parser.generic_params = generic_params;
2932    let stmt = parser.parse_stmt_allow_missing_semi()?;
2933    let stats = ParseStats {
2934        function_call_count: parser.function_call_count,
2935        deref_count: parser.deref_count,
2936    };
2937    let detected = parser.detected_type_params;
2938    Ok((stmt, stats, detected))
2939}
2940
2941/// トークン列を複数のブロック項目としてパース
2942///
2943/// セミコロン区切りの複数文を含むマクロ本体のパースに使用。
2944/// `{ }` なしの BlockItem リストをパースし、EOF まで読む。
2945///
2946/// # Returns
2947/// (パースされたブロック項目リスト, 統計情報)
2948pub fn parse_block_items_from_tokens_ref_with_stats(
2949    tokens: Vec<Token>,
2950    interner: &StringInterner,
2951    files: &FileRegistry,
2952    typedefs: &HashSet<InternedStr>,
2953) -> Result<(Vec<BlockItem>, ParseStats)> {
2954    let mut source = TokenSliceRef::new(tokens, interner, files);
2955    let mut parser = Parser::from_source_with_typedefs(&mut source, typedefs.clone())?;
2956    parser.allow_missing_semi = true;
2957    let mut items = Vec::new();
2958    while !parser.check(&TokenKind::Eof) {
2959        items.push(parser.parse_block_item()?);
2960    }
2961    let stats = ParseStats {
2962        function_call_count: parser.function_call_count,
2963        deref_count: parser.deref_count,
2964    };
2965    Ok((items, stats))
2966}
2967
2968/// トークン列を複数のブロック項目としてパース（generic_params 付き）
2969///
2970/// # Returns
2971/// (パースされたブロック項目リスト, 統計情報, 検出された型パラメータ)
2972pub fn parse_block_items_from_tokens_ref_with_generic_params(
2973    tokens: Vec<Token>,
2974    interner: &StringInterner,
2975    files: &FileRegistry,
2976    typedefs: &HashSet<InternedStr>,
2977    generic_params: HashMap<InternedStr, usize>,
2978) -> Result<(Vec<BlockItem>, ParseStats, HashSet<InternedStr>)> {
2979    let mut source = TokenSliceRef::new(tokens, interner, files);
2980    let mut parser = Parser::from_source_with_typedefs(&mut source, typedefs.clone())?;
2981    parser.allow_missing_semi = true;
2982    parser.generic_params = generic_params;
2983    let mut items = Vec::new();
2984    while !parser.check(&TokenKind::Eof) {
2985        items.push(parser.parse_block_item()?);
2986    }
2987    let stats = ParseStats {
2988        function_call_count: parser.function_call_count,
2989        deref_count: parser.deref_count,
2990    };
2991    let detected = parser.detected_type_params;
2992    Ok((items, stats, detected))
2993}
2994
2995/// 型文字列から TypeName をパース
2996///
2997/// apidoc 等の型文字列（例: "SV *", "const char *"）をパースして
2998/// TypeName AST を返す。ReadOnlyLexer を使用するため、
2999/// 型文字列内の識別子は既に intern 済みである必要がある。
3000///
3001/// # Arguments
3002/// * `type_str` - パースする型文字列
3003/// * `interner` - 文字列インターナーへの参照（読み取り専用）
3004/// * `files` - ファイルレジストリへの参照
3005/// * `typedefs` - typedef名のセットへの参照
3006///
3007/// # Returns
3008/// パースされた TypeName AST、または識別子が未知の場合はエラー
3009pub fn parse_type_from_string(
3010    type_str: &str,
3011    interner: &StringInterner,
3012    files: &FileRegistry,
3013    typedefs: &HashSet<InternedStr>,
3014) -> Result<TypeName> {
3015    // 型文字列用のダミー FileId（エラー時の位置情報は限定的）
3016    let file_id = FileId::default();
3017
3018    // ReadOnlyLexer でトークン化（新規 intern なし）
3019    let mut lexer = Lexer::<LookupOnly>::new_readonly(type_str.as_bytes(), file_id, interner);
3020
3021    let mut tokens = Vec::new();
3022    loop {
3023        let token = lexer.next_token()?;
3024        if matches!(token.kind, TokenKind::Eof) {
3025            break;
3026        }
3027        tokens.push(token);
3028    }
3029
3030    // パース
3031    let mut source = TokenSliceRef::new(tokens, interner, files);
3032    let mut parser = Parser::from_source_with_typedefs(&mut source, typedefs.clone())?;
3033    parser.parse_type_name()
3034}
3035
3036/// トークン列を struct メンバー宣言の連続としてパースする。
3037///
3038/// `_XPVCV_COMMON` のような共通フィールド宣言マクロの本体を解析する用途。
3039/// 入力末尾に `;` が無い場合は自動補完する（マクロ本体は典型的に最終
3040/// 宣言の後に `;` を持たない — 展開先で `;` が補われる）。
3041pub fn parse_struct_members_from_tokens_ref(
3042    mut tokens: Vec<Token>,
3043    interner: &StringInterner,
3044    files: &FileRegistry,
3045    typedefs: &HashSet<InternedStr>,
3046) -> Result<Vec<StructMember>> {
3047    // 末尾に `;` が無ければ補う（最後の意味のあるトークンを見て判定）
3048    let needs_trailing_semi = tokens
3049        .iter()
3050        .rev()
3051        .find(|t| !matches!(t.kind, TokenKind::Eof))
3052        .is_some_and(|t| !matches!(t.kind, TokenKind::Semi));
3053    if needs_trailing_semi {
3054        // EOF を取り除いて `;` を足し直す
3055        let eof = tokens.iter().position(|t| matches!(t.kind, TokenKind::Eof))
3056            .map(|i| tokens.remove(i));
3057        let semi_loc = tokens.last().map(|t| t.loc.clone()).unwrap_or_default();
3058        tokens.push(Token::new(TokenKind::Semi, semi_loc));
3059        if let Some(eof) = eof {
3060            tokens.push(eof);
3061        }
3062    }
3063    let mut source = TokenSliceRef::new(tokens, interner, files);
3064    let mut parser = Parser::from_source_with_typedefs(&mut source, typedefs.clone())?;
3065    let mut members = Vec::new();
3066    while !parser.check(&TokenKind::Eof) {
3067        members.push(parser.parse_struct_member()?);
3068    }
3069    Ok(members)
3070}
3071
3072#[cfg(test)]
3073mod tests {
3074    use super::*;
3075    use crate::preprocessor::PPConfig;
3076    use std::io::Write;
3077    use tempfile::NamedTempFile;
3078
3079    fn parse_str(code: &str) -> Result<TranslationUnit> {
3080        let mut file = NamedTempFile::new().unwrap();
3081        file.write_all(code.as_bytes()).unwrap();
3082
3083        let mut pp = Preprocessor::new(PPConfig::default());
3084        pp.add_source_file(file.path())?;
3085
3086        let mut parser = Parser::new(&mut pp)?;
3087        parser.parse()
3088    }
3089
3090    #[test]
3091    fn test_simple_function() {
3092        let tu = parse_str("int main(void) { return 0; }").unwrap();
3093        assert_eq!(tu.decls.len(), 1);
3094        assert!(matches!(tu.decls[0], ExternalDecl::FunctionDef(_)));
3095    }
3096
3097    #[test]
3098    fn test_variable_declaration() {
3099        let tu = parse_str("int x;").unwrap();
3100        assert_eq!(tu.decls.len(), 1);
3101        assert!(matches!(tu.decls[0], ExternalDecl::Declaration(_)));
3102    }
3103
3104    #[test]
3105    fn test_struct_declaration() {
3106        let tu = parse_str("struct Point { int x; int y; };").unwrap();
3107        assert_eq!(tu.decls.len(), 1);
3108    }
3109
3110    #[test]
3111    fn test_typedef() {
3112        let tu = parse_str("typedef int INT; INT x;").unwrap();
3113        assert_eq!(tu.decls.len(), 2);
3114    }
3115
3116    #[test]
3117    fn test_expression() {
3118        let tu = parse_str("int x = 1 + 2 * 3;").unwrap();
3119        assert_eq!(tu.decls.len(), 1);
3120    }
3121}
libperl_macrogen/parser.rs

libperl_macrogen/
parser.rs
