Struct Parser

pub struct Parser<'tu> { /* private fields */ }

Parses translation units.

Implementations

impl<'tu> Parser<'tu>

pub fn cache_completion_results( &mut self, cache_completion_results: bool, ) -> &mut Parser<'tu>

Sets whether certain code completion results will be cached when the translation unit is reparsed.

This option increases the time it takes to reparse the translation unit but improves code completion performance.

pub fn detailed_preprocessing_record( &mut self, detailed_preprocessing_record: bool, ) -> &mut Parser<'tu>

Sets whether a detailed preprocessing record will be constructed which tracks all macro definitions and instantiations.

pub fn briefs_in_completion_results( &mut self, briefs_in_completion_results: bool, ) -> &mut Parser<'tu>

Sets whether documentation comment briefs will be included in code completion results.

pub fn incomplete(&mut self, incomplete: bool) -> &mut Parser<'tu>

Sets whether the translation unit will be considered incomplete.

This option suppresses certain semantic analyses and is typically used when parsing headers with the intent of creating a precompiled header.

pub fn skip_function_bodies( &mut self, skip_function_bodies: bool, ) -> &mut Parser<'tu>

Sets whether function and method bodies will be skipped.

pub fn keep_going(&mut self, keep_going: bool) -> &mut Parser<'tu>

Sets whether processing will continue after a fatal error is encountered.

pub fn single_file_parse(&mut self, single_file_parse: bool) -> &mut Parser<'tu>

Sets whether incremental processing will be used.

pub fn limit_skip_function_bodies_to_preamble( &mut self, limit_skip_function_bodies_to_preamble: bool, ) -> &mut Parser<'tu>

Sets whether function bodies will only be skipped in the preamble.

Used in conjunction with skip_function_bodies.

pub fn include_attributed_types( &mut self, include_attributed_types: bool, ) -> &mut Parser<'tu>

Sets whether attributed types should be included.

pub fn visit_implicit_attributes( &mut self, visit_implicit_attributes: bool, ) -> &mut Parser<'tu>

Sets whether implicit attributes should be visited.

pub fn ignore_non_errors_from_included_files( &mut self, ignore_non_errors_from_included_files: bool, ) -> &mut Parser<'tu>

Indicates that non-errors (e.g. warnings) from included files should be ignored.

pub fn retain_excluded_conditional_blocks( &mut self, retain_excluded_conditional_blocks: bool, ) -> &mut Parser<'tu>

Sets whether the preprocessor will retain excluded conditional blocks.

impl<'tu> Parser<'tu>

pub fn arguments<S: AsRef<str>>(&mut self, arguments: &[S]) -> &mut Parser<'tu>

Sets the compiler arguments to provide to libclang.

Any compiler argument that could be supplied to clang may be supplied to this function. However, the following arguments are ignored:

• -c
• -emit-ast
• -fsyntax-only
• -o and the following <output>

pub fn unsaved(&mut self, unsaved: &[Unsaved]) -> &mut Parser<'tu>

Sets the unsaved files to use.

pub fn parse(&self) -> Result<TranslationUnit<'tu>, SourceError>

Parses a translation unit.

Failures

• an error occurs while deserializing an AST file
• libclang crashes
• an unknown error occurs

Examples found in repository

examples/structs.rs (line 13)

fn main() {
    // Acquire an instance of `Clang`
    let clang = Clang::new().unwrap();

    // Create a new `Index`
    let index = Index::new(&clang, false, false);

    // Parse a source file into a translation unit
    let tu = index.parser("examples/structs.c").parse().unwrap();

    // Get the structs in this translation unit
    let structs = tu.get_entity().get_children().into_iter().filter(|e| {
        e.get_kind() == EntityKind::StructDecl
    }).collect::<Vec<_>>();

    // Print information about the structs
    for struct_ in structs {
        let type_ =  struct_.get_type().unwrap();
        let size = type_.get_sizeof().unwrap();
        println!("struct: {:?} (size: {} bytes)", struct_.get_name().unwrap(), size);

        for field in struct_.get_children() {
            let name = field.get_name().unwrap();
            let offset = type_.get_offsetof(&name).unwrap();
            println!("    field: {:?} (offset: {} bits)", name, offset);
        }
    }
}

Trait Implementations

impl<'tu> Clone for Parser<'tu>

fn clone(&self) -> Parser<'tu>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'tu> Debug for Parser<'tu>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.