| ... | ... | @@ -129,18 +129,18 @@ const Tokenizer = struct { |
| 129 | 129 | code_node_count: usize, |
| 130 | 130 | |
| 131 | 131 | const State = enum { |
| 132 | | Start, |
| 133 | | LBracket, |
| 134 | | Hash, |
| 135 | | TagName, |
| 136 | | Eof, |
| 132 | start, |
| 133 | l_bracket, |
| 134 | hash, |
| 135 | tag_name, |
| 136 | eof, |
| 137 | 137 | }; |
| 138 | 138 | |
| 139 | 139 | fn init(source_file_name: []const u8, buffer: []const u8) Tokenizer { |
| 140 | 140 | return Tokenizer{ |
| 141 | 141 | .buffer = buffer, |
| 142 | 142 | .index = 0, |
| 143 | | .state = State.Start, |
| 143 | .state = .start, |
| 144 | 144 | .source_file_name = source_file_name, |
| 145 | 145 | .code_node_count = 0, |
| 146 | 146 | }; |
| ... | ... | @@ -155,33 +155,33 @@ const Tokenizer = struct { |
| 155 | 155 | while (self.index < self.buffer.len) : (self.index += 1) { |
| 156 | 156 | const c = self.buffer[self.index]; |
| 157 | 157 | switch (self.state) { |
| 158 | | State.Start => switch (c) { |
| 158 | .start => switch (c) { |
| 159 | 159 | '{' => { |
| 160 | | self.state = State.LBracket; |
| 160 | self.state = .l_bracket; |
| 161 | 161 | }, |
| 162 | 162 | else => { |
| 163 | 163 | result.id = .content; |
| 164 | 164 | }, |
| 165 | 165 | }, |
| 166 | | State.LBracket => switch (c) { |
| 166 | .l_bracket => switch (c) { |
| 167 | 167 | '#' => { |
| 168 | 168 | if (result.id != .eof) { |
| 169 | 169 | self.index -= 1; |
| 170 | | self.state = State.Start; |
| 170 | self.state = .start; |
| 171 | 171 | break; |
| 172 | 172 | } else { |
| 173 | 173 | result.id = .bracket_open; |
| 174 | 174 | self.index += 1; |
| 175 | | self.state = State.TagName; |
| 175 | self.state = .tag_name; |
| 176 | 176 | break; |
| 177 | 177 | } |
| 178 | 178 | }, |
| 179 | 179 | else => { |
| 180 | 180 | result.id = .content; |
| 181 | | self.state = State.Start; |
| 181 | self.state = .start; |
| 182 | 182 | }, |
| 183 | 183 | }, |
| 184 | | State.TagName => switch (c) { |
| 184 | .tag_name => switch (c) { |
| 185 | 185 | '|' => { |
| 186 | 186 | if (result.id != .eof) { |
| 187 | 187 | break; |
| ... | ... | @@ -192,40 +192,40 @@ const Tokenizer = struct { |
| 192 | 192 | } |
| 193 | 193 | }, |
| 194 | 194 | '#' => { |
| 195 | | self.state = State.Hash; |
| 195 | self.state = .hash; |
| 196 | 196 | }, |
| 197 | 197 | else => { |
| 198 | 198 | result.id = .tag_content; |
| 199 | 199 | }, |
| 200 | 200 | }, |
| 201 | | State.Hash => switch (c) { |
| 201 | .hash => switch (c) { |
| 202 | 202 | '}' => { |
| 203 | 203 | if (result.id != .eof) { |
| 204 | 204 | self.index -= 1; |
| 205 | | self.state = State.TagName; |
| 205 | self.state = .tag_name; |
| 206 | 206 | break; |
| 207 | 207 | } else { |
| 208 | 208 | result.id = .bracket_close; |
| 209 | 209 | self.index += 1; |
| 210 | | self.state = State.Start; |
| 210 | self.state = .start; |
| 211 | 211 | break; |
| 212 | 212 | } |
| 213 | 213 | }, |
| 214 | 214 | else => { |
| 215 | 215 | result.id = .tag_content; |
| 216 | | self.state = State.TagName; |
| 216 | self.state = .tag_name; |
| 217 | 217 | }, |
| 218 | 218 | }, |
| 219 | | State.Eof => unreachable, |
| 219 | .eof => unreachable, |
| 220 | 220 | } |
| 221 | 221 | } else { |
| 222 | 222 | switch (self.state) { |
| 223 | | State.Start, State.LBracket, State.Eof => {}, |
| 223 | .start, .l_bracket, .eof => {}, |
| 224 | 224 | else => { |
| 225 | 225 | result.id = .invalid; |
| 226 | 226 | }, |
| 227 | 227 | } |
| 228 | | self.state = State.Eof; |
| 228 | self.state = .eof; |
| 229 | 229 | } |
| 230 | 230 | result.end = self.index; |
| 231 | 231 | return result; |
Linus Groh <mail@linusgroh.de> 2023-05-20 21:53:12+01:00
doc