build: rename crate from pac to parc

Author: bresilla

Cargo.toml

@@ -1,12 +1,12 @@
 [package]
-name = "pac"
+name = "parc"
 version = "0.16.0"
 authors = ["Vickenty Fesunov <kent@setattr.net>"]
 edition = "2021"
 license = "MIT/Apache-2.0"
 description = "C language frontend: preprocessing, parsing, and source-level semantic extraction"
 include = [ "/src/**/*.rs", "Cargo.toml", "/LICENSE*", "/README.md" ]
-documentation = "https://docs.rs/pac"
+documentation = "https://docs.rs/parc"
 homepage = "https://github.com/vickenty/lang-c"
 repository = "https://github.com/vickenty/lang-c"
 keywords = [ "ast", "c", "parser", "ffi", "preprocessing" ]

README.md

@@ -1,13 +1,12 @@
-# PAC (parser c)
+# PARC
 
-[![Documentation](https://docs.rs/pac/badge.svg)](https://docs.rs/pac)
+[![Documentation](https://docs.rs/parc/badge.svg)](https://docs.rs/parc)
 
-PAC (parser c) is a lightweight parser of the C language for Rust users. Almost full support for the C11 revision of the language.
-Several GCC and Clang extensions are also supported as an option.
+PARC is a C language frontend: preprocessing, parsing, and source-level semantic extraction.
+Full support for C11 with GNU and Clang extensions.
 
 ```rust
-extern crate pac;
-use pac::driver::{Config, parse}; 
+use parc::driver::{Config, parse};
 
 fn main() {
     let config = Config::default();
@@ -17,7 +16,7 @@ fn main() {
 
 # Bugs
 
-Just open an issue, bug reports and patches are most welcome. 
+Just open an issue, bug reports and patches are most welcome.
 
 ## License
 

book/book.toml

@@ -1,7 +1,7 @@
 [book]
 authors = ["Trim Bresilla"]
 language = "en"
-title = "PAC Reference"
+title = "PARC Reference"
 
 [output.html]
 default-theme = "navy"

book/src/010_getting_started.md

@@ -4,17 +4,17 @@
 
 ```toml
 [dependencies]
-pac = { path = "../pac" }
+parc = { path = "../pac" }
 ```
 
 ## Pick the right API first
 
-Use `pac::driver` when you have a file on disk and want PAC to run a system preprocessor first.
+Use `parc::driver` when you have a file on disk and want PAC to run a system preprocessor first.
 
 ```rust
-use pac::driver::{parse, Config};
+use parc::driver::{parse, Config};
 
-fn main() -> Result<(), pac::driver::Error> {
+fn main() -> Result<(), parc::driver::Error> {
     let config = Config::default();
     let parsed = parse(&config, "examples/sample.c")?;
 
@@ -24,11 +24,11 @@ fn main() -> Result<(), pac::driver::Error> {
 }
 ```
 
-Use `pac::parse` when you already have source text in memory and want to parse a fragment directly.
+Use `parc::parse` when you already have source text in memory and want to parse a fragment directly.
 
 ```rust
-use pac::driver::Flavor;
-use pac::parse;
+use parc::driver::Flavor;
+use parc::parse;
 
 fn main() {
     let expr = parse::expression("a + b * 2", Flavor::StdC11).unwrap();
@@ -54,7 +54,7 @@ For file-based parsing, `Config::default()` selects:
 You can also select explicitly:
 
 ```rust
-use pac::driver::Config;
+use parc::driver::Config;
 
 let gnu = Config::with_gcc();
 let clang = Config::with_clang();
@@ -65,9 +65,9 @@ let clang = Config::with_clang();
 This example parses a translation unit and counts top-level entries:
 
 ```rust
-use pac::driver::{parse, Config};
+use parc::driver::{parse, Config};
 
-fn main() -> Result<(), pac::driver::Error> {
+fn main() -> Result<(), parc::driver::Error> {
     let parsed = parse(&Config::default(), "examples/header.h")?;
 
     for (i, item) in parsed.unit.0.iter().enumerate() {
@@ -83,8 +83,8 @@ fn main() -> Result<(), pac::driver::Error> {
 If you only need one declaration or statement, the direct parser API is faster to wire in:
 
 ```rust
-use pac::driver::Flavor;
-use pac::parse;
+use parc::driver::Flavor;
+use parc::parse;
 
 fn main() {
     let decl = parse::declaration("static const int answer = 42;", Flavor::StdC11).unwrap();

book/src/015_workflows.md

@@ -18,7 +18,7 @@ the right API.
 Use this when your source depends on `#include`, `#define`, or compiler predefined macros.
 
 ```rust
-use pac::driver::{parse, Config};
+use parc::driver::{parse, Config};
 
 let config = Config::default();
 let parsed = parse(&config, "src/main.c")?;
@@ -34,7 +34,7 @@ This gives you:
 Use this when another tool already ran preprocessing and you only want PAC to parse.
 
 ```rust
-use pac::driver::{parse_preprocessed, Config};
+use parc::driver::{parse_preprocessed, Config};
 
 let config = Config::default();
 let source = r#"
@@ -55,11 +55,11 @@ This is useful for:
 
 ## Parse a fragment
 
-Use `pac::parse` when you are not dealing with a whole file.
+Use `parc::parse` when you are not dealing with a whole file.
 
 ```rust
-use pac::driver::Flavor;
-use pac::parse;
+use parc::driver::Flavor;
+use parc::parse;
 
 let expr = parse::expression("ptr->len + 1", Flavor::GnuC11)?;
 let decl = parse::declaration("unsigned long flags;", Flavor::StdC11)?;
@@ -83,9 +83,9 @@ The normal analyzer flow is:
 Example outline:
 
 ```rust
-use pac::driver::{parse, Config};
-use pac::visit::{self, Visit};
-use pac::{ast, span};
+use parc::driver::{parse, Config};
+use parc::visit::{self, Visit};
+use parc::{ast, span};
 
 struct FunctionCounter {
     count: usize,
@@ -106,24 +106,24 @@ let parsed = parse(&Config::default(), "src/main.c")?;
 let mut counter = FunctionCounter { count: 0 };
 counter.visit_translation_unit(&parsed.unit);
 println!("functions: {}", counter.count);
-# Ok::<(), pac::driver::Error>(())
+# Ok::<(), parc::driver::Error>(())
 ```
 
 ## Debug the parse tree
 
 Use the printer when you need a human-readable structural dump:
 
 ```rust
-use pac::driver::{parse, Config};
-use pac::print::Printer;
-use pac::visit::Visit;
+use parc::driver::{parse, Config};
+use parc::print::Printer;
+use parc::visit::Visit;
 
 let parsed = parse(&Config::default(), "src/main.c")?;
 
 let mut out = String::new();
 Printer::new(&mut out).visit_translation_unit(&parsed.unit);
 println!("{}", out);
-# Ok::<(), pac::driver::Error>(())
+# Ok::<(), parc::driver::Error>(())
 ```
 
 ## Rule of thumb

book/src/020_driver.md

@@ -32,22 +32,22 @@ The return value matters:
 ## Basic file parsing
 
 ```rust
-use pac::driver::{parse, Config};
+use parc::driver::{parse, Config};
 
 let config = Config::default();
 let parsed = parse(&config, "examples/demo.c")?;
 
 println!("preprocessed bytes: {}", parsed.source.len());
 println!("top-level nodes: {}", parsed.unit.0.len());
-# Ok::<(), pac::driver::Error>(())
+# Ok::<(), parc::driver::Error>(())
 ```
 
 ## Configuring the preprocessor
 
 You can override both the preprocessor executable and its arguments.
 
 ```rust
-use pac::driver::{parse, Config, Flavor};
+use parc::driver::{parse, Config, Flavor};
 
 let config = Config {
     cpp_command: "gcc".into(),
@@ -61,7 +61,7 @@ let config = Config {
 };
 
 let parsed = parse(&config, "src/input.c")?;
-# Ok::<(), pac::driver::Error>(())
+# Ok::<(), parc::driver::Error>(())
 ```
 
 This is the place to inject:
@@ -75,7 +75,7 @@ This is the place to inject:
 The convenience constructors also select parser flavor:
 
 ```rust
-use pac::driver::Config;
+use parc::driver::Config;
 
 let gcc = Config::with_gcc();     // gcc -E, GNU flavor
 let clang = Config::with_clang(); // clang -E, Clang flavor
@@ -89,7 +89,7 @@ preprocessor.
 If you already have `.i`-style content, skip `parse` and call `parse_preprocessed`.
 
 ```rust
-use pac::driver::{parse_preprocessed, Config};
+use parc::driver::{parse_preprocessed, Config};
 
 let source = r#"
 # 1 "sample.i"
@@ -100,15 +100,15 @@ count_t next(count_t x) { return x + 1; }
 
 let parsed = parse_preprocessed(&Config::default(), source)?;
 println!("{}", parsed.unit.0.len());
-# Ok::<(), pac::driver::SyntaxError>(())
+# Ok::<(), parc::driver::SyntaxError>(())
 ```
 
 ## Error model
 
 `driver::parse` returns:
 
 ```rust
-Result<Parse, pac::driver::Error>
+Result<Parse, parc::driver::Error>
 ```
 
 The error variants are:
@@ -127,7 +127,7 @@ The error variants are:
 Example:
 
 ```rust
-use pac::driver::{parse_preprocessed, Config};
+use parc::driver::{parse_preprocessed, Config};
 
 let broken = "int main( { return 0; }".to_string();
 match parse_preprocessed(&Config::default(), broken) {
@@ -148,13 +148,13 @@ PAC includes a built-in C preprocessor that eliminates the need for an external
 `gcc` or `clang` binary. Use `parse_builtin` instead of `parse`:
 
 ```rust
-use pac::driver::{parse_builtin, Config};
+use parc::driver::{parse_builtin, Config};
 use std::path::Path;
 
 let config = Config::with_gcc();
 let include_paths = vec![Path::new("/usr/include")];
 let parsed = parse_builtin(&config, "src/input.c", &include_paths)?;
-# Ok::<(), pac::driver::Error>(())
+# Ok::<(), parc::driver::Error>(())
 ```
 
 The built-in preprocessor supports:
@@ -172,14 +172,14 @@ The built-in preprocessor supports:
 To extract all `#define` macros from a C file (equivalent to `gcc -dD -E`):
 
 ```rust
-use pac::driver::capture_macros;
+use parc::driver::capture_macros;
 use std::path::Path;
 
 let macros = capture_macros("src/input.c", &[Path::new("/usr/include")])?;
 for (name, value) in &macros {
     println!("#define {} {}", name, value);
 }
-# Ok::<(), pac::driver::Error>(())
+# Ok::<(), parc::driver::Error>(())
 ```
 
 This returns all macros active after preprocessing, including predefined target

book/src/025_preprocessor.md

@@ -1,6 +1,6 @@
 # Built-in Preprocessor
 
-PAC includes a complete built-in C preprocessor in the `pac::preprocess` module.
+PAC includes a complete built-in C preprocessor in the `parc::preprocess` module.
 This eliminates the runtime dependency on `gcc` or `clang` for preprocessing.
 
 ## Architecture
@@ -21,7 +21,7 @@ The preprocessor is split into focused modules:
 ## Quick start
 
 ```rust
-use pac::preprocess::preprocess;
+use parc::preprocess::preprocess;
 
 let output = preprocess("#define X 42\nint a = X;\n");
 // output.tokens contains the expanded token stream
@@ -67,7 +67,7 @@ The `#if` expression evaluator supports:
 ## Include resolution
 
 ```rust
-use pac::preprocess::{IncludeResolver, Processor};
+use parc::preprocess::{IncludeResolver, Processor};
 
 let mut resolver = IncludeResolver::new();
 resolver.add_system_path("/usr/include");
@@ -92,7 +92,7 @@ Features:
 Target-specific macros are available for common platforms:
 
 ```rust
-use pac::preprocess::{MacroTable, Target, define_target_macros};
+use parc::preprocess::{MacroTable, Target, define_target_macros};
 
 let mut table = MacroTable::new();
 define_target_macros(&mut table, &Target::host());

book/src/026_source_ir.md

@@ -1,14 +1,14 @@
 # Source IR
 
-The `pac::ir` module defines the durable intermediate representation produced
+The `parc::ir` module defines the durable intermediate representation produced
 by the PARC frontend. It is the primary contract between the parser/extractor
 and downstream consumers (LINC, GERC).
 
 ## Design Principles
 
 - **Smaller than the AST**: only normalized declarations, not the full syntax tree
 - **Serializable**: all types derive `serde::Serialize` and `serde::Deserialize`
-- **Parser-agnostic**: downstream consumers should depend on `pac::ir`, not `pac::ast`
+- **Parser-agnostic**: downstream consumers should depend on `parc::ir`, not `parc::ast`
 - **No link/binary concerns**: no ABI probing, no library paths, no symbol validation
 
 ## Key Types
@@ -18,7 +18,7 @@ and downstream consumers (LINC, GERC).
 The top-level container:
 
 ```rust
-use pac::ir::SourcePackage;
+use parc::ir::SourcePackage;
 
 let pkg = SourcePackage::new();
 assert!(pkg.is_empty());
@@ -68,7 +68,7 @@ Frontend diagnostic with kind, severity, message, optional location, and optiona
 All IR types support JSON roundtrip:
 
 ```rust
-use pac::ir::SourcePackage;
+use parc::ir::SourcePackage;
 
 let pkg = SourcePackage::new();
 let json = serde_json::to_string_pretty(&pkg).unwrap();