Пятнадцать байтов на стек от конца

// Top-level program structure
TranslationUnit = Declaration*

// Declarations
Declaration = Type Identifier ';'
            | Type Identifier '(' ParameterList ')' CompoundStmt
ParameterList = (Type Identifier (',' Type Identifier)*)?

// Types
Type = 'int'
     | 'float'
     | 'char'
     | 'void'

// Statements
Stmt = CompoundStmt
     | ExprStmt
     | IfStmt
     | WhileStmt
     | ReturnStmt

CompoundStmt = '{' Declaration* Stmt* '}'
ExprStmt = Expr ';'
IfStmt = 'if' '(' Expr ')' Stmt ('else' Stmt)?
WhileStmt = 'while' '(' Expr ')' Stmt
ReturnStmt = 'return' Expr? ';'

// Expressions
Expr = AssignmentExpr
AssignmentExpr = EqualityExpr ('=' EqualityExpr)?
EqualityExpr = RelationalExpr (('==' | '!=') RelationalExpr)?
RelationalExpr = AddExpr (('<' | '>' | '<=' | '>=') AddExpr)?
AddExpr = MultExpr (('+' | '-') MultExpr)*
MultExpr = UnaryExpr (('*' | '/') UnaryExpr)*
UnaryExpr = PrimaryExpr
          | '-' UnaryExpr
          | '!' UnaryExpr
PrimaryExpr = Identifier
            | Number
            | String
            | '(' Expr ')'

// Basic tokens
Identifier = <token>
Number = <token>
String = <token>

int x = 42;
int main(int argc) {
    int y = 3 + 5 * 2;
    if (y > x) {
        return 1;
    } else {
        return 0;
    }
}

$ cargo run
...
     Running `/home/vak/c_parser/target/debug/c_parser`
( результат )

• Лексический сканер Lex
• Грамматический парсер Yacc

• The Zephyr Abstract Syntax Description Language
• Abstract Syntax Tree Implementation Idioms

• jyn514/saltwater
• ClementTsang/rustcc

#include <variant>
#include <memory>
#include <string>
#include <stdexcept>

// A simplified Cow implementation in C++
template<typename T>
class Cow {
private:
    // Using variant to hold either a borrowed pointer or an owned value
    std::variant<const T*, std::unique_ptr<T>> data;

public:
    // Constructor for borrowed value
    explicit Cow(const T* borrowed) : data(borrowed) {
        if (!borrowed) {
            throw std::invalid_argument("Borrowed pointer cannot be null");
        }
    }

    // Constructor for owned value
    explicit Cow(T&& owned) : data(std::make_unique<T>(std::move(owned))) {}

    // Copy constructor
    Cow(const Cow& other) {
        if (std::holds_alternative<const T*>(other.data)) {
            data = std::get<const T*>(other.data);
        } else {
            const auto& owned = std::get<std::unique_ptr<T>>(other.data);
            data = std::make_unique<T>(*owned);
        }
    }

    // Move constructor
    Cow(Cow&& other) noexcept = default;

    // Assignment operators
    Cow& operator=(const Cow& other) {
        if (this != &other) {
            Cow temp(other);
            swap(*this, temp);
        }
        return *this;
    }

    Cow& operator=(Cow&& other) noexcept = default;

    // Access the underlying value (non-mutating)
    const T& operator*() const {
        if (std::holds_alternative<const T*>(data)) {
            return *std::get<const T*>(data);
        }
        return *std::get<std::unique_ptr<T>>(data);
    }

    const T* operator->() const {
        return &(**this);
    }

    // Check if the Cow holds a borrowed value
    bool is_borrowed() const {
        return std::holds_alternative<const T*>(data);
    }

    // Check if the Cow holds an owned value
    bool is_owned() const {
        return std::holds_alternative<std::unique_ptr<T>>(data);
    }

    // Convert to owned value if borrowed (clone on write)
    void to_owned() {
        if (is_borrowed()) {
            data = std::make_unique<T>(*std::get<const T*>(data));
        }
    }

    // Swap implementation
    friend void swap(Cow& lhs, Cow& rhs) noexcept {
        using std::swap;
        swap(lhs.data, rhs.data);
    }
};

#include <mutex>
#include <memory>

template<typename T>
class Mutex {
private:
    T data;
    std::mutex mtx;

public:
    // Constructor
    explicit Mutex(T value) : data(std::move(value)) {}

