github.com/phpstudyer/protoreflect@v1.7.2/desc/protoparse/ast.go (about) 1 /** 2 * @Author: ZhaoYadong 3 * @Date: 2020-11-03 15:46:09 4 * @LastEditors: ZhaoYadong 5 * @LastEditTime: 2020-11-03 16:05:41 6 * @FilePath: /src/protoreflect/desc/protoparse/ast.go 7 */ 8 package protoparse 9 10 import "github.com/phpstudyer/protoreflect/desc/protoparse/ast" 11 12 // SourcePos is the same as ast.SourcePos. This alias exists for 13 // backwards compatibility (SourcePos used to be defined in this package.) 14 type SourcePos = ast.SourcePos 15 16 // the types below are accumulator types: linked lists that are 17 // constructed during parsing and then converted to slices of AST nodes 18 // once the whole list has been parsed 19 20 type compactOptionList struct { 21 option *ast.OptionNode 22 comma *ast.RuneNode 23 next *compactOptionList 24 } 25 26 func (list *compactOptionList) toNodes() ([]*ast.OptionNode, []*ast.RuneNode) { 27 l := 0 28 for cur := list; cur != nil; cur = cur.next { 29 l++ 30 } 31 opts := make([]*ast.OptionNode, l) 32 commas := make([]*ast.RuneNode, l-1) 33 for cur, i := list, 0; cur != nil; cur, i = cur.next, i+1 { 34 opts[i] = cur.option 35 if cur.comma != nil { 36 commas[i] = cur.comma 37 } 38 } 39 return opts, commas 40 } 41 42 type stringList struct { 43 str *ast.StringLiteralNode 44 next *stringList 45 } 46 47 func (list *stringList) toStringValueNode() ast.StringValueNode { 48 if list.next == nil { 49 // single name 50 return list.str 51 } 52 53 l := 0 54 for cur := list; cur != nil; cur = cur.next { 55 l++ 56 } 57 strs := make([]*ast.StringLiteralNode, l) 58 for cur, i := list, 0; cur != nil; cur, i = cur.next, i+1 { 59 strs[i] = cur.str 60 } 61 return ast.NewCompoundLiteralStringNode(strs...) 62 } 63 64 type nameList struct { 65 name ast.StringValueNode 66 comma *ast.RuneNode 67 next *nameList 68 } 69 70 func (list *nameList) toNodes() ([]ast.StringValueNode, []*ast.RuneNode) { 71 l := 0 72 for cur := list; cur != nil; cur = cur.next { 73 l++ 74 } 75 names := make([]ast.StringValueNode, l) 76 commas := make([]*ast.RuneNode, l-1) 77 for cur, i := list, 0; cur != nil; cur, i = cur.next, i+1 { 78 names[i] = cur.name 79 if cur.comma != nil { 80 commas[i] = cur.comma 81 } 82 } 83 return names, commas 84 } 85 86 type rangeList struct { 87 rng *ast.RangeNode 88 comma *ast.RuneNode 89 next *rangeList 90 } 91 92 func (list *rangeList) toNodes() ([]*ast.RangeNode, []*ast.RuneNode) { 93 l := 0 94 for cur := list; cur != nil; cur = cur.next { 95 l++ 96 } 97 ranges := make([]*ast.RangeNode, l) 98 commas := make([]*ast.RuneNode, l-1) 99 for cur, i := list, 0; cur != nil; cur, i = cur.next, i+1 { 100 ranges[i] = cur.rng 101 if cur.comma != nil { 102 commas[i] = cur.comma 103 } 104 } 105 return ranges, commas 106 } 107 108 type valueList struct { 109 val ast.ValueNode 110 comma *ast.RuneNode 111 next *valueList 112 } 113 114 func (list *valueList) toNodes() ([]ast.ValueNode, []*ast.RuneNode) { 115 if list == nil { 116 return nil, nil 117 } 118 l := 0 119 for cur := list; cur != nil; cur = cur.next { 120 l++ 121 } 122 vals := make([]ast.ValueNode, l) 123 commas := make([]*ast.RuneNode, l-1) 124 for cur, i := list, 0; cur != nil; cur, i = cur.next, i+1 { 125 vals[i] = cur.val 126 if cur.comma != nil { 127 commas[i] = cur.comma 128 } 129 } 130 return vals, commas 131 } 132 133 type fieldRefList struct { 134 ref *ast.FieldReferenceNode 135 dot *ast.RuneNode 136 next *fieldRefList 137 } 138 139 func (list *fieldRefList) toNodes() ([]*ast.FieldReferenceNode, []*ast.RuneNode) { 140 l := 0 141 for cur := list; cur != nil; cur = cur.next { 142 l++ 143 } 144 refs := make([]*ast.FieldReferenceNode, l) 145 dots := make([]*ast.RuneNode, l-1) 146 for cur, i := list, 0; cur != nil; cur, i = cur.next, i+1 { 147 refs[i] = cur.ref 148 if cur.dot != nil { 149 dots[i] = cur.dot 150 } 151 } 152 153 return refs, dots 154 } 155 156 type identList struct { 157 ident *ast.IdentNode 158 dot *ast.RuneNode 159 next *identList 160 } 161 162 func (list *identList) toIdentValueNode(leadingDot *ast.RuneNode) ast.IdentValueNode { 163 if list.next == nil && leadingDot == nil { 164 // single name 165 return list.ident 166 } 167 168 l := 0 169 for cur := list; cur != nil; cur = cur.next { 170 l++ 171 } 172 idents := make([]*ast.IdentNode, l) 173 dots := make([]*ast.RuneNode, l-1) 174 for cur, i := list, 0; cur != nil; cur, i = cur.next, i+1 { 175 idents[i] = cur.ident 176 if cur.dot != nil { 177 dots[i] = cur.dot 178 } 179 } 180 181 return ast.NewCompoundIdentNode(leadingDot, idents, dots) 182 } 183 184 type messageFieldEntry struct { 185 field *ast.MessageFieldNode 186 delimiter *ast.RuneNode 187 } 188 189 type messageFieldList struct { 190 field *messageFieldEntry 191 next *messageFieldList 192 } 193 194 func (list *messageFieldList) toNodes() ([]*ast.MessageFieldNode, []*ast.RuneNode) { 195 if list == nil { 196 return nil, nil 197 } 198 l := 0 199 for cur := list; cur != nil; cur = cur.next { 200 l++ 201 } 202 fields := make([]*ast.MessageFieldNode, l) 203 delimiters := make([]*ast.RuneNode, l) 204 for cur, i := list, 0; cur != nil; cur, i = cur.next, i+1 { 205 fields[i] = cur.field.field 206 if cur.field.delimiter != nil { 207 delimiters[i] = cur.field.delimiter 208 } 209 } 210 211 return fields, delimiters 212 }