types.go

Documentation: github.com/alecthomas/chroma

     1  package chroma
     2  
     3  import (
     4  	"encoding/json"
     5  	"fmt"
     6  )
     7  
     8  //go:generate stringer -type TokenType
     9  
    10  // TokenType is the type of token to highlight.
    11  //
    12  // It is also an Emitter, emitting a single token of itself
    13  type TokenType int
    14  
    15  func (t TokenType) MarshalJSON() ([]byte, error) { return json.Marshal(t.String()) }
    16  func (t *TokenType) UnmarshalJSON(data []byte) error {
    17  	key := ""
    18  	err := json.Unmarshal(data, &key)
    19  	if err != nil {
    20  		return err
    21  	}
    22  	for tt, text := range _TokenType_map {
    23  		if text == key {
    24  			*t = tt
    25  			return nil
    26  		}
    27  	}
    28  	return fmt.Errorf("unknown TokenType %q", data)
    29  }
    30  
    31  // Set of TokenTypes.
    32  //
    33  // Categories of types are grouped in ranges of 1000, while sub-categories are in ranges of 100. For
    34  // example, the literal category is in the range 3000-3999. The sub-category for literal strings is
    35  // in the range 3100-3199.
    36  
    37  // Meta token types.
    38  const (
    39  	// Default background style.
    40  	Background TokenType = -1 - iota
    41  	// PreWrapper style.
    42  	PreWrapper
    43  	// Line style.
    44  	Line
    45  	// Line numbers in output.
    46  	LineNumbers
    47  	// Line numbers in output when in table.
    48  	LineNumbersTable
    49  	// Line higlight style.
    50  	LineHighlight
    51  	// Line numbers table wrapper style.
    52  	LineTable
    53  	// Line numbers table TD wrapper style.
    54  	LineTableTD
    55  	// Code line wrapper style.
    56  	CodeLine
    57  	// Input that could not be tokenised.
    58  	Error
    59  	// Other is used by the Delegate lexer to indicate which tokens should be handled by the delegate.
    60  	Other
    61  	// No highlighting.
    62  	None
    63  	// Used as an EOF marker / nil token
    64  	EOFType TokenType = 0
    65  )
    66  
    67  // Keywords.
    68  const (
    69  	Keyword TokenType = 1000 + iota
    70  	KeywordConstant
    71  	KeywordDeclaration
    72  	KeywordNamespace
    73  	KeywordPseudo
    74  	KeywordReserved
    75  	KeywordType
    76  )
    77  
    78  // Names.
    79  const (
    80  	Name TokenType = 2000 + iota
    81  	NameAttribute
    82  	NameBuiltin
    83  	NameBuiltinPseudo
    84  	NameClass
    85  	NameConstant
    86  	NameDecorator
    87  	NameEntity
    88  	NameException
    89  	NameFunction
    90  	NameFunctionMagic
    91  	NameKeyword
    92  	NameLabel
    93  	NameNamespace
    94  	NameOperator
    95  	NameOther
    96  	NamePseudo
    97  	NameProperty
    98  	NameTag
    99  	NameVariable
   100  	NameVariableAnonymous
   101  	NameVariableClass
   102  	NameVariableGlobal
   103  	NameVariableInstance
   104  	NameVariableMagic
   105  )
   106  
   107  // Literals.
   108  const (
   109  	Literal TokenType = 3000 + iota
   110  	LiteralDate
   111  	LiteralOther
   112  )
   113  
   114  // Strings.
   115  const (
   116  	LiteralString TokenType = 3100 + iota
   117  	LiteralStringAffix
   118  	LiteralStringAtom
   119  	LiteralStringBacktick
   120  	LiteralStringBoolean
   121  	LiteralStringChar
   122  	LiteralStringDelimiter
   123  	LiteralStringDoc
   124  	LiteralStringDouble
   125  	LiteralStringEscape
   126  	LiteralStringHeredoc
   127  	LiteralStringInterpol
   128  	LiteralStringName
   129  	LiteralStringOther
   130  	LiteralStringRegex
   131  	LiteralStringSingle
   132  	LiteralStringSymbol
   133  )
   134  
   135  // Literals.
   136  const (
   137  	LiteralNumber TokenType = 3200 + iota
   138  	LiteralNumberBin
   139  	LiteralNumberFloat
   140  	LiteralNumberHex
   141  	LiteralNumberInteger
   142  	LiteralNumberIntegerLong
   143  	LiteralNumberOct
   144  )
   145  
   146  // Operators.
   147  const (
   148  	Operator TokenType = 4000 + iota
   149  	OperatorWord
   150  )
   151  
   152  // Punctuation.
   153  const (
   154  	Punctuation TokenType = 5000 + iota
   155  )
   156  
   157  // Comments.
   158  const (
   159  	Comment TokenType = 6000 + iota
   160  	CommentHashbang
   161  	CommentMultiline
   162  	CommentSingle
   163  	CommentSpecial
   164  )
   165  
   166  // Preprocessor "comments".
   167  const (
   168  	CommentPreproc TokenType = 6100 + iota
   169  	CommentPreprocFile
   170  )
   171  
   172  // Generic tokens.
   173  const (
   174  	Generic TokenType = 7000 + iota
   175  	GenericDeleted
   176  	GenericEmph
   177  	GenericError
   178  	GenericHeading
   179  	GenericInserted
   180  	GenericOutput
   181  	GenericPrompt
   182  	GenericStrong
   183  	GenericSubheading
   184  	GenericTraceback
   185  	GenericUnderline
   186  )
   187  
   188  // Text.
   189  const (
   190  	Text TokenType = 8000 + iota
   191  	TextWhitespace
   192  	TextSymbol
   193  	TextPunctuation
   194  )
   195  
   196  // Aliases.
   197  const (
   198  	Whitespace = TextWhitespace
   199  
   200  	Date = LiteralDate
   201  
   202  	String          = LiteralString
   203  	StringAffix     = LiteralStringAffix
   204  	StringBacktick  = LiteralStringBacktick
   205  	StringChar      = LiteralStringChar
   206  	StringDelimiter = LiteralStringDelimiter
   207  	StringDoc       = LiteralStringDoc
   208  	StringDouble    = LiteralStringDouble
   209  	StringEscape    = LiteralStringEscape
   210  	StringHeredoc   = LiteralStringHeredoc
   211  	StringInterpol  = LiteralStringInterpol
   212  	StringOther     = LiteralStringOther
   213  	StringRegex     = LiteralStringRegex
   214  	StringSingle    = LiteralStringSingle
   215  	StringSymbol    = LiteralStringSymbol
   216  
   217  	Number            = LiteralNumber
   218  	NumberBin         = LiteralNumberBin
   219  	NumberFloat       = LiteralNumberFloat
   220  	NumberHex         = LiteralNumberHex
   221  	NumberInteger     = LiteralNumberInteger
   222  	NumberIntegerLong = LiteralNumberIntegerLong
   223  	NumberOct         = LiteralNumberOct
   224  )
   225  
   226  var (
   227  	StandardTypes = map[TokenType]string{
   228  		Background:       "bg",
   229  		PreWrapper:       "chroma",
   230  		Line:             "line",
   231  		LineNumbers:      "ln",
   232  		LineNumbersTable: "lnt",
   233  		LineHighlight:    "hl",
   234  		LineTable:        "lntable",
   235  		LineTableTD:      "lntd",
   236  		CodeLine:         "cl",
   237  		Text:             "",
   238  		Whitespace:       "w",
   239  		Error:            "err",
   240  		Other:            "x",
   241  		// I have no idea what this is used for...
   242  		// Escape:     "esc",
   243  
   244  		Keyword:            "k",
   245  		KeywordConstant:    "kc",
   246  		KeywordDeclaration: "kd",
   247  		KeywordNamespace:   "kn",
   248  		KeywordPseudo:      "kp",
   249  		KeywordReserved:    "kr",
   250  		KeywordType:        "kt",
   251  
   252  		Name:                 "n",
   253  		NameAttribute:        "na",
   254  		NameBuiltin:          "nb",
   255  		NameBuiltinPseudo:    "bp",
   256  		NameClass:            "nc",
   257  		NameConstant:         "no",
   258  		NameDecorator:        "nd",
   259  		NameEntity:           "ni",
   260  		NameException:        "ne",
   261  		NameFunction:         "nf",
   262  		NameFunctionMagic:    "fm",
   263  		NameProperty:         "py",
   264  		NameLabel:            "nl",
   265  		NameNamespace:        "nn",
   266  		NameOther:            "nx",
   267  		NameTag:              "nt",
   268  		NameVariable:         "nv",
   269  		NameVariableClass:    "vc",
   270  		NameVariableGlobal:   "vg",
   271  		NameVariableInstance: "vi",
   272  		NameVariableMagic:    "vm",
   273  
   274  		Literal:     "l",
   275  		LiteralDate: "ld",
   276  
   277  		String:          "s",
   278  		StringAffix:     "sa",
   279  		StringBacktick:  "sb",
   280  		StringChar:      "sc",
   281  		StringDelimiter: "dl",
   282  		StringDoc:       "sd",
   283  		StringDouble:    "s2",
   284  		StringEscape:    "se",
   285  		StringHeredoc:   "sh",
   286  		StringInterpol:  "si",
   287  		StringOther:     "sx",
   288  		StringRegex:     "sr",
   289  		StringSingle:    "s1",
   290  		StringSymbol:    "ss",
   291  
   292  		Number:            "m",
   293  		NumberBin:         "mb",
   294  		NumberFloat:       "mf",
   295  		NumberHex:         "mh",
   296  		NumberInteger:     "mi",
   297  		NumberIntegerLong: "il",
   298  		NumberOct:         "mo",
   299  
   300  		Operator:     "o",
   301  		OperatorWord: "ow",
   302  
   303  		Punctuation: "p",
   304  
   305  		Comment:            "c",
   306  		CommentHashbang:    "ch",
   307  		CommentMultiline:   "cm",
   308  		CommentPreproc:     "cp",
   309  		CommentPreprocFile: "cpf",
   310  		CommentSingle:      "c1",
   311  		CommentSpecial:     "cs",
   312  
   313  		Generic:           "g",
   314  		GenericDeleted:    "gd",
   315  		GenericEmph:       "ge",
   316  		GenericError:      "gr",
   317  		GenericHeading:    "gh",
   318  		GenericInserted:   "gi",
   319  		GenericOutput:     "go",
   320  		GenericPrompt:     "gp",
   321  		GenericStrong:     "gs",
   322  		GenericSubheading: "gu",
   323  		GenericTraceback:  "gt",
   324  		GenericUnderline:  "gl",
   325  	}
   326  )
   327  
   328  func (t TokenType) Parent() TokenType {
   329  	if t%100 != 0 {
   330  		return t / 100 * 100
   331  	}
   332  	if t%1000 != 0 {
   333  		return t / 1000 * 1000
   334  	}
   335  	return 0
   336  }
   337  
   338  func (t TokenType) Category() TokenType {
   339  	return t / 1000 * 1000
   340  }
   341  
   342  func (t TokenType) SubCategory() TokenType {
   343  	return t / 100 * 100
   344  }
   345  
   346  func (t TokenType) InCategory(other TokenType) bool {
   347  	return t/1000 == other/1000
   348  }
   349  
   350  func (t TokenType) InSubCategory(other TokenType) bool {
   351  	return t/100 == other/100
   352  }
   353  
   354  func (t TokenType) Emit(groups []string, _ *LexerState) Iterator {
   355  	return Literator(Token{Type: t, Value: groups[0]})
   356  }
   357
View as plain text