Initial commit

.github/workflows/test.yml

@@ -21,13 +21,3 @@ jobs:
           node-version: 14
       - run: npm install
       - run: npm test
-
-  test_windows:
-    runs-on: windows-2019
-    steps:
-      - uses: actions/checkout@v2
-      - uses: actions/setup-node@v2
-        with:
-          node-version: 14
-      - run: npm install
-      - run: npm run-script test-windows

Cargo.toml

@@ -0,0 +1,26 @@
+[package]
+name = "tree-sitter-objdump"
+description = "objdump grammar for the tree-sitter parsing library"
+version = "1.0.0"
+keywords = ["incremental", "parsing", "objdump"]
+categories = ["parsing", "text-editors"]
+repository = "https://github.com/ColinKennedy/tree-sitter-objdump"
+edition = "2018"
+license = "MIT"
+
+build = "bindings/rust/build.rs"
+include = [
+  "bindings/rust/*",
+  "grammar.js",
+  "queries/*",
+  "src/*",
+]
+
+[lib]
+path = "bindings/rust/lib.rs"
+
+[dependencies]
+tree-sitter = "~0.20.10"
+
+[build-dependencies]
+cc = "1.0"

README.md

@@ -1 +1,59 @@
-TODO add this
+# tree-sitter-objdump
+This library parses objdump text using
+[tree-sitter](https://tree-sitter.github.io/tree-sitter) to produce
+a light-weight grammar of the file.
+
+
+![tree-sitter-objdump-highlights](https://github.com/ColinKennedy/tree-sitter-objdump/assets/10103049/57ee586d-a021-483f-8dd5-1f090184fde6)
+
+
+## Disclaimer
+This repository's parsing rules are subject to change.
+
+
+## Building + Using
+### Neovim
+Make sure you include the following somewhere in your `init.lua` file.
+
+```lua
+require("nvim-treesitter.configs").setup {
+    ensure_installed = {"objdump"},
+    parser_install_dir = installation_directory,
+    highlight = { enable = true },
+
+    -- More stuff
+}
+```
+
+
+## Testing
+### Unittests
+- Install the [tree-sitter-cli](https://www.npmjs.com/package/tree-sitter-cli)
+```sh
+cd {root}
+tree-sitter test
+```
+
+All tests should pass.
+
+
+### Actual Objdump Files
+The best way to test tree-sitter-usd is to parse Objdump files in-action.
+
+A quick way to do that is to run `check.sh`
+
+
+```sh
+check.sh  # Searches the current directory
+check.sh  /path/to/place
+```
+
+This outputs objdump text to `/tmp/objdump_files`
+
+Then run
+
+```sh
+cat /tmp/objdumps | xargs -I{} sh -c 'tree-sitter parse {} > /dev/null || echo "{}"' > /tmp/fails
+```
+
+If all is going well, the output file `/tmp/fails` should be empty!

binding.gyp

@@ -0,0 +1,19 @@
+{
+  "targets": [
+    {
+      "target_name": "tree_sitter_objdump_binding",
+      "include_dirs": [
+        "<!(node -e \"require('nan')\")",
+        "src"
+      ],
+      "sources": [
+        "bindings/node/binding.cc",
+        "src/parser.c",
+        "src/scanner.cc",
+      ],
+      "cflags_c": [
+        "-std=c99",
+      ]
+    }
+  ]
+}

bindings/node/binding.cc

@@ -0,0 +1,28 @@
+#include "tree_sitter/parser.h"
+#include <node.h>
+#include "nan.h"
+
+using namespace v8;
+
+extern "C" TSLanguage * tree_sitter_objdump();
+
+namespace {
+
+NAN_METHOD(New) {}
+
+void Init(Local<Object> exports, Local<Object> module) {
+  Local<FunctionTemplate> tpl = Nan::New<FunctionTemplate>(New);
+  tpl->SetClassName(Nan::New("Language").ToLocalChecked());
+  tpl->InstanceTemplate()->SetInternalFieldCount(1);
+
+  Local<Function> constructor = Nan::GetFunction(tpl).ToLocalChecked();
+  Local<Object> instance = constructor->NewInstance(Nan::GetCurrentContext()).ToLocalChecked();
+  Nan::SetInternalFieldPointer(instance, 0, tree_sitter_objdump());
+
+  Nan::Set(instance, Nan::New("name").ToLocalChecked(), Nan::New("objdump").ToLocalChecked());
+  Nan::Set(module, Nan::New("exports").ToLocalChecked(), instance);
+}
+
+NODE_MODULE(tree_sitter_objdump_binding, Init)
+
+}  // namespace

bindings/node/index.js

@@ -0,0 +1,19 @@
+try {
+  module.exports = require("../../build/Release/tree_sitter_objdump_binding");
+} catch (error1) {
+  if (error1.code !== 'MODULE_NOT_FOUND') {
+    throw error1;
+  }
+  try {
+    module.exports = require("../../build/Debug/tree_sitter_objdump_binding");
+  } catch (error2) {
+    if (error2.code !== 'MODULE_NOT_FOUND') {
+      throw error2;
+    }
+    throw error1
+  }
+}
+
+try {
+  module.exports.nodeTypeInfo = require("../../src/node-types.json");
+} catch (_) {}

bindings/rust/build.rs

@@ -0,0 +1,38 @@
+fn main() {
+    let src_dir = std::path::Path::new("src");
+
+    let mut c_config = cc::Build::new();
+    c_config.include(&src_dir);
+    c_config
+        .flag_if_supported("-Wno-unused-parameter")
+        .flag_if_supported("-Wno-unused-but-set-variable")
+        .flag_if_supported("-Wno-trigraphs");
+    let parser_path = src_dir.join("parser.c");
+    c_config.file(&parser_path);
+
+    // If your language uses an external scanner written in C,
+    // then include this block of code:
+
+    /*
+    let scanner_path = src_dir.join("scanner.c");
+    c_config.file(&scanner_path);
+    println!("cargo:rerun-if-changed={}", scanner_path.to_str().unwrap());
+    */
+
+    c_config.compile("parser");
+    println!("cargo:rerun-if-changed={}", parser_path.to_str().unwrap());
+
+    // If your language uses an external scanner written in C++,
+    // then include this block of code:
+
+    let mut cpp_config = cc::Build::new();
+    cpp_config.cpp(true);
+    cpp_config.include(&src_dir);
+    cpp_config
+        .flag_if_supported("-Wno-unused-parameter")
+        .flag_if_supported("-Wno-unused-but-set-variable");
+    let scanner_path = src_dir.join("scanner.cc");
+    cpp_config.file(&scanner_path);
+    cpp_config.compile("scanner");
+    println!("cargo:rerun-if-changed={}", scanner_path.to_str().unwrap());
+}

bindings/rust/lib.rs

@@ -0,0 +1,52 @@
+//! This crate provides objdump language support for the [tree-sitter][] parsing library.
+//!
+//! Typically, you will use the [language][language func] function to add this language to a
+//! tree-sitter [Parser][], and then use the parser to parse some code:
+//!
+//! ```
+//! let code = "";
+//! let mut parser = tree_sitter::Parser::new();
+//! parser.set_language(tree_sitter_objdump::language()).expect("Error loading objdump grammar");
+//! let tree = parser.parse(code, None).unwrap();
+//! ```
+//!
+//! [Language]: https://docs.rs/tree-sitter/*/tree_sitter/struct.Language.html
+//! [language func]: fn.language.html
+//! [Parser]: https://docs.rs/tree-sitter/*/tree_sitter/struct.Parser.html
+//! [tree-sitter]: https://tree-sitter.github.io/
+
+use tree_sitter::Language;
+
+extern "C" {
+    fn tree_sitter_objdump() -> Language;
+}
+
+/// Get the tree-sitter [Language][] for this grammar.
+///
+/// [Language]: https://docs.rs/tree-sitter/*/tree_sitter/struct.Language.html
+pub fn language() -> Language {
+    unsafe { tree_sitter_objdump() }
+}
+
+/// The content of the [`node-types.json`][] file for this grammar.
+///
+/// [`node-types.json`]: https://tree-sitter.github.io/tree-sitter/using-parsers#static-node-types
+pub const NODE_TYPES: &'static str = include_str!("../../src/node-types.json");
+
+// Uncomment these to include any queries that this grammar contains
+
+// pub const HIGHLIGHTS_QUERY: &'static str = include_str!("../../queries/highlights.scm");
+// pub const INJECTIONS_QUERY: &'static str = include_str!("../../queries/injections.scm");
+// pub const LOCALS_QUERY: &'static str = include_str!("../../queries/locals.scm");
+// pub const TAGS_QUERY: &'static str = include_str!("../../queries/tags.scm");
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn test_can_load_grammar() {
+        let mut parser = tree_sitter::Parser::new();
+        parser
+            .set_language(super::language())
+            .expect("Error loading objdump language");
+    }
+}

check.sh

@@ -0,0 +1,17 @@
+#!/usr/bin/env bash
+
+directory=${1:-$PWD}
+$($(find $directory -type f -executable | xargs -I{} sh -c "file -i '{}' \; | grep  'x-executable; charset=binary'" 2> /dev/null) | cut -d: -f1 | sed "s:^\.::" | xargs du | sort -n | awk '{print $2}'`)
+
+for file in $files
+do
+    output=/tmp/objdump_files/file_`basename $file`.cppdump
+
+    if [ -e $output ]
+    then
+        continue
+    fi
+
+    echo "Processing $file"
+    objdump "$file" --disassemble-all --demangle=auto --line-numbers --disassemble-zeroes -M intel > $output
+done