tree-sitter-cuda 0.0.3

cuda grammar for the tree-sitter parsing library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

#include <cwctype>
#include <string>
#include <tree_sitter/parser.h>

namespace {

using std::iswspace;
using std::wstring;

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);
    }
  }
};

} // namespace

extern "C" {

void *tree_sitter_cuda_external_scanner_create() { return new Scanner(); }

bool tree_sitter_cuda_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_cuda_external_scanner_serialize(void *payload,
                                                     char *buffer) {
  return 0;
}

void tree_sitter_cuda_external_scanner_deserialize(void *payload,
                                                   const char *buffer,
                                                   unsigned length) {}

void tree_sitter_cuda_external_scanner_destroy(void *payload) {
  Scanner *scanner = static_cast<Scanner *>(payload);
  delete scanner;
}
}