token.go

Documentation: github.com/vektah/gqlparser/v2/lexer

     1  package lexer
     2  
     3  import (
     4  	"strconv"
     5  
     6  	"github.com/vektah/gqlparser/v2/ast"
     7  )
     8  
     9  const (
    10  	Invalid Type = iota
    11  	EOF
    12  	Bang
    13  	Dollar
    14  	Amp
    15  	ParenL
    16  	ParenR
    17  	Spread
    18  	Colon
    19  	Equals
    20  	At
    21  	BracketL
    22  	BracketR
    23  	BraceL
    24  	BraceR
    25  	Pipe
    26  	Name
    27  	Int
    28  	Float
    29  	String
    30  	BlockString
    31  	Comment
    32  )
    33  
    34  func (t Type) Name() string {
    35  	switch t {
    36  	case Invalid:
    37  		return "Invalid"
    38  	case EOF:
    39  		return "EOF"
    40  	case Bang:
    41  		return "Bang"
    42  	case Dollar:
    43  		return "Dollar"
    44  	case Amp:
    45  		return "Amp"
    46  	case ParenL:
    47  		return "ParenL"
    48  	case ParenR:
    49  		return "ParenR"
    50  	case Spread:
    51  		return "Spread"
    52  	case Colon:
    53  		return "Colon"
    54  	case Equals:
    55  		return "Equals"
    56  	case At:
    57  		return "At"
    58  	case BracketL:
    59  		return "BracketL"
    60  	case BracketR:
    61  		return "BracketR"
    62  	case BraceL:
    63  		return "BraceL"
    64  	case BraceR:
    65  		return "BraceR"
    66  	case Pipe:
    67  		return "Pipe"
    68  	case Name:
    69  		return "Name"
    70  	case Int:
    71  		return "Int"
    72  	case Float:
    73  		return "Float"
    74  	case String:
    75  		return "String"
    76  	case BlockString:
    77  		return "BlockString"
    78  	case Comment:
    79  		return "Comment"
    80  	}
    81  	return "Unknown " + strconv.Itoa(int(t))
    82  }
    83  
    84  func (t Type) String() string {
    85  	switch t {
    86  	case Invalid:
    87  		return "<Invalid>"
    88  	case EOF:
    89  		return "<EOF>"
    90  	case Bang:
    91  		return "!"
    92  	case Dollar:
    93  		return "$"
    94  	case Amp:
    95  		return "&"
    96  	case ParenL:
    97  		return "("
    98  	case ParenR:
    99  		return ")"
   100  	case Spread:
   101  		return "..."
   102  	case Colon:
   103  		return ":"
   104  	case Equals:
   105  		return "="
   106  	case At:
   107  		return "@"
   108  	case BracketL:
   109  		return "["
   110  	case BracketR:
   111  		return "]"
   112  	case BraceL:
   113  		return "{"
   114  	case BraceR:
   115  		return "}"
   116  	case Pipe:
   117  		return "|"
   118  	case Name:
   119  		return "Name"
   120  	case Int:
   121  		return "Int"
   122  	case Float:
   123  		return "Float"
   124  	case String:
   125  		return "String"
   126  	case BlockString:
   127  		return "BlockString"
   128  	case Comment:
   129  		return "Comment"
   130  	}
   131  	return "Unknown " + strconv.Itoa(int(t))
   132  }
   133  
   134  // Kind represents a type of token. The types are predefined as constants.
   135  type Type int
   136  
   137  type Token struct {
   138  	Kind  Type         // The token type.
   139  	Value string       // The literal value consumed.
   140  	Pos   ast.Position // The file and line this token was read from
   141  }
   142  
   143  func (t Token) String() string {
   144  	if t.Value != "" {
   145  		return t.Kind.String() + " " + strconv.Quote(t.Value)
   146  	}
   147  	return t.Kind.String()
   148  }
   149
View as plain text