    // Lock guard class (similar to Rust's MutexGuard)
    class LockGuard {
    private:
        T& data_ref;
        std::unique_lock<std::mutex> lock;

    public:
        LockGuard(T& d, std::mutex& m)
            : data_ref(d), lock(m) {}

        // Access the underlying data
        T& operator*() { return data_ref; }
        T* operator->() { return &data_ref; }
    };

    // Lock method that returns the guard
    LockGuard lock() {
        return LockGuard(data, mtx);
    }

    // Prevent copying
    Mutex(const Mutex&) = delete;
    Mutex& operator=(const Mutex&) = delete;

    // Allow move construction
    Mutex(Mutex&&) = default;
    Mutex& operator=(Mutex&&) = default;
};

• A container for the value.
• Counters for active immutable and mutable borrows.
• Methods to borrow the value immutably (borrow) or mutably (borrow_mut), returning smart pointers that enforce the borrowing rules.
• Runtime checks to panic (or throw, in C++ terms) if the rules are violated.

#include <iostream>
#include <memory>
#include <stdexcept>
#include <utility>

template <typename T>
class RefCell {
private:
    T value;
    mutable size_t borrow_count;  // Tracks immutable borrows
    mutable bool borrowed_mut;    // Tracks if there's a mutable borrow

public:
    explicit RefCell(T initial) : value(std::move(initial)), borrow_count(0), borrowed_mut(false) {}

    class Ref {
    private:
        const RefCell<T>* cell;
        friend class RefCell<T>;

        Ref(const RefCell<T>* c) : cell(c) {
            if (cell->borrowed_mut) {
                throw std::runtime_error("Already mutably borrowed");
            }
            cell->borrow_count++;
        }

    public:
        ~Ref() {
            if (cell) {
                cell->borrow_count--;
            }
        }

        Ref(const Ref&) = delete;
        Ref& operator=(const Ref&) = delete;
        Ref(Ref&& other) noexcept : cell(other.cell) { other.cell = nullptr; }

        const T& get() const { return cell->value; }
    };

    class RefMut {
    private:
        RefCell<T>* cell;
        friend class RefCell<T>;

        RefMut(RefCell<T>* c) : cell(c) {
            if (c->borrow_count > 0 || c->borrowed_mut) {
                throw std::runtime_error("Already borrowed");
            }
            c->borrowed_mut = true;
        }

    public:
        ~RefMut() {
            if (cell) {
                cell->borrowed_mut = false;
            }
        }

        RefMut(const RefMut&) = delete;
        RefMut& operator=(const RefMut&) = delete;
        RefMut(RefMut&& other) noexcept : cell(other.cell) { other.cell = nullptr; }

        T& get() { return cell->value; }

        void set(T new_value) {
            cell->value = std::move(new_value);
        }
    };

    Ref borrow() const { return Ref(this); }
    RefMut borrow_mut() { return RefMut(this); }
};

#include <atomic>
#include <memory>
#include <utility>
#include <type_traits>

// Define Inner as a standalone template struct
template <typename T>
struct ArcInner {
    T data;
    std::atomic<int> ref_count;

    template <typename... Args>
    ArcInner(Args&&... args) : data(std::forward<Args>(args)...), ref_count(1) {}
};

template <typename T>
class Arc {
private:
    ArcInner<T>* ptr;

    void increment_count() {
        if (ptr) {
            ptr->ref_count.fetch_add(1, std::memory_order_relaxed);
        }
    }

    void decrement_count() {
        if (ptr) {
            if (ptr->ref_count.fetch_sub(1, std::memory_order_acq_rel) == 1) {
                delete ptr;
                ptr = nullptr;
            }
        }
    }

public:
    // Constructor with constraint: Args must be convertible to T
    template <typename... Args, typename = std::enable_if_t<std::is_constructible_v<T, Args...>>>
    explicit Arc(Args&&... args) : ptr(new ArcInner<T>(std::forward<Args>(args)...)) {}

    // Copy constructor
    Arc(const Arc& other) : ptr(other.ptr) {
        increment_count();
    }

    // Move constructor
    Arc(Arc&& other) noexcept : ptr(other.ptr) {
        other.ptr = nullptr;
    }

    // Assignment operators
    Arc& operator=(const Arc& other) {
        if (this != &other) {
            decrement_count();
            ptr = other.ptr;
            increment_count();
        }
        return *this;
    }

