Automatic binding generation

crates/header-translator/Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+name = "header-translator"
+version = "0.1.0"
+edition = "2021"
+publish = false
+
+repository = "https://github.com/madsmtm/objc2"
+license = "Zlib OR Apache-2.0 OR MIT"
+
+[dependencies]
+clang = { version = "2.0", features = ["runtime", "clang_10_0"] }
+toml = "0.5.9"
+serde = { version = "1.0.144", features = ["derive"] }
+apple-sdk = { version = "0.2.0", default-features = false }

crates/header-translator/README.md

@@ -0,0 +1,11 @@
+# Objective-C header translator
+
+For use in making `icrate`.
+
+```console
+cargo run --bin header-translator -- /Applications/Xcode.app/Contents/Developer
+```
+
+## SDKs
+
+We do not redistribute the relevant SDKs, to hopefully avoid a license violation. You can download the SDKs yourself (they're bundled in XCode) from [Apple's website](https://developer.apple.com/download/all/?q=xcode) (requires an Apple ID).

crates/header-translator/framework-includes.h

@@ -0,0 +1,17 @@
+// Workaround for clang < 13, only used in NSBundle.h
+#define NS_FORMAT_ARGUMENT(A)
+
+// Workaround for clang < 13
+#define _Nullable_result _Nullable
+
+#include <TargetConditionals.h>
+
+#import <Foundation/Foundation.h>
+
+#import <CoreData/CoreData.h>
+
+#if TARGET_OS_OSX
+#import <AppKit/AppKit.h>
+#endif
+
+#import <AuthenticationServices/AuthenticationServices.h>

crates/header-translator/src/availability.rs

@@ -0,0 +1,15 @@
+use clang::PlatformAvailability;
+
+#[derive(Debug, Clone)]
+pub struct Availability {
+    #[allow(dead_code)]
+    inner: Vec<PlatformAvailability>,
+}
+
+impl Availability {
+    pub fn parse(availability: Vec<PlatformAvailability>) -> Self {
+        Self {
+            inner: availability,
+        }
+    }
+}

crates/header-translator/src/config.rs

@@ -0,0 +1,108 @@
+use std::collections::HashMap;
+use std::fs;
+use std::io::Result;
+use std::path::Path;
+
+use serde::Deserialize;
+
+#[derive(Deserialize, Debug, Clone, PartialEq, Eq)]
+#[serde(deny_unknown_fields)]
+pub struct Config {
+    #[serde(rename = "class")]
+    #[serde(default)]
+    pub class_data: HashMap<String, ClassData>,
+    #[serde(rename = "protocol")]
+    #[serde(default)]
+    pub protocol_data: HashMap<String, ClassData>,
+    #[serde(rename = "struct")]
+    #[serde(default)]
+    pub struct_data: HashMap<String, StructData>,
+    #[serde(rename = "enum")]
+    #[serde(default)]
+    pub enum_data: HashMap<String, EnumData>,
+    #[serde(rename = "fn")]
+    #[serde(default)]
+    pub fns: HashMap<String, FnData>,
+    #[serde(rename = "static")]
+    #[serde(default)]
+    pub statics: HashMap<String, StaticData>,
+    #[serde(rename = "typedef")]
+    #[serde(default)]
+    pub typedef_data: HashMap<String, TypedefData>,
+    #[serde(default)]
+    pub imports: Vec<String>,
+}
+
+#[derive(Deserialize, Debug, Default, Clone, PartialEq, Eq)]
+#[serde(deny_unknown_fields)]
+pub struct ClassData {
+    #[serde(default)]
+    pub skipped: bool,
+    #[serde(rename = "superclass-name")]
+    #[serde(default)]
+    pub new_superclass_name: Option<String>,
+    #[serde(default)]
+    pub methods: HashMap<String, MethodData>,
+    #[serde(default)]
+    pub properties: HashMap<String, MethodData>,
+}
+
+#[derive(Deserialize, Debug, Default, Clone, PartialEq, Eq)]
+#[serde(deny_unknown_fields)]
+pub struct StructData {
+    #[serde(default)]
+    pub skipped: bool,
+}
+
+#[derive(Deserialize, Debug, Default, Clone, PartialEq, Eq)]
+#[serde(deny_unknown_fields)]
+pub struct EnumData {
+    #[serde(default)]
+    pub skipped: bool,
+    #[serde(rename = "use-value")]
+    #[serde(default)]
+    pub use_value: bool,
+    #[serde(default)]
+    pub constants: HashMap<String, StructData>,
+}
+
+#[derive(Deserialize, Debug, Clone, Copy, PartialEq, Eq)]
+#[serde(deny_unknown_fields)]
+pub struct MethodData {
+    #[serde(rename = "unsafe")]
+    #[serde(default = "unsafe_default")]
+    pub unsafe_: bool,
+    #[serde(default = "skipped_default")]
+    pub skipped: bool,
+    // TODO: mutating
+}
+
+// TODO
+pub type FnData = StructData;
+pub type StaticData = StructData;
+pub type TypedefData = StructData;
+
+fn unsafe_default() -> bool {
+    true
+}
+
+fn skipped_default() -> bool {
+    false
+}
+
+impl Default for MethodData {
+    fn default() -> Self {
+        Self {
+            unsafe_: unsafe_default(),
+            skipped: skipped_default(),
+        }
+    }
+}
+
+impl Config {
+    pub fn from_file(file: &Path) -> Result<Self> {
+        let s = fs::read_to_string(file)?;
+
+        Ok(toml::from_str(&s)?)
+    }
+}

crates/header-translator/src/expr.rs

@@ -0,0 +1,130 @@
+use std::fmt;
+use std::fmt::Write;
+
+use clang::token::TokenKind;
+use clang::{Entity, EntityKind, EntityVisitResult};
+
+use crate::unexposed_macro::UnexposedMacro;
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct Expr {
+    s: String,
+}
+
+impl Expr {
+    pub fn from_val((signed, unsigned): (i64, u64), is_signed: bool) -> Self {
+        let s = if is_signed {
+            format!("{}", signed)
+        } else {
+            format!("{}", unsigned)
+        };
+        Expr { s }
+    }
+
+    pub fn parse_enum_constant(entity: &Entity<'_>) -> Option<Self> {
+        let mut declaration_references = Vec::new();
+
+        entity.visit_children(|entity, _parent| {
+            if let EntityKind::DeclRefExpr = entity.get_kind() {
+                let name = entity.get_name().expect("expr decl ref name");
+                declaration_references.push(name);
+            }
+            EntityVisitResult::Recurse
+        });
+
+        let mut res = None;
+
+        entity.visit_children(|entity, _parent| {
+            match entity.get_kind() {
+                EntityKind::UnexposedAttr => {
+                    if let Some(macro_) = UnexposedMacro::parse(&entity) {
+                        panic!("parsed macro in expr: {macro_:?}, {entity:?}");
+                    }
+                }
+                _ => {
+                    if res.is_none() {
+                        res = Self::parse(&entity, &declaration_references);
+                    } else {
+                        panic!("found multiple expressions where one was expected");
+                    }
+                }
+            }
+            EntityVisitResult::Continue
+        });
+
+        res
+    }
+
+    pub fn parse_var(entity: &Entity<'_>) -> Option<Self> {
+        Self::parse(entity, &[])
+    }
+
+    fn parse(entity: &Entity<'_>, declaration_references: &[String]) -> Option<Self> {
+        let range = entity.get_range().expect("expr range");
+        let tokens = range.tokenize();
+
+        if tokens.is_empty() {
+            // TODO: Find a better way to parse macros
+            return None;
+        }
+
+        let mut s = String::new();
+
+        for token in &tokens {
+            match (token.get_kind(), token.get_spelling()) {
+                (TokenKind::Identifier, ident) => {
+                    if declaration_references.contains(&ident) {
+                        // TODO: Handle these specially when we need to
+                    }
+                    write!(s, "{}", ident).unwrap();
+                }
+                (TokenKind::Literal, lit) => {
+                    let lit = lit
+                        .trim_end_matches("UL")
+                        .trim_end_matches("L")
+                        .trim_end_matches("u")
+                        .trim_end_matches("U");
+                    let lit = lit.replace("0X", "0x");
+                    write!(s, "{}", lit).unwrap();
+                }
+                (TokenKind::Punctuation, punct) => {
+                    match &*punct {
+                        // These have the same semantics in C and Rust
+                        "(" | ")" | "<<" | "-" | "+" | "|" | "&" | "^" => {
+                            write!(s, "{}", punct).unwrap()
+                        }
+                        // Bitwise not
+                        "~" => write!(s, "!").unwrap(),
+                        punct => panic!("unknown expr punctuation {punct}"),
+                    }
+                }
+                (kind, spelling) => panic!("unknown expr token {kind:?}/{spelling}"),
+            }
+        }
+
+        // Trim casts
+        s = s
+            .trim_start_matches("(NSBoxType)")
+            .trim_start_matches("(NSBezelStyle)")
+            .trim_start_matches("(NSEventSubtype)")
+            .trim_start_matches("(NSWindowButton)")
+            .trim_start_matches("(NSExpressionType)")
+            .to_string();
+
+        // Trim unnecessary parentheses
+        if s.starts_with('(')
+            && s.ends_with(')')
+            && s.chars().filter(|&c| c == '(' || c == ')').count() == 2
+        {
+            s = s.trim_start_matches("(").trim_end_matches(")").to_string();
+        }
+
+        Some(Self { s })
+    }
+}
+
+impl fmt::Display for Expr {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.s)
+    }
+}