Парсинг определения функции C++

Вопрос или проблема

  fn parse_function_def (input: &str) -> Vec<String> {
    let mut iter = input.chars().peekable();
    let mut func_def:Vec<String> = Vec::new();  // Строка для хранения всего определения класса

    let mut level = 0;

    let mut temp_str  = String::new();
    let mut return_type = String::new();
    let mut func_name = String::new();
    let mut func_args = String::new();
    let mut whole_func = String::new();



    while let Some(c)= iter.next() {

        temp_str.push(c);

        if c == '(' {
            return_type = temp_str.clone();
            temp_str.clear();
        }

        if c == ')' {
            func_name = temp_str.clone();
            temp_str.clear();
        }

        if c == '{' {
            func_args = temp_str.clone();
            temp_str.clear();
        }

        if c == '}' {
            // func_def.push(return_type.clone());
            // func_def.push(func_name.clone());
            // func_def.push(func_args.clone());
            whole_func.push_str(&return_type);
            whole_func.push_str(&func_name);
            whole_func.push_str(&func_args);
            func_def.push(whole_func.clone());
            level += 1;
            break;
        }
    }


    return func_def;

    
}


fn main() {
    let input = "for(int i = 0; i < 10; i++) {
        cout << i << endl;
    }";

    let func_def = parse_function_def(input);
    println!("Определение функции: {:?}", func_def);

}

Ответ или решение

Для решения задачи парсинга определения функции на языке C++ существует ряд ключевых аспектов, которые нужно учитывать при разработке алгоритма. Ваш текущий код на языке Rust пытается извлечь возвращаемый тип, имя функции и параметры, но сталкивается с проблемой, когда парсит не те структурные элементы кода, такие как циклы for. Давайте разберем, как можно улучшить ваш код, чтобы он правильно извлекал только определения функций.

Основные аспекты парсинга

1. Идентификация функции:
   Чтобы избежать парсинга конструкций, которые не являются определениями функций (например, циклы, условные операторы), необходимо уточнить правила определения функций. Определение функции в C++ включает:

   • Возвращаемый тип (может содержать модификаторы, такие как const, &, *)
   • Имя функции
   • Параметры, заключенные в круглые скобки

2. Использование регулярных выражений:
   Один из эффективных способов извлечения информации из строк — это использование регулярных выражений. Они позволяют точно определять шаблоны, соответствующие определениям функций.

Улучшение вашего кода

Рассмотрим модификацию вашего текущего кода на Rust, используя регулярные выражения для более точного извлечения данных. Вот как может выглядеть обновленный вариант вашей функции parse_function_def:

use regex::Regex;

fn parse_function_def(input: &str) -> Vec<String> {
    let mut func_defs: Vec<String> = Vec::new();

    // Регулярное выражение для извлечения определений функций
    let re = Regex::new(r"(?P<return_type>[\w\s\*&]+)\s+(?P<func_name>[\w_]+)\((?P<params>[^)]*)\)\s*\{").unwrap();

    for line in input.lines() {
        if let Some(captures) = re.captures(line) {
            let return_type = captures.name("return_type").unwrap().as_str();
            let func_name = captures.name("func_name").unwrap().as_str();
            let params = captures.name("params").unwrap().as_str();
            func_defs.push(format!("{} {}({})", return_type, func_name, params));
        }
    }

    func_defs
}

fn main() {
    let input = r#"
    int func1(int a, float b) {
        return a + b;
    }

    for(int i = 0; i < 10; i++) {
        cout << i << endl;
    }

    void func2() {
        // do something
    }
    "#;

    let func_defs = parse_function_def(input);
    println!("Function definitions: {:?}", func_defs);
}

Объяснение исправленного кода

1. Регулярное выражение:
   Используется регулярное выражение для захвата возвращаемого типа, имени функции и параметров. Это дает большую точность и позволяет избежать ошибок при парсинге циклов и других конструкций.

2. Обработка строк:
   Код проходит по всем строкам входного текста, ищет соответствия с регулярным выражением и добавляет найденные определения функций в вектор func_defs.

3. Результат:
   Вывод результата будет содержать только корректные определения функций, что соответствует вашим требованиям.

Заключение

Использование регулярных выражений для парсинга кода C++ позволяет значительно повысить точность и надежность. Обновленный пример кода должен лучше решать вашу первоначальную задачу по извлечению определений функций, исключая циклы и другие конструкции.