Create a new version of paste:

makepkg -s
==> Making package: tree-sitter-haskell-git 0.13.0.r80.g237f4eb-1 (Sat 07 Jan 2023 19:19:14 CST)
==> Checking runtime dependencies...
==> Checking buildtime dependencies...
==> Retrieving sources...
  -> Cloning tree-sitter-haskell-git git repo...
Cloning into bare repository '/home/bhrgunatha/scratch/tree-sitter-haskell-git/tree-sitter-haskell-git'...
remote: Enumerating objects: 8017, done.
remote: Counting objects: 100% (149/149), done.
remote: Compressing objects: 100% (112/112), done.
remote: Total 8017 (delta 76), reused 86 (delta 35), pack-reused 7868
Receiving objects: 100% (8017/8017), 257.68 MiB | 6.35 MiB/s, done.
Resolving deltas: 100% (5209/5209), done.
==> Validating source files with sha256sums...
    tree-sitter-haskell-git ... Skipped
==> Extracting sources...
  -> Creating working copy of tree-sitter-haskell-git git repo...
Cloning into 'tree-sitter-haskell-git'...
done.
==> Starting prepare()...
==> Starting pkgver()...
==> Updated version: tree-sitter-haskell-git 0.13.0.r143.gaee3725-1
==> Starting build()...
scanner.c:211:51: error: expected ‘,’ or ‘...’ before ‘vs’
  211 | State state_new(TSLexer *l, const bool * restrict vs, indent_vec *is) {
      |                                                   ^~
scanner.c: In function ‘State state_new(TSLexer*, const bool*)’:
scanner.c:214:16: error: ‘vs’ was not declared in this scope
  214 |     .symbols = vs,
      |                ^~
scanner.c:215:16: error: ‘is’ was not declared in this scope
  215 |     .indents = is,
      |                ^~
scanner.c: At global scope:
scanner.c:301:39: error: expected ‘,’ or ‘...’ before ‘s’
  301 | static bool seq(const char * restrict s, State *state) {
      |                                       ^
scanner.c: In function ‘bool seq(const char*)’:
scanner.c:302:23: error: ‘s’ was not declared in this scope
  302 |   size_t len = strlen(s);
      |                       ^
scanner.c:23:14: error: ‘state’ was not declared in this scope; did you mean ‘State’?
   23 | #define PEEK state->lexer->lookahead
      |              ^~~~~
scanner.c:305:18: note: in expansion of macro ‘PEEK’
  305 |     int32_t c2 = PEEK;
      |                  ^~~~
scanner.c: In function ‘void consume_until(char*, State*)’:
scanner.c:315:27: error: too many arguments to function ‘bool seq(const char*)’
  315 |   while (PEEK != 0 && !seq(target, state)) {
      |                        ~~~^~~~~~~~~~~~~~~
scanner.c:301:13: note: declared here
  301 | static bool seq(const char * restrict s, State *state) {
      |             ^~~
scanner.c: In function ‘wchar_vec read_string(bool (*)(uint32_t), State*)’:
scanner.c:39:24: error: invalid conversion from ‘void*’ to ‘int32_t*’ {aka ‘int*’} [-fpermissive]
   39 |   (vec)->data = realloc((vec)->data, (_cap) * sizeof((vec)->data[0])); \
      |                 ~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
      |                        |
      |                        void*
scanner.c:46:35: note: in expansion of macro ‘VEC_RESIZE’
   46 |   if ((vec)->cap == (vec)->len) { VEC_RESIZE((vec), MAX(20, (vec)->len * 2)); } \
      |                                   ^~~~~~~~~~
scanner.c:342:5: note: in expansion of macro ‘VEC_PUSH’
  342 |     VEC_PUSH(&res, c);
      |     ^~~~~~~~
scanner.c: At global scope:
scanner.c:388:40: error: expected ‘,’ or ‘...’ before ‘s’
  388 | static bool token(const char *restrict s, State *state) {
      |                                        ^
scanner.c: In function ‘bool token(const char*)’:
scanner.c:389:14: error: ‘s’ was not declared in this scope
  389 |   return seq(s, state) && token_end(PEEK);
      |              ^
scanner.c:389:17: error: ‘state’ was not declared in this scope; did you mean ‘State’?
  389 |   return seq(s, state) && token_end(PEEK);
      |                 ^~~~~
      |                 State
scanner.c: At global scope:
scanner.c:644:50: error: expected ‘,’ or ‘...’ before ‘desc’
  644 | static Result finish(const Sym s, char *restrict desc) {
      |                                                  ^~~~
scanner.c:652:59: error: expected ‘,’ or ‘...’ before ‘desc’
  652 | static Result finish_if_valid(const Sym s, char *restrict desc, State *state) {
      |                                                           ^~~~
scanner.c: In function ‘Result finish_if_valid(Sym, char*)’:
scanner.c:28:17: error: ‘state’ was not declared in this scope; did you mean ‘State’?
   28 | #define SYM(s) (state->symbols[s])
      |                 ^~~~~
scanner.c:653:10: note: in expansion of macro ‘SYM’
  653 |   return SYM(s) ? finish(s, desc) : res_cont;
      |          ^~~
scanner.c:653:29: error: ‘desc’ was not declared in this scope
  653 |   return SYM(s) ? finish(s, desc) : res_cont;
      |                             ^~~~
scanner.c: In function ‘void push(uint16_t, State*)’:
scanner.c:39:24: error: invalid conversion from ‘void*’ to ‘uint16_t*’ {aka ‘short unsigned int*’} [-fpermissive]
   39 |   (vec)->data = realloc((vec)->data, (_cap) * sizeof((vec)->data[0])); \
      |                 ~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
      |                        |
      |                        void*
scanner.c:46:35: note: in expansion of macro ‘VEC_RESIZE’
   46 |   if ((vec)->cap == (vec)->len) { VEC_RESIZE((vec), MAX(20, (vec)->len * 2)); } \
      |                                   ^~~~~~~~~~
scanner.c:661:3: note: in expansion of macro ‘VEC_PUSH’
  661 |   VEC_PUSH(state->indents, ind);
      |   ^~~~~~~~
scanner.c: In function ‘Result end_or_semicolon(char*, State*)’:
scanner.c:707:25: error: too many arguments to function ‘Result finish_if_valid(Sym, char*)’
  707 |   return finish_if_valid(SEMICOLON, desc, state);
      |          ~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~
scanner.c:652:15: note: declared here
  652 | static Result finish_if_valid(const Sym s, char *restrict desc, State *state) {
      |               ^~~~~~~~~~~~~~~
scanner.c: In function ‘Result eof(State*)’:
scanner.c:759:28: warning: ISO C++ forbids converting a string constant to ‘char*’ [-Wwrite-strings]
  759 |       return finish(EMPTY, "eof");
      |                            ^~~~~
scanner.c:761:35: warning: ISO C++ forbids converting a string constant to ‘char*’ [-Wwrite-strings]
  761 |     Result res = end_or_semicolon("eof", state);
      |                                   ^~~~~
scanner.c: In function ‘Result initialize(uint32_t, State*)’:
scanner.c:777:23: error: too many arguments to function ‘bool token(const char*)’
  777 |     bool match = token("module", state);
      |                  ~~~~~^~~~~~~~~~~~~~~~~
scanner.c:388:13: note: declared here
  388 | static bool token(const char *restrict s, State *state) {
      |             ^~~~~
scanner.c:780:27: warning: ISO C++ forbids converting a string constant to ‘char*’ [-Wwrite-strings]
  780 |     return finish(INDENT, "init");
      |                           ^~~~~~
scanner.c: In function ‘Result dot(State*)’:
scanner.c:807:64: warning: ISO C++ forbids converting a string constant to ‘char*’ [-Wwrite-strings]
  807 |       if (SYM(VARSYM) && iswspace(PEEK)) return finish(VARSYM, "dot");
      |                                                                ^~~~~
scanner.c:809:26: warning: ISO C++ forbids converting a string constant to ‘char*’ [-Wwrite-strings]
  809 |       return finish(DOT, "dot");
      |                          ^~~~~
scanner.c: In function ‘Result cpp_workaround(State*)’:
scanner.c:843:12: error: too many arguments to function ‘bool seq(const char*)’
  843 |     if (seq("el", state)) {
      |         ~~~^~~~~~~~~~~~~
scanner.c:301:13: note: declared here
  301 | static bool seq(const char * restrict s, State *state) {
      |             ^~~
scanner.c:844:21: warning: ISO C++ forbids converting a string constant to ‘char*’ [-Wwrite-strings]
  844 |       consume_until("#endif", state);
      |                     ^~~~~~~~
scanner.c:850:26: warning: ISO C++ forbids converting a string constant to ‘char*’ [-Wwrite-strings]
  850 |       return finish(CPP, "cpp-else");
      |                          ^~~~~~~~~~
scanner.c:854:24: warning: ISO C++ forbids converting a string constant to ‘char*’ [-Wwrite-strings]
  854 |     return finish(CPP, "cpp");
      |                        ^~~~~
scanner.c: In function ‘Result dedent(uint32_t, State*)’:
scanner.c:874:56: warning: ISO C++ forbids converting a string constant to ‘char*’ [-Wwrite-strings]
  874 |   if (smaller_indent(indent, state)) return layout_end("dedent", state);
      |                                                        ^~~~~~~~
scanner.c: In function ‘Result newline_where(uint32_t, State*)’:
scanner.c:886:14: error: too many arguments to function ‘bool token(const char*)’
  886 |     if (token("where", state)) {
      |         ~~~~~^~~~~~~~~~~~~~~~
scanner.c:388:13: note: declared here
  388 | static bool token(const char *restrict s, State *state) {
      |             ^~~~~
scanner.c:887:31: warning: ISO C++ forbids converting a string constant to ‘char*’ [-Wwrite-strings]
  887 |       return end_or_semicolon("newline_where", state);
      |                               ^~~~~~~~~~~~~~~
scanner.c: In function ‘Result newline_semicolon(uint32_t, State*)’:
scanner.c:899:30: warning: ISO C++ forbids converting a string constant to ‘char*’ [-Wwrite-strings]
  899 |     return finish(SEMICOLON, "newline_semicolon");
      |                              ^~~~~~~~~~~~~~~~~~~
scanner.c: In function ‘Result newline_infix(uint32_t, Symbolic, State*)’:
scanner.c:924:23: warning: ISO C++ forbids converting a string constant to ‘char*’ [-Wwrite-strings]
  924 |     return layout_end("newline_infix", state);
      |                       ^~~~~~~~~~~~~~~
scanner.c: In function ‘Result where(State*)’:
scanner.c:935:12: error: too many arguments to function ‘bool token(const char*)’
  935 |   if (token("where", state)) {
      |       ~~~~~^~~~~~~~~~~~~~~~
scanner.c:388:13: note: declared here
  388 | static bool token(const char *restrict s, State *state) {
      |             ^~~~~
scanner.c:938:28: warning: ISO C++ forbids converting a string constant to ‘char*’ [-Wwrite-strings]
  938 |       return finish(WHERE, "where");
      |                            ^~~~~~~
scanner.c:940:23: warning: ISO C++ forbids converting a string constant to ‘char*’ [-Wwrite-strings]
  940 |     return layout_end("where", state);
      |                       ^~~~~~~
scanner.c: In function ‘Result in(State*)’:
scanner.c:949:23: error: too many arguments to function ‘bool token(const char*)’
  949 |   if (SYM(IN) && token("in", state)) {
      |                  ~~~~~^~~~~~~~~~~~~
scanner.c:388:13: note: declared here
  388 | static bool token(const char *restrict s, State *state) {
      |             ^~~~~
scanner.c:952:23: warning: ISO C++ forbids converting a string constant to ‘char*’ [-Wwrite-strings]
  952 |     return finish(IN, "in");
      |                       ^~~~
scanner.c: In function ‘Result else_(State*)’:
scanner.c:961:15: error: too many arguments to function ‘bool token(const char*)’
  961 |   return token("else", state) ? end_or_semicolon("else", state) : res_cont;
      |          ~~~~~^~~~~~~~~~~~~~~
scanner.c:388:13: note: declared here
  388 | static bool token(const char *restrict s, State *state) {
      |             ^~~~~
scanner.c:961:50: warning: ISO C++ forbids converting a string constant to ‘char*’ [-Wwrite-strings]
  961 |   return token("else", state) ? end_or_semicolon("else", state) : res_cont;
      |                                                  ^~~~~~
scanner.c: In function ‘Result qq_start(State*)’:
scanner.c:971:44: warning: ISO C++ forbids converting a string constant to ‘char*’ [-Wwrite-strings]
  971 |   if (PEEK == '|') return finish(QQ_START, "qq_start");
      |                                            ^~~~~~~~~~
scanner.c: In function ‘Result qq_body(State*)’:
scanner.c:991:34: warning: ISO C++ forbids converting a string constant to ‘char*’ [-Wwrite-strings]
  991 |           return finish(QQ_BODY, "qq_body");
      |                                  ^~~~~~~~~
scanner.c: In function ‘Result splice(State*)’:
scanner.c:1006:27: warning: ISO C++ forbids converting a string constant to ‘char*’ [-Wwrite-strings]
 1006 |     return finish(SPLICE, "splice");
      |                           ^~~~~~~~
scanner.c: In function ‘Result unboxed_close(State*)’:
scanner.c:1016:42: warning: ISO C++ forbids converting a string constant to ‘char*’ [-Wwrite-strings]
 1016 |       return finish(UNBOXED_TUPLE_CLOSE, "unboxed_close");
      |                                          ^~~~~~~~~~~~~~~
scanner.c: In function ‘Result inline_comment(State*)’:
scanner.c:1040:26: warning: ISO C++ forbids converting a string constant to ‘char*’ [-Wwrite-strings]
 1040 |   return finish(COMMENT, "inline_comment");
      |                          ^~~~~~~~~~~~~~~~
scanner.c: In function ‘Result symop_marked(Symbolic, State*)’:
scanner.c:1064:46: warning: ISO C++ forbids converting a string constant to ‘char*’ [-Wwrite-strings]
 1064 |       Result res = finish_if_valid(TYCONSYM, "symop", state);
      |                                              ^~~~~~~
scanner.c:1064:35: error: too many arguments to function ‘Result finish_if_valid(Sym, char*)’
 1064 |       Result res = finish_if_valid(TYCONSYM, "symop", state);
      |                    ~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~
scanner.c:652:15: note: declared here
  652 | static Result finish_if_valid(const Sym s, char *restrict desc, State *state) {
      |               ^~~~~~~~~~~~~~~
scanner.c:1073:38: warning: ISO C++ forbids converting a string constant to ‘char*’ [-Wwrite-strings]
 1073 |       return finish_if_valid(STRICT, "strict", state);
      |                                      ^~~~~~~~
scanner.c:1073:29: error: too many arguments to function ‘Result finish_if_valid(Sym, char*)’
 1073 |       return finish_if_valid(STRICT, "strict", state);
      |              ~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~
scanner.c:652:15: note: declared here
  652 | static Result finish_if_valid(const Sym s, char *restrict desc, State *state) {
      |               ^~~~~~~~~~~~~~~
scanner.c:1077:44: warning: ISO C++ forbids converting a string constant to ‘char*’ [-Wwrite-strings]
 1077 |       Result res = finish_if_valid(CONSYM, "symop", state);
      |                                            ^~~~~~~
scanner.c:1077:35: error: too many arguments to function ‘Result finish_if_valid(Sym, char*)’
 1077 |       Result res = finish_if_valid(CONSYM, "symop", state);
      |                    ~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~
scanner.c:652:15: note: declared here
  652 | static Result finish_if_valid(const Sym s, char *restrict desc, State *state) {
      |               ^~~~~~~~~~~~~~~
scanner.c: In function ‘Result symop(Symbolic, State*)’:
scanner.c:1107:26: warning: ISO C++ forbids converting a string constant to ‘char*’ [-Wwrite-strings]
 1107 |       return finish(BAR, "bar");
      |                          ^~~~~
scanner.c:1109:29: warning: ISO C++ forbids converting a string constant to ‘char*’ [-Wwrite-strings]
 1109 |     Result res = layout_end("bar", state);
      |                             ^~~~~
scanner.c:1116:35: warning: ISO C++ forbids converting a string constant to ‘char*’ [-Wwrite-strings]
 1116 |   res = finish_if_valid(TYCONSYM, "symop", state);
      |                                   ^~~~~~~
scanner.c:1116:24: error: too many arguments to function ‘Result finish_if_valid(Sym, char*)’
 1116 |   res = finish_if_valid(TYCONSYM, "symop", state);
      |         ~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~
scanner.c:652:15: note: declared here
  652 | static Result finish_if_valid(const Sym s, char *restrict desc, State *state) {
      |               ^~~~~~~~~~~~~~~
scanner.c:1118:33: warning: ISO C++ forbids converting a string constant to ‘char*’ [-Wwrite-strings]
 1118 |   res = finish_if_valid(VARSYM, "symop", state);
      |                                 ^~~~~~~
scanner.c:1118:24: error: too many arguments to function ‘Result finish_if_valid(Sym, char*)’
 1118 |   res = finish_if_valid(VARSYM, "symop", state);
      |         ~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~
scanner.c:652:15: note: declared here
  652 | static Result finish_if_valid(const Sym s, char *restrict desc, State *state) {
      |               ^~~~~~~~~~~~~~~
scanner.c: In function ‘Result minus(State*)’:
scanner.c:1133:11: error: too many arguments to function ‘bool seq(const char*)’
 1133 |   if (!seq("--", state)) return res_cont;
      |        ~~~^~~~~~~~~~~~~
scanner.c:301:13: note: declared here
  301 | static bool seq(const char * restrict s, State *state) {
      |             ^~~
scanner.c: In function ‘Result multiline_comment_success(State*)’:
scanner.c:1144:26: warning: ISO C++ forbids converting a string constant to ‘char*’ [-Wwrite-strings]
 1144 |   return finish(COMMENT, "multiline_comment");
      |                          ^~~~~~~~~~~~~~~~~~~
scanner.c: In function ‘Result close_layout_in_list(State*)’:
scanner.c:1232:28: warning: ISO C++ forbids converting a string constant to ‘char*’ [-Wwrite-strings]
 1232 |         return finish(END, "bracket");
      |                            ^~~~~~~~~
scanner.c:1240:30: warning: ISO C++ forbids converting a string constant to ‘char*’ [-Wwrite-strings]
 1240 |         return finish(COMMA, "comma");
      |                              ^~~~~~~
scanner.c:1242:31: warning: ISO C++ forbids converting a string constant to ‘char*’ [-Wwrite-strings]
 1242 |       Result res = layout_end("comma", state);
      |                               ^~~~~~~
scanner.c: In function ‘Result inline_tokens(State*)’:
scanner.c:1279:31: warning: ISO C++ forbids converting a string constant to ‘char*’ [-Wwrite-strings]
 1279 |       Result res = layout_end(")", state);
      |                               ^~~
scanner.c: In function ‘Result layout_start(uint32_t, State*)’:
scanner.c:1344:26: warning: ISO C++ forbids converting a string constant to ‘char*’ [-Wwrite-strings]
 1344 |     return finish(START, "layout_start");
      |                          ^~~~~~~~~~~~~~
scanner.c: In function ‘Result post_end_semicolon(uint32_t, State*)’:
scanner.c:1366:25: warning: ISO C++ forbids converting a string constant to ‘char*’ [-Wwrite-strings]
 1366 |     ? finish(SEMICOLON, "post_end_semicolon")
      |                         ^~~~~~~~~~~~~~~~~~~~
scanner.c: In function ‘Result repeat_end(uint32_t, State*)’:
scanner.c:1375:23: warning: ISO C++ forbids converting a string constant to ‘char*’ [-Wwrite-strings]
 1375 |     return layout_end("repeat_end", state);
      |                       ^~~~~~~~~~~~
scanner.c: In function ‘void tree_sitter_haskell_external_scanner_deserialize(void*, char*, unsigned int)’:
scanner.c:39:24: error: invalid conversion from ‘void*’ to ‘uint16_t*’ {aka ‘short unsigned int*’} [-fpermissive]
   39 |   (vec)->data = realloc((vec)->data, (_cap) * sizeof((vec)->data[0])); \
      |                 ~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
      |                        |
      |                        void*
scanner.c:43:56: note: in expansion of macro ‘VEC_RESIZE’
   43 | #define VEC_GROW(vec, _cap) if ((vec)->cap < (_cap)) { VEC_RESIZE((vec), (_cap)); }
      |                                                        ^~~~~~~~~~
scanner.c:1610:5: note: in expansion of macro ‘VEC_GROW’
 1610 |     VEC_GROW(indents, els);
      |     ^~~~~~~~
==> ERROR: A failure occurred in build().
    Aborting...