Add GitHub Actions

Author: Luni-4

.github/workflows/rust-code-analysis.yml

@@ -0,0 +1,40 @@
+name: Run tests
+
+on: [push, pull_request]
+
+jobs:
+  test-code:
+
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-latest]
+
+    runs-on: ${{ matrix.os }}
+
+    steps:
+    - uses: actions/checkout@v2
+
+    - name: Checkout submodules
+      shell: bash
+      run: |
+        GIT_PATH=https://github.com/.extraheader
+        AUTH_HEADER="$(git config --local --get http.$GIT_PATH)"
+        git submodule sync --recursive
+        git -c "http.extraheader=$AUTH_HEADER" \
+            -c protocol.version=2 \
+            submodule update --init --force --recursive --depth=1
+
+    - name: Install Rust stable
+      uses: actions-rs/toolchain@v1
+      with:
+        profile: minimal
+        toolchain: stable
+        override: true
+
+    - name: Build
+      run: |
+        cargo build --all-features --verbose
+
+    - name: Run tests
+      run: |
+        cargo test --all-features --verbose

build.rs

@@ -96,6 +96,7 @@ fn collect_src_files(dir: &str) -> (Vec<String>, Vec<String>) {
 }
 
 fn build_c(files: Vec<String>, language: &str) {
+    let triple = env::var("TARGET").unwrap();
     let mut build = cc::Build::new();
     for file in files {
         build
@@ -104,8 +105,11 @@ fn build_c(files: Vec<String>, language: &str) {
             .pic(true)
             .opt_level(get_opt_level())
             .debug(get_debug())
-            .warnings(false)
-            .flag("-std=c99");
+            .warnings(false);
+
+        if triple != "x86_64-pc-windows-msvc" {
+            build.flag("-std=c99");
+        }
     }
     build.compile(&format!("tree-sitter-{}-c", language));
 }

tree-sitter-mozcpp/src/scanner.cc

@@ -0,0 +1,119 @@
+#include <tree_sitter/parser.h>
+#include <string>
+#include <cwctype>
+
+namespace {
+
+using std::wstring;
+using std::iswspace;
+
+enum TokenType {
+  RAW_STRING_LITERAL,
+};
+
+struct Scanner {
+  bool scan(TSLexer *lexer, const bool *valid_symbols) {
+    while (iswspace(lexer->lookahead)) {
+      lexer->advance(lexer, true);
+    }
+
+    lexer->result_symbol = RAW_STRING_LITERAL;
+
+    // Raw string literals can start with: R, LR, uR, UR, u8R
+    // Consume 'R'
+    if (lexer->lookahead == 'L' || lexer->lookahead == 'U') {
+      lexer->advance(lexer, false);
+      if (lexer->lookahead != 'R') {
+        return false;
+      }
+    } else if (lexer->lookahead == 'u') {
+      lexer->advance(lexer, false);
+      if (lexer->lookahead == '8') {
+        lexer->advance(lexer, false);
+        if (lexer->lookahead != 'R') {
+          return false;
+        }
+      } else if (lexer->lookahead != 'R') {
+        return false;
+      }
+    } else if (lexer->lookahead != 'R') {
+      return false;
+    }
+    lexer->advance(lexer, false);
+
+    // Consume '"'
+    if (lexer->lookahead != '"') return false;
+    lexer->advance(lexer, false);
+
+    // Consume '(', delimiter
+    wstring delimiter;
+    for (;;) {
+      if (lexer->lookahead == 0 || lexer->lookahead == '\\' || iswspace(lexer->lookahead)) {
+        return false;
+      }
+      if (lexer->lookahead == '(') {
+        lexer->advance(lexer, false);
+        break;
+      }
+      delimiter += lexer->lookahead;
+      lexer->advance(lexer, false);
+    }
+
+    // Consume content, delimiter, ')', '"'
+    int delimiter_index = -1;
+    for (;;) {
+      if (lexer->lookahead == 0) return false;
+
+      if (delimiter_index >= 0) {
+        if (static_cast<unsigned>(delimiter_index) == delimiter.size()) {
+          if (lexer->lookahead == '"') {
+            lexer->advance(lexer, false);
+            return true;
+          } else {
+            delimiter_index = -1;
+          }
+        } else {
+          if (lexer->lookahead == delimiter[delimiter_index]) {
+            delimiter_index++;
+          } else {
+            delimiter_index = -1;
+          }
+        }
+      }
+
+      if (delimiter_index == -1 && lexer->lookahead == ')') {
+        delimiter_index = 0;
+      }
+
+      lexer->advance(lexer, false);
+    }
+  }
+};
+
+}
+
+extern "C" {
+
+void *tree_sitter_cpp_external_scanner_create() {
+  return new Scanner();
+}
+
+bool tree_sitter_cpp_external_scanner_scan(void *payload, TSLexer *lexer,
+                                            const bool *valid_symbols) {
+  Scanner *scanner = static_cast<Scanner *>(payload);
+  return scanner->scan(lexer, valid_symbols);
+}
+
+unsigned tree_sitter_cpp_external_scanner_serialize(void *payload, char *buffer) {
+  return 0;
+}
+
+void tree_sitter_cpp_external_scanner_deserialize(void *payload, const char *buffer, unsigned length) {
+}
+
+void tree_sitter_cpp_external_scanner_destroy(void *payload) {
+  Scanner *scanner = static_cast<Scanner *>(payload);
+  delete scanner;
+}
+
+}