Line data    Source code

       1              : !> Token definitions for the HSD lexer
       2              : !>
       3              : !> This module defines token types used during HSD parsing.
       4              : module hsd_token
       5              :   implicit none (type, external)
       6              :   private
       7              : 
       8              :   public :: hsd_token_t, token_kind
       9              :   public :: TOKEN_INVALID, TOKEN_EOF, TOKEN_WHITESPACE, TOKEN_NEWLINE
      10              :   public :: TOKEN_COMMENT, TOKEN_LBRACE, TOKEN_RBRACE, TOKEN_LBRACKET
      11              :   public :: TOKEN_RBRACKET, TOKEN_EQUAL, TOKEN_SEMICOLON, TOKEN_STRING
      12              :   public :: TOKEN_TEXT, TOKEN_INCLUDE_TXT, TOKEN_INCLUDE_HSD
      13              :   public :: token_name
      14              : 
      15              :   !> Token kind enumeration
      16              :   type :: enum_token_kind
      17              :     integer :: invalid = -1
      18              :     integer :: eof = 0
      19              :     integer :: whitespace = 1
      20              :     integer :: newline = 2
      21              :     integer :: comment = 3
      22              :     integer :: lbrace = 4      ! {
      23              :     integer :: rbrace = 5      ! }
      24              :     integer :: lbracket = 6    ! [
      25              :     integer :: rbracket = 7    ! ]
      26              :     integer :: equal = 8       ! =
      27              :     integer :: semicolon = 9   ! ;
      28              :     integer :: string = 10     ! quoted string
      29              :     integer :: text = 11       ! unquoted text/identifier
      30              :     integer :: include_txt = 12  ! <<<
      31              :     integer :: include_hsd = 13  ! <<+
      32              :   end type enum_token_kind
      33              : 
      34              :   !> Token kind constants
      35              :   type(enum_token_kind), parameter :: token_kind = enum_token_kind()
      36              : 
      37              :   !> Convenience aliases
      38              :   integer, parameter :: TOKEN_INVALID = -1
      39              :   integer, parameter :: TOKEN_EOF = 0
      40              :   integer, parameter :: TOKEN_WHITESPACE = 1
      41              :   integer, parameter :: TOKEN_NEWLINE = 2
      42              :   integer, parameter :: TOKEN_COMMENT = 3
      43              :   integer, parameter :: TOKEN_LBRACE = 4
      44              :   integer, parameter :: TOKEN_RBRACE = 5
      45              :   integer, parameter :: TOKEN_LBRACKET = 6
      46              :   integer, parameter :: TOKEN_RBRACKET = 7
      47              :   integer, parameter :: TOKEN_EQUAL = 8
      48              :   integer, parameter :: TOKEN_SEMICOLON = 9
      49              :   integer, parameter :: TOKEN_STRING = 10
      50              :   integer, parameter :: TOKEN_TEXT = 11
      51              :   integer, parameter :: TOKEN_INCLUDE_TXT = 12
      52              :   integer, parameter :: TOKEN_INCLUDE_HSD = 13
      53              : 
      54              :   !> Token type with position and value
      55              :   type :: hsd_token_t
      56              :     !> Kind of token
      57              :     integer :: kind = TOKEN_EOF
      58              :     !> Token value (for strings and text)
      59              :     character(len=:), allocatable :: value
      60              :     !> Line number where token starts
      61              :     integer :: line = 0
      62              :     !> Column number where token starts
      63              :     integer :: column = 0
      64              :   contains
      65              :     procedure :: is_eof => token_is_eof
      66              :     procedure :: is_valid => token_is_valid
      67              :   end type hsd_token_t
      68              : 
      69              : contains
      70              : 
      71              :   !> Check if token is eof
      72        56894 :   pure function token_is_eof(self) result(is_eof)
      73              :     class(hsd_token_t), intent(in) :: self
      74              :     logical :: is_eof
      75        56894 :     is_eof = self%kind == TOKEN_EOF
      76       113788 :   end function token_is_eof
      77              : 
      78              :   !> Check if token is valid (not invalid or eof)
      79            2 :   pure function token_is_valid(self) result(is_valid)
      80              :     class(hsd_token_t), intent(in) :: self
      81              :     logical :: is_valid
      82            2 :     is_valid = self%kind > TOKEN_EOF
      83        56894 :   end function token_is_valid
      84              : 
      85              :   !> Get human-readable name for a token kind
      86           16 :   pure function token_name(kind) result(name)
      87              :     integer, intent(in) :: kind
      88              :     character(len=:), allocatable :: name
      89              : 
      90           17 :     select case (kind)
      91              :     case (TOKEN_INVALID)
      92            1 :       name = "invalid"
      93              :     case (TOKEN_EOF)
      94            1 :       name = "end of file"
      95              :     case (TOKEN_WHITESPACE)
      96            1 :       name = "whitespace"
      97              :     case (TOKEN_NEWLINE)
      98            1 :       name = "newline"
      99              :     case (TOKEN_COMMENT)
     100            1 :       name = "comment"
     101              :     case (TOKEN_LBRACE)
     102            1 :       name = "opening brace"
     103              :     case (TOKEN_RBRACE)
     104            1 :       name = "closing brace"
     105              :     case (TOKEN_LBRACKET)
     106            1 :       name = "opening bracket"
     107              :     case (TOKEN_RBRACKET)
     108            1 :       name = "closing bracket"
     109              :     case (TOKEN_EQUAL)
     110            1 :       name = "equal sign"
     111              :     case (TOKEN_SEMICOLON)
     112            1 :       name = "semicolon"
     113              :     case (TOKEN_STRING)
     114            1 :       name = "string"
     115              :     case (TOKEN_TEXT)
     116            1 :       name = "text"
     117              :     case (TOKEN_INCLUDE_TXT)
     118            1 :       name = "text include"
     119              :     case (TOKEN_INCLUDE_HSD)
     120            1 :       name = "HSD include"
     121              :     case default
     122            1 :       name = "unknown"
     123              :     end select
     124              : 
     125            2 :   end function token_name
     126              : 
     127           16 : end module hsd_token