    Arc& operator=(Arc&& other) noexcept {
        if (this != &other) {
            decrement_count();
            ptr = other.ptr;
            other.ptr = nullptr;
        }
        return *this;
    }

    // Destructor
    ~Arc() {
        decrement_count();
    }

    // Dereference operators
    T& operator*() const { return ptr->data; }
    T* operator->() const { return &ptr->data; }

    // Get the reference count
    int use_count() const { return ptr ? ptr->ref_count.load(std::memory_order_relaxed) : 0; }
};

// Helper function to create an Arc
template <typename T, typename... Args>
Arc<T> make_arc(Args&&... args) {
    return Arc<T>(std::forward<Args>(args)...);
}

fn copy_file_contents(mut dest_file: &fs::File, src_filename: &str) -> Result<(), String> {
    let mut src_file = fs::File::open(src_filename)
                                .map_err(|e| format!("Failed to open source file '{}': {}", src_filename, e))?;
    io::copy(&mut src_file, &mut dest_file)
       .map_err(|e| format!("Failed to copy to destination: {}", e))?;
    Ok(())
}

Let’s dive into translating the Rust idiom Result<(), String> into C++. In Rust, Result is an enum used for error handling, with two variants: Ok(T) for success and Err(E) for failure. Here, Result<(), String> means a function returns either "success with no meaningful value" (Ok(()), where () is the unit type) or "failure with a string error message" (Err(String)). This is a common pattern in Rust for operations that either succeed without producing a value or fail with a descriptive error.

In C++, we don’t have a direct equivalent to Rust’s Result in the standard library, but we can approximate it using modern C++ features. The closest analogs are std::optional, std::variant, or a custom implementation.

Let’s define a reusable Result class with a Rust-like interface, using std::variant under the hood. This adds convenience methods like is_ok(), is_err(), unwrap(), and unwrap_err().

#include <variant>
#include <string>
#include <stdexcept>
#include <iostream>

template<typename T, typename E>
class Result {
public:
    Result(T value) : data(value) {}
    Result(E error) : data(error) {}

    bool is_ok() const { return std::holds_alternative<T>(data); }
    bool is_err() const { return std::holds_alternative<E>(data); }

    T unwrap() const {
        if (is_err()) throw std::runtime_error("Called unwrap() on an Err value");
        return std::get<T>(data);
    }

    E unwrap_err() const {
        if (is_ok()) throw std::runtime_error("Called unwrap_err() on an Ok value");
        return std::get<E>(data);
    }

private:
    std::variant<T, E> data;
};

// Specialize for empty value and std::string
struct Void {};
using VoidResult = Result<Void, std::string>;

This version is the most Rust-like. VoidResult directly corresponds to Result<(), String>. You can call is_ok() or is_err() to check the state, and unwrap() or unwrap_err() to extract values (with error checking). It’s reusable for other T and E types too.

( Си++ )

Smart Pointers in Rust’s Standard Library

• Module: std::boxed
• Purpose: Unique ownership of a heap-allocated T. The simplest smart pointer, providing a single owner with automatic cleanup.
• Use Case: When you need heap allocation without sharing (e.g., recursive data structures, large objects).
• Threading: Safe to send across threads if T: Send.

• Module: std::rc
• Purpose: Reference-counted shared ownership for single-threaded use. Multiple Rc<T> instances share the same T, deallocating when the last reference drops.
• Use Case: Shared immutable data in a single thread (e.g., graph structures).
• Threading: Not thread-safe (!Send, !Sync).
• Notes: Paired with Weak<T> for non-owning refs.

Comparison to C++

• C++ Equivalents:
  • Box<T> ≈ std::unique_ptr<T>
  • Rc<T> ≈ std::shared_ptr<T> (non-atomic version)
  • Arc<T> ≈ std::shared_ptr<T> (atomic)
  • Weak<T> ≈ std::weak_ptr<T>
  • Mutex<T> ≈ std::mutex + std::unique_lock
  • RwLock<T> ≈ std::shared_mutex (C++17)
  • No direct Cell/RefCell - custom runtime checks needed.
  • Cow ≈ custom variant-like type or manual ownership toggling.
• Rust Unique: Cell and RefCell leverage Rust’s borrow checker, offering safety not easily replicated in C++.