`42f9bdb`

Implement multiline syntax highlighting and wire up symbols panels

Multiline comments (/* */) and strings (""", `, etc.) were not
highlighted across multiple lines. This made reading C, JavaScript,
Python, and other languages difficult.

Also replaced stub panel renderers with real implementations so
document symbols and workspace symbols are now fully functional.

Authored by

espadonne 5 months ago

SHA: 42f9bdb61ce8251cd911e6b3b9920068c33f2598
Parents: 3d6f981
Tree: 295ac40

3 changed files

Status	File	+	-
M	`src/commands/command_handler_module.f90`	16	16
M	`src/syntax/syntax_highlighter_module.f90`	135	5
M	`src/terminal/renderer_module.f90`	10	69

src/commands/command_handler_module.f90modified

      ! The response parsing logic is ready but needs proper callback integration
      ! Wrapper callback that matches the LSP callback signature
 -    subroutine handle_references_response_wrapper(request_id, response)
 +    subroutine handle_references_response_wrapper(unused_request_id, response)
          use lsp_protocol_module, only: lsp_message_t
 -        integer, intent(in) :: request_id
 +        integer, intent(in) :: unused_request_id
          type(lsp_message_t), intent(in) :: response
          ! Call the actual handler with saved editor state
      end subroutine handle_references_response_impl
      ! Wrapper callback that matches the LSP callback signature for code actions
 -    subroutine handle_code_actions_response_wrapper(request_id, response)
 +    subroutine handle_code_actions_response_wrapper(unused_request_id, response)
          use lsp_protocol_module, only: lsp_message_t
 -        integer, intent(in) :: request_id
 +        integer, intent(in) :: unused_request_id
          type(lsp_message_t), intent(in) :: response
          ! Call the actual handler with saved editor state
      end subroutine handle_code_actions_response_impl
      ! Wrapper callback that matches the LSP callback signature for symbols
 -    subroutine handle_symbols_response_wrapper(request_id, response)
 +    subroutine handle_symbols_response_wrapper(unused_request_id, response)
          use lsp_protocol_module, only: lsp_message_t
 -        integer, intent(in) :: request_id
 +        integer, intent(in) :: unused_request_id
          type(lsp_message_t), intent(in) :: response
          ! Call the actual handler with saved editor state
      end subroutine handle_symbols_response_impl
      ! Wrapper callback that matches the LSP callback signature for signature help
 -    subroutine handle_signature_response_wrapper(request_id, response)
 +    subroutine handle_signature_response_wrapper(unused_request_id, response)
          use lsp_protocol_module, only: lsp_message_t
 -        integer, intent(in) :: request_id
 +        integer, intent(in) :: unused_request_id
          type(lsp_message_t), intent(in) :: response
          ! Call the actual handler with saved editor state
      end subroutine handle_signature_response_wrapper
      ! Wrapper callback that matches the LSP callback signature for rename
 -    subroutine handle_rename_response_wrapper(request_id, response)
 +    subroutine handle_rename_response_wrapper(unused_request_id, response)
          use lsp_protocol_module, only: lsp_message_t
          use json_module, only: json_value_t, json_stringify
 -        integer, intent(in) :: request_id
 +        integer, intent(in) :: unused_request_id
          type(lsp_message_t), intent(in) :: response
          character(len=:), allocatable :: result_str
      end subroutine handle_rename_response_wrapper
      ! Wrapper callback for formatting response
 -    subroutine handle_formatting_response_wrapper(request_id, response)
 +    subroutine handle_formatting_response_wrapper(unused_request_id, response)
          use lsp_protocol_module, only: lsp_message_t
          use json_module, only: json_value_t, json_array_size, json_get_array_element, &
                                 json_get_object, json_get_string, json_get_number, json_has_key
 -        integer, intent(in) :: request_id
 +        integer, intent(in) :: unused_request_id
          type(lsp_message_t), intent(in) :: response
          type(json_value_t) :: edits_array, edit_obj, range_obj, start_obj, end_obj
      end subroutine execute_palette_command
      ! Handle workspace symbols LSP response
 -    subroutine handle_workspace_symbols_response_wrapper(request_id, response)
 +    subroutine handle_workspace_symbols_response_wrapper(unused_request_id, response)
          use lsp_protocol_module, only: lsp_message_t
          use json_module
          use workspace_symbols_panel_module, only: workspace_symbol_t, set_workspace_symbols
 -        integer, intent(in) :: request_id
 +        integer, intent(in) :: unused_request_id
          type(lsp_message_t), intent(in) :: response
          type(json_value_t) :: symbol_obj, location_obj, range_obj, start_obj
          integer :: num_symbols, i
      ! ==================================================
      ! Wrapper callback for go to definition
 -    subroutine handle_definition_response_wrapper(request_id, response)
 +    subroutine handle_definition_response_wrapper(unused_request_id, response)
          use lsp_protocol_module, only: lsp_message_t
 -        integer, intent(in) :: request_id
 +        integer, intent(in) :: unused_request_id
          type(lsp_message_t), intent(in) :: response
          ! Call actual handler with saved editor state

src/syntax/syntax_highlighter_module.f90modified

          do while (i <= line_len)
              ch = line(i:i)
 +            ! Check for multiline comment start
 +            if (check_multiline_comment_start(highlighter, line, i)) then
 +                call process_multiline_comment_start(highlighter, line, tokens, token_count, i)
++
              ! Check for single-line comment
 -            if (check_comment_start(highlighter, line, i)) then
 +            else if (check_comment_start(highlighter, line, i)) then
                  token_count = token_count + 1
                  tokens(token_count)%type = TOKEN_COMMENT
                  tokens(token_count)%start_col = i
          end if
      end function check_comment_start
 +    function check_multiline_comment_start(highlighter, line, pos) result(res)
 +        type(syntax_highlighter_t), intent(in) :: highlighter
 +        character(len=*), intent(in) :: line
 +        integer, intent(in) :: pos
 +        logical :: res
 +        integer :: comment_len
++
 +        res = .false.
 +        if (highlighter%current_lang%comment_start /= "") then
 +            comment_len = len_trim(highlighter%current_lang%comment_start)
 +            if (pos + comment_len - 1 <= len(line)) then
 +                res = line(pos:pos+comment_len-1) == trim(highlighter%current_lang%comment_start)
 +            end if
 +        end if
 +    end function check_multiline_comment_start
++
      function check_string_start(highlighter, line, pos) result(res)
          type(syntax_highlighter_t), intent(in) :: highlighter
          character(len=*), intent(in) :: line
          integer, intent(inout) :: token_count, pos
          integer :: i, start_pos, delim_len, line_len
          character(len=:), allocatable :: delimiter
 -        logical :: found_end
 +        logical :: found_end, is_multiline
          line_len = len(line)
          start_pos = pos
              end if
          end do
 +        ! Check if this is a multiline-capable delimiter
 +        ! Python: """ or ''' (length 3)
 +        ! JavaScript/TypeScript: ` (template literals)
 +        is_multiline = (len(delimiter) >= 3) .or. (delimiter == '`')
++
          ! Move past opening delimiter
          pos = pos + len(delimiter)
          ! Handle unclosed string
          if (.not. found_end) then
 +            if (is_multiline) then
 +                ! Enter multiline string mode
 +                highlighter%in_multiline_string = .true.
 +                highlighter%string_delimiter = delimiter
 +            end if
              pos = line_len + 1
          end if
      end subroutine process_string
          highlighter%enabled = .true.
      end subroutine load_markdown_syntax
 -    ! Stub implementations for multiline handling
 +    ! Handle multiline comment start (when we encounter /* on a line)
 +    subroutine process_multiline_comment_start(highlighter, line, tokens, token_count, pos)
 +        type(syntax_highlighter_t), intent(inout) :: highlighter
 +        character(len=*), intent(in) :: line
 +        type(token_t), intent(inout) :: tokens(:)
 +        integer, intent(inout) :: token_count, pos
 +        integer :: start_pos, end_pos, comment_start_len, comment_end_len, line_len
++
 +        line_len = len(line)
 +        start_pos = pos
 +        comment_start_len = len_trim(highlighter%current_lang%comment_start)
 +        comment_end_len = len_trim(highlighter%current_lang%comment_end)
++
 +        ! Skip past the opening delimiter
 +        pos = pos + comment_start_len
++
 +        ! Look for closing delimiter on the same line
 +        end_pos = index(line(pos:), trim(highlighter%current_lang%comment_end))
++
 +        if (end_pos > 0) then
 +            ! Found closing delimiter on same line - this is a complete comment
 +            end_pos = pos + end_pos - 1 + comment_end_len - 1
++
 +            token_count = token_count + 1
 +            tokens(token_count)%type = TOKEN_COMMENT
 +            tokens(token_count)%start_col = start_pos
 +            tokens(token_count)%end_col = end_pos
++
 +            pos = end_pos + 1
 +        else
 +            ! Closing delimiter not found - rest of line is comment, enter multiline mode
 +            token_count = token_count + 1
 +            tokens(token_count)%type = TOKEN_COMMENT
 +            tokens(token_count)%start_col = start_pos
 +            tokens(token_count)%end_col = line_len
++
 +            highlighter%in_multiline_comment = .true.
 +            pos = line_len + 1
 +        end if
 +    end subroutine process_multiline_comment_start
++
 +    ! Handle multiline comment continuation (when we start a line in comment mode)
      subroutine process_multiline_comment(highlighter, line, tokens, token_count, pos)
          type(syntax_highlighter_t), intent(inout) :: highlighter
          character(len=*), intent(in) :: line
          type(token_t), intent(inout) :: tokens(:)
          integer, intent(inout) :: token_count, pos
 -        ! TODO: Implement multiline comment handling
 +        integer :: end_pos, comment_end_len, line_len
++
 +        line_len = len(line)
 +        comment_end_len = len_trim(highlighter%current_lang%comment_end)
++
 +        ! Look for closing delimiter
 +        end_pos = index(line(pos:), trim(highlighter%current_lang%comment_end))
++
 +        if (end_pos > 0) then
 +            ! Found closing delimiter on this line
 +            end_pos = pos + end_pos - 1 + comment_end_len - 1
++
 +            token_count = token_count + 1
 +            tokens(token_count)%type = TOKEN_COMMENT
 +            tokens(token_count)%start_col = pos
 +            tokens(token_count)%end_col = end_pos
++
 +            ! Exit multiline comment mode
 +            highlighter%in_multiline_comment = .false.
 +            pos = end_pos + 1
 +        else
 +            ! Closing delimiter not found - entire rest of line is comment
 +            token_count = token_count + 1
 +            tokens(token_count)%type = TOKEN_COMMENT
 +            tokens(token_count)%start_col = pos
 +            tokens(token_count)%end_col = line_len
++
 +            ! Stay in multiline comment mode
 +            pos = line_len + 1
 +        end if
      end subroutine process_multiline_comment
      subroutine process_multiline_string(highlighter, line, tokens, token_count, pos)
          character(len=*), intent(in) :: line
          type(token_t), intent(inout) :: tokens(:)
          integer, intent(inout) :: token_count, pos
 -        ! TODO: Implement multiline string handling
 +        integer :: end_pos, delim_len, line_len
++
 +        line_len = len(line)
 +        delim_len = len(highlighter%string_delimiter)
++
 +        ! Look for closing delimiter
 +        end_pos = index(line(pos:), highlighter%string_delimiter)
++
 +        if (end_pos > 0) then
 +            ! Found closing delimiter on this line
 +            end_pos = pos + end_pos - 1 + delim_len - 1
++
 +            token_count = token_count + 1
 +            tokens(token_count)%type = TOKEN_STRING
 +            tokens(token_count)%start_col = pos
 +            tokens(token_count)%end_col = end_pos
++
 +            ! Exit multiline string mode
 +            highlighter%in_multiline_string = .false.
 +            highlighter%string_delimiter = ""
 +            pos = end_pos + 1
 +        else
 +            ! Closing delimiter not found - entire rest of line is string
 +            token_count = token_count + 1
 +            tokens(token_count)%type = TOKEN_STRING
 +            tokens(token_count)%start_col = pos
 +            tokens(token_count)%end_col = line_len
++
 +            ! Stay in multiline string mode
 +            pos = line_len + 1
 +        end if
      end subroutine process_multiline_string
  end module syntax_highlighter_module

src/terminal/renderer_module.f90modified

          if (n_panes == 0) return
          if (n_panes > 1) then
 -            call render_cursor_for_panes_in_lsp_view(editor, start_col, width)
 +            call render_cursor_for_panes_in_lsp_view(editor)
          else
              call render_cursor_in_pane(editor, start_col, width)
          end if
      end subroutine render_cursor_for_lsp_panel
      ! Helper to render cursor for multiple panes when LSP panel is visible
 -    subroutine render_cursor_for_panes_in_lsp_view(editor, start_col, width)
 +    subroutine render_cursor_for_panes_in_lsp_view(editor)
          use editor_state_module, only: pane_t
          type(editor_state_t), intent(inout) :: editor
 -        integer, intent(in) :: start_col, width
          integer :: tab_idx, active_pane
          type(pane_t) :: pane
          integer :: screen_row, screen_col
      ! Render symbols panel in offcanvas mode (right side, full height)
      subroutine render_lsp_symbols_panel(panel, start_col, width, start_row, end_row)
 -        use symbols_panel_module, only: symbols_panel_t
 +        use symbols_panel_module, only: symbols_panel_t, render_symbols_panel
          type(symbols_panel_t), intent(in) :: panel
          integer, intent(in) :: start_col, width, start_row, end_row
 -        integer :: row
 -        character(len=1), parameter :: ESC = achar(27)
+-
 -        ! Clear panel area
 -        do row = start_row, end_row
 -            call terminal_move_cursor(row, start_col)
 -            call terminal_write(repeat(' ', width))
 -        end do
+-
 -        row = start_row
 -        ! Header
 -        call terminal_move_cursor(row, start_col)
 -        call terminal_write(ESC // '[48;5;237m' // ESC // '[1m Document Symbols ')
 -        if (19 < width) then
 -            call terminal_write(repeat(' ', width - 19))
 -        end if
 -        call terminal_write(ESC // '[0m')
 -        row = row + 1
+-
 -        ! Separator
 -        call terminal_move_cursor(row, start_col)
 -        call terminal_write(ESC // '[48;5;237m' // repeat("─", width) // ESC // '[0m')
 -        row = row + 1
+-
 -        ! Legend
 -        call terminal_move_cursor(row, start_col)
 -        call terminal_write(ESC // '[90mj/k:nav  enter:jump  esc:close' // ESC // '[0m')
 -        row = row + 1
+-
 -        ! TODO: Actually render symbols (will delegate to symbols_panel_module logic)
 -        call terminal_move_cursor(row, start_col)
 -        call terminal_write(ESC // '[90m(symbols panel implementation pending)' // ESC // '[0m')
 +        ! Delegate to the real symbols panel renderer
 +        ! The panel manages its own positioning via panel_start_col and panel_width
 +        call render_symbols_panel(panel, end_row)
      end subroutine render_lsp_symbols_panel
      ! Render workspace symbols panel in offcanvas mode (right side, full height)
      subroutine render_lsp_workspace_symbols_panel(panel, start_col, width, start_row, end_row)
 -        use workspace_symbols_panel_module, only: workspace_symbols_panel_t
 +        use workspace_symbols_panel_module, only: workspace_symbols_panel_t, render_workspace_symbols_panel
          type(workspace_symbols_panel_t), intent(in) :: panel
          integer, intent(in) :: start_col, width, start_row, end_row
 -        integer :: row
 -        character(len=1), parameter :: ESC = achar(27)
+-
 -        ! Clear panel area
 -        do row = start_row, end_row
 -            call terminal_move_cursor(row, start_col)
 -            call terminal_write(repeat(' ', width))
 -        end do
+-
 -        row = start_row
+-
 -        ! Header
 -        call terminal_move_cursor(row, start_col)
 -        call terminal_write(ESC // '[48;5;237m' // ESC // '[1m Workspace Symbols ')
 -        if (21 < width) then
 -            call terminal_write(repeat(' ', width - 21))
 -        end if
 -        call terminal_write(ESC // '[0m')
 -        row = row + 1
+-
 -        ! Separator
 -        call terminal_move_cursor(row, start_col)
 -        call terminal_write(ESC // '[48;5;237m' // repeat("─", width) // ESC // '[0m')
 -        row = row + 1
 -        ! Legend
 -        call terminal_move_cursor(row, start_col)
 -        call terminal_write(ESC // '[90mj/k:nav  enter:jump  esc:close' // ESC // '[0m')
 -        row = row + 1
+-
 -        ! TODO: Actually render workspace symbols (will delegate to workspace_symbols_panel_module logic)
 -        call terminal_move_cursor(row, start_col)
 -        call terminal_write(ESC // '[90m(workspace symbols panel implementation pending)' // ESC // '[0m')
 +        ! Delegate to the real workspace symbols panel renderer
 +        ! The panel manages its own positioning via panel_start_col and panel_width
 +        call render_workspace_symbols_panel(panel, end_row)
      end subroutine render_lsp_workspace_symbols_panel
      ! Helper function to extract basename from path