codeimage.io

STUDIO HAZE · image

Topaz source

Open by house policy. Topaz is our own language.

Topaz 5.21 · 113 files

topaz/src/structure.tpz

Topaz · 24062 B · Original file

1// Canonical structure records, their JSON readers and scalar accessors, and
2// structure validation with canonical wire encoding and decoding.
4import std.bytes { Bytes }
5import std.json
6import hash { 해시배열 }
7import nodes { 노드종류 }
8import util { 바이트로, 바이트배열로, 바이트추가, 배열같음, 부분배열 }
9import wire {
10 가변정수쓰기,
11 가변정수읽기,
12 널문자있음,
13 사전색인,
14 사전쓰기,
15 사전읽기,
16 사전해석,
17 삼십이쓰기,
18 삼십이읽기,
19 안전문자열코드단위키,
20 정렬고유,
21 정수읽기,
22 짝없는대리자있음,
23 코드단위문자열,
24 코드단위문자열만들기,
25 코드단위사전쓰기,
26 코드단위사전읽기,
27 코드단위사전해석,
28 코드단위키읽기,
31export record 구조스칼라 {
32 필드: string,
33 태그: int,
34 정수값: int,
35 문자열값: string
38export record 구조노드 {
39 코드워드: int,
40 부모순번: int,
41 자식필드있음: bool,
42 자식필드: string,
43 자식색인: int,
44 시작: int,
45 끝: int,
46 스칼라들: Array<구조스칼라>,
47 식별자있음: bool,
48 식별자류번호: int
51export record 구조입력 {
52 분리본문키해시: string,
53 분리본문값수: int,
54 노드들: Array<구조노드>
57export record 이미지요청 {
58 언어번호: int,
59 팔레트번호: int,
60 프로필해시: string,
61 구조해시: string,
62 키해시: string,
63 크롬번호: int,
64 제목: string,
65 원본줄수: int,
66 구조: 구조입력
69// JSON readers. A record is read from JSON in the module that declares it, so
70// the image request, which embeds a structure, is declared here as well.
71export function 구조입력읽기(글: string) -> Result<구조입력, string> {
72 json.parseAs<구조입력>(글)
75export function 이미지요청읽기(글: string) -> Result<이미지요청, string> {
76 json.parseAs<이미지요청>(글)
79export function 구조언어번호(구조: 구조입력) -> int {
80 if 구조.노드들.length == 0 { return 0 }
81 let 뿌리코드 = 구조.노드들[0].코드워드
82 if 노드종류(1, 뿌리코드) == 101 { return 1 }
83 if 노드종류(2, 뿌리코드) == 101 { return 2 }
84 if 노드종류(3, 뿌리코드) == 101 { return 3 }
85 if 노드종류(4, 뿌리코드) == 101 { return 4 }
86 if 노드종류(5, 뿌리코드) == 101 { return 5 }
87 if 노드종류(6, 뿌리코드) == 101 { return 6 }
88 if 노드종류(7, 뿌리코드) == 101 { return 7 }
89 if 노드종류(8, 뿌리코드) == 101 { return 8 }
90 if 노드종류(9, 뿌리코드) == 101 { return 9 }
91 if 노드종류(10, 뿌리코드) == 101 { return 10 }
92 if 노드종류(11, 뿌리코드) == 101 { return 11 }
93 if 노드종류(12, 뿌리코드) == 101 { return 12 }
94 if 노드종류(13, 뿌리코드) == 101 { return 13 }
95 if 노드종류(14, 뿌리코드) == 101 { return 14 }
96 if 노드종류(15, 뿌리코드) == 101 { return 15 }
97 if 노드종류(16, 뿌리코드) == 101 { return 16 }
98 if 노드종류(17, 뿌리코드) == 101 { return 17 }
99 if 노드종류(18, 뿌리코드) == 101 { return 18 }
100 if 노드종류(19, 뿌리코드) == 101 { return 19 }
101 if 노드종류(21, 뿌리코드) == 101 { return 21 }
102 if 노드종류(20, 뿌리코드) == 101 { return 20 }
103 if 노드종류(22, 뿌리코드) == 101 { return 22 }
104 if 노드종류(23, 뿌리코드) == 101 { return 23 }
105 if 노드종류(24, 뿌리코드) == 101 { return 24 }
106 if 노드종류(25, 뿌리코드) == 101 { return 25 }
107 if 노드종류(26, 뿌리코드) == 101 { return 26 }
108 if 노드종류(27, 뿌리코드) == 101 { return 27 }
109 if 노드종류(28, 뿌리코드) == 101 { return 28 }
110 if 노드종류(29, 뿌리코드) == 101 { return 29 }
111 if 노드종류(30, 뿌리코드) == 101 { return 30 }
112 0
115function 코드단위태그허용(언어번호: int, 노드: 구조노드, 스칼라: 구조스칼라) -> bool {
116 if 언어번호 != 1 && 언어번호 != 2 { return false }
117 let 종류 = 노드종류(언어번호, 노드.코드워드)
118 (종류 == 108 && 스칼라.필드 == "value") ||
119 (종류 == 116 && 스칼라.필드 == "value.cooked")
122function 구조스칼라검사(언어번호: int, 노드: 구조노드, 스칼라: 구조스칼라) -> Result<bool, string> {
123 if 스칼라.필드 == "" || 널문자있음(스칼라.필드) {
124 return Err("구조 스칼라 필드가 비었거나 영 문자를 포함합니다")
125 }
126 if 스칼라.필드 == "trailingFileLayout" {
127 if 언어번호 != 12 || 노드.부모순번 != -1 || 노드.코드워드 != 36 ||
128 스칼라.태그 != 5 || 스칼라.문자열값 == "" || 스칼라.문자열값.scalars().length > 4194304 {
129 return Err("Swift 파일 끝 배치가 정규형이 아닙니다")
130 }
131 for 글자 in 스칼라.문자열값.scalars() {
132 let 코드 = 글자.codePointAt(0) ?? 0
133 if 코드 != 32 && !(코드 >= 9 && 코드 <= 13) {
134 return Err("Swift 파일 끝 배치에 비배치 문자가 있습니다")
135 }
136 }
137 }
138 if 스칼라.태그 >= 0 && 스칼라.태그 <= 2 {
139 if 스칼라.정수값 != 0 || 스칼라.문자열값 != "" {
140 return Err("논리 구조 스칼라의 빈 본문이 정규형이 아닙니다")
141 }
142 return Ok(true)
143 }
144 if 스칼라.태그 == 3 {
145 if 스칼라.정수값 < 0 || 스칼라.정수값 > 9007199254740991 || 스칼라.문자열값 != "" {
146 return Err("양의 구조 스칼라가 안전 정수 정규형이 아닙니다")
147 }
148 return Ok(true)
149 }
150 if 스칼라.태그 == 4 {
151 if 스칼라.정수값 < 1 || 스칼라.정수값 > 9007199254740991 || 스칼라.문자열값 != "" {
152 return Err("음의 구조 스칼라가 안전 정수 정규형이 아닙니다")
153 }
154 return Ok(true)
155 }
156 if 스칼라.태그 == 5 {
157 if 스칼라.정수값 != 0 { return Err("문자열 구조 스칼라 정수 본문이 0이 아닙니다") }
158 return Ok(true)
159 }
160 if 스칼라.태그 == 6 {
161 if 스칼라.정수값 != 0 { return Err("UTF-16 호스트 스칼라 정수 본문이 0이 아닙니다") }
162 let 단위들 = 코드단위키읽기(스칼라.문자열값, false)?
163 if !짝없는대리자있음(단위들) {
164 return Err("UTF-16 호스트 스칼라에 짝없는 대리자가 없습니다")
165 }
166 if !코드단위태그허용(언어번호, 노드, 스칼라) {
167 return Err("UTF-16 호스트 스칼라가 허용되지 않은 구조 위치에 있습니다")
168 }
169 return Ok(true)
170 }
171 Err("지원하지 않는 구조 스칼라 태그입니다")
174export function 구조입력검사(언어번호: int, 구조: 구조입력) -> Result<bool, string> {
175 for 노드 in 구조.노드들 {
176 let mut 첫필드 = true
177 let mut 이전필드 = ""
178 for 스칼라 in 노드.스칼라들 {
179 if !첫필드 && 이전필드 >= 스칼라.필드 { return Err("구조 스칼라 필드가 정규 순서가 아닙니다") }
180 구조스칼라검사(언어번호, 노드, 스칼라)?
181 이전필드 = 스칼라.필드
182 첫필드 = false
183 }
184 }
185 Ok(true)
188function 구조스칼라코드단위문자열(스칼라: 구조스칼라) -> Result<코드단위문자열, string> {
189 if 스칼라.태그 == 5 {
190 let 키 = 안전문자열코드단위키(스칼라.문자열값)
191 return Ok(코드단위문자열 { 키: 키, 안전값: 스칼라.문자열값, 안전: true })
192 }
193 if 스칼라.태그 == 6 { return 코드단위문자열만들기(스칼라.문자열값) }
194 Err("문자열이 아닌 구조 스칼라입니다")
197export record 압축원본행 {
198 행: int,
199 시작: int
202function 원본기하필드인가(필드: string) -> bool {
203 필드 == "startRow" || 필드 == "startColumn" ||
204 필드 == "endRow" || 필드 == "endColumn"
207function 압축원본행들(구조: 구조입력) -> Result<Array<압축원본행>, string> {
208 let mut 행들: Array<압축원본행> = []
209 for 노드 in 구조.노드들 {
210 let mut 모서리 = 0
211 while 모서리 < 2 {
212 let 행필드 = if 모서리 == 0 { "startRow" } else { "endRow" }
213 let 열필드 = if 모서리 == 0 { "startColumn" } else { "endColumn" }
214 let 오프셋 = if 모서리 == 0 { 노드.시작 } else { 노드.끝 }
215 let 행스칼라 = 노드스칼라(노드, 행필드)
216 let 열스칼라 = 노드스칼라(노드, 열필드)
217 if 행스칼라.태그 != 3 || 열스칼라.태그 != 3 ||
218 행스칼라.정수값 < 0 || 열스칼라.정수값 < 0 || 열스칼라.정수값 > 오프셋 {
219 return Err("JS/TS 원본 행 기하가 틀립니다")
220 }
221 let 행 = 행스칼라.정수값
222 let 행시작 = 오프셋 - 열스칼라.정수값
223 let mut 찾음 = false
224 for 기존 in 행들 {
225 if 기존.행 == 행 {
226 if 기존.시작 != 행시작 { return Err("한 원본 행의 시작 오프셋이 서로 다릅니다") }
227 찾음 = true
228 }
229 }
230 if !찾음 { 행들.push(압축원본행 { 행: 행, 시작: 행시작 }) }
231 모서리 = 모서리 + 1
232 }
233 }
234 let mut 왼쪽 = 0
235 while 왼쪽 < 행들.length {
236 let mut 오른쪽 = 왼쪽 + 1
237 while 오른쪽 < 행들.length {
238 if 행들[오른쪽].행 < 행들[왼쪽].행 {
239 let 임시 = 행들[왼쪽]
240 행들[왼쪽] = 행들[오른쪽]
241 행들[오른쪽] = 임시
242 }
243 오른쪽 = 오른쪽 + 1
244 }
245 왼쪽 = 왼쪽 + 1
246 }
247 let mut 색인 = 1
248 while 색인 < 행들.length {
249 if 행들[색인].시작 <= 행들[색인 - 1].시작 {
250 return Err("원본 행 시작 오프셋이 엄격히 증가하지 않습니다")
251 }
252 색인 = 색인 + 1
253 }
254 Ok(행들)
257function 압축원본문자위치(
258 행들: Array<압축원본행>,
259 오프셋: int
260) -> Result<Array<int>, string> {
261 let mut 아래 = -1
262 let mut 위 = 행들.length
263 while 아래 + 1 < 위 {
264 let 가운데 = (아래 + 위) / 2
265 if 행들[가운데].시작 <= 오프셋 { 아래 = 가운데 } else { 위 = 가운데 }
266 }
267 if 아래 < 0 { return Err("노드 오프셋이 첫 원본 행보다 앞섭니다") }
268 Ok([행들[아래].행, 오프셋 - 행들[아래].시작])
271function 구조스칼라필드정렬(값들: Array<구조스칼라>) -> Array<구조스칼라> {
272 let mut 결과 = 값들
273 let mut 왼쪽 = 0
274 while 왼쪽 < 결과.length {
275 let mut 오른쪽 = 왼쪽 + 1
276 while 오른쪽 < 결과.length {
277 if 결과[오른쪽].필드 < 결과[왼쪽].필드 {
278 let 임시 = 결과[왼쪽]
279 결과[왼쪽] = 결과[오른쪽]
280 결과[오른쪽] = 임시
281 }
282 오른쪽 = 오른쪽 + 1
283 }
284 왼쪽 = 왼쪽 + 1
285 }
286 결과
289function 구조인코드배열(구조: 구조입력) -> Result<Array<int>, string> {
290 let 언어번호 = 구조언어번호(구조)
291 let 압축기하 = 언어번호 == 1 || 언어번호 == 2
292 구조입력검사(언어번호, 구조)?
293 if 구조.분리본문키해시.scalars().length != 64 { return Err("분리 본문 키 해시 길이가 틀립니다") }
294 let mut 자식모음: Array<string> = []
295 let mut 스칼라필드모음: Array<string> = []
296 let mut 스칼라문자키들: Array<string> = []
297 for 노드 in 구조.노드들 {
298 if 노드.자식필드있음 { 자식모음.push(노드.자식필드) }
299 for 스칼라 in 노드.스칼라들 {
300 if !압축기하 || !원본기하필드인가(스칼라.필드) {
301 스칼라필드모음.push(스칼라.필드)
302 if 스칼라.태그 == 5 || 스칼라.태그 == 6 {
303 let 코드단위문자열 = 구조스칼라코드단위문자열(스칼라)?
304 스칼라문자키들.push(코드단위문자열.키)
305 }
306 }
307 }
308 }
309 let mut 원본행들: Array<압축원본행> = []
310 if 압축기하 { 원본행들 = 압축원본행들(구조)? }
311 let 자식사전 = 정렬고유(자식모음)
312 let 스칼라필드사전 = 정렬고유(스칼라필드모음)
313 let 스칼라문자사전 = 정렬고유(스칼라문자키들)
314 let mut 내용 = 바이트배열로(Bytes.fromHex(구조.분리본문키해시)?)
315 내용 = 가변정수쓰기(내용, 구조.노드들.length)
316 내용 = 가변정수쓰기(내용, 구조.분리본문값수)
317 if 압축기하 {
318 내용 = 가변정수쓰기(내용, 원본행들.length)
319 let mut 이전행 = -1
320 let mut 이전시작 = 0
321 for 행 in 원본행들 {
322 내용 = 가변정수쓰기(내용, 행.행 - 이전행)
323 내용 = 가변정수쓰기(내용, 행.시작 - 이전시작)
324 이전행 = 행.행
325 이전시작 = 행.시작
326 }
327 }
328 내용 = 사전쓰기(내용, 자식사전)?
329 내용 = 사전쓰기(내용, 스칼라필드사전)?
330 내용 = 코드단위사전쓰기(내용, 스칼라문자사전)?
331 let mut 순번 = 0
332 let mut 스칼라문자순번 = 0
333 for 노드 in 구조.노드들 {
334 내용 = 가변정수쓰기(내용, 노드.코드워드)
335 내용 = 가변정수쓰기(내용, if 노드.부모순번 < 0 { 0 } else { 순번 - 노드.부모순번 })
336 내용 = 가변정수쓰기(내용, if 노드.자식필드있음 { 사전색인(자식사전, 노드.자식필드) + 1 } else { 0 })
337 내용 = 가변정수쓰기(내용, if 노드.자식색인 < 0 { 0 } else { 노드.자식색인 + 1 })
338 내용 = 가변정수쓰기(내용, 노드.시작)
339 내용 = 가변정수쓰기(내용, 노드.끝)
340 let mut 스칼라수 = 0
341 for 스칼라 in 노드.스칼라들 {
342 if !압축기하 || !원본기하필드인가(스칼라.필드) { 스칼라수 = 스칼라수 + 1 }
343 }
344 내용 = 가변정수쓰기(내용, 스칼라수)
345 for 스칼라 in 노드.스칼라들 {
346 if !압축기하 || !원본기하필드인가(스칼라.필드) {
347 내용 = 가변정수쓰기(내용, 사전색인(스칼라필드사전, 스칼라.필드))
348 내용.push(if 스칼라.태그 == 6 { 5 } else { 스칼라.태그 })
349 if 스칼라.태그 == 3 || 스칼라.태그 == 4 { 내용 = 가변정수쓰기(내용, 스칼라.정수값) }
350 else if 스칼라.태그 == 5 || 스칼라.태그 == 6 {
351 if 스칼라문자순번 >= 스칼라문자키들.length {
352 return Err("스칼라 문자열 키 캐시가 구조보다 짧습니다")
353 }
354 내용 = 가변정수쓰기(
355 내용,
356 사전색인(스칼라문자사전, 스칼라문자키들[스칼라문자순번])
357 )
358 스칼라문자순번 = 스칼라문자순번 + 1
359 }
360 }
361 }
362 if 노드.식별자있음 { 내용 = 가변정수쓰기(내용, 노드.식별자류번호) }
363 순번 = 순번 + 1
364 }
365 if 스칼라문자순번 != 스칼라문자키들.length {
366 return Err("스칼라 문자열 키 캐시가 구조보다 깁니다")
367 }
368 let 구조버전 = if 언어번호 == 1 || 언어번호 == 2 { 4 } else { 1 }
369 let mut 본문 = [67, 73, 70, 83, 구조버전, 1, 0, 0]
370 본문 = 삼십이쓰기(본문, 16 + 내용.length + 32)
371 본문 = 삼십이쓰기(본문, 내용.length)
372 본문 = 바이트추가(본문, 내용)
373 let 결과 = 바이트추가(본문, 해시배열(본문))
374 Ok(결과)
377export function 구조인코드(입력: string) -> Result<Bytes, string> {
378 let 구조 = json.parseAs<구조입력>(입력)?
379 바이트로(구조인코드배열(구조)?)
382export function 구조디코드(와이어: Bytes, 식별자표: Array<bool>) -> Result<string, string> {
383 let 전체 = 바이트배열로(와이어)
384 if 전체.length < 48 { return Err("구조 와이어가 잘렸습니다") }
385 if 전체.length > 2097152 { return Err("구조 와이어가 허용량을 넘습니다") }
386 let 본문 = 부분배열(전체, 0, 전체.length - 32)
387 let 실제해시 = 부분배열(전체, 전체.length - 32, 전체.length)
388 if !배열같음(실제해시, 해시배열(본문)) { return Err("구조 와이어 검사합이 맞지 않습니다") }
389 if 본문[0] != 67 || 본문[1] != 73 || 본문[2] != 70 || 본문[3] != 83 { return Err("구조 와이어 마법값이 틀립니다") }
390 if (본문[4] != 1 && 본문[4] != 4) || 본문[5] != 1 || 본문[6] != 0 || 본문[7] != 0 {
391 return Err("구조 와이어 버전이 틀립니다")
392 }
393 let 와이어버전 = 본문[4]
394 if 삼십이읽기(본문, 8) != 전체.length || 삼십이읽기(본문, 12) != 본문.length - 16 { return Err("구조 와이어 길이가 틀립니다") }
395 let mut 위치 = 16
396 let 해시끝 = 위치 + 32
397 let 분리본문키바이트 = 바이트로(부분배열(본문, 위치, 해시끝))?
398 let 분리본문키해시 = 분리본문키바이트.toHex()
399 위치 = 해시끝
400 let 노드수읽기 = 가변정수읽기(본문, 위치)?; 위치 = 노드수읽기.다음
401 let 본문수읽기 = 가변정수읽기(본문, 위치)?; 위치 = 본문수읽기.다음
402 if 식별자표.length != 노드수읽기.값 { return Err("식별자 표 길이가 노드 수와 다릅니다") }
403 let mut 원본행들: Array<압축원본행> = []
404 if 와이어버전 == 4 {
405 let 행수읽기 = 가변정수읽기(본문, 위치)?; 위치 = 행수읽기.다음
406 if 행수읽기.값 == 0 || 행수읽기.값 > 노드수읽기.값 * 2 {
407 return Err("원본 행 수가 허용량을 넘습니다")
408 }
409 let mut 이전행 = -1
410 let mut 이전시작 = 0
411 let mut 행색인 = 0
412 while 행색인 < 행수읽기.값 {
413 let 행차 = 가변정수읽기(본문, 위치)?; 위치 = 행차.다음
414 let 시작차 = 가변정수읽기(본문, 위치)?; 위치 = 시작차.다음
415 if 행차.값 == 0 || (행색인 > 0 && 시작차.값 == 0) {
416 return Err("원본 행들이 엄격히 증가하지 않습니다")
417 }
418 let 행 = 이전행 + 행차.값
419 let 시작 = 이전시작 + 시작차.값
420 원본행들.push(압축원본행 { 행: 행, 시작: 시작 })
421 이전행 = 행
422 이전시작 = 시작
423 행색인 = 행색인 + 1
424 }
425 }
426 let 자식읽기 = 사전해석(본문, 위치)?; 위치 = 자식읽기.다음
427 let 필드읽기 = 사전해석(본문, 위치)?; 위치 = 필드읽기.다음
428 if 와이어버전 == 4 {
429 for 필드 in 필드읽기.값들 {
430 if 원본기하필드인가(필드) { return Err("원본 기하가 스칼라 사전에 중복되었습니다") }
431 }
432 }
433 let 문자읽기 = 코드단위사전해석(본문, 위치)?; 위치 = 문자읽기.다음
434 let mut 노드들: Array<구조노드> = []
435 let mut 순번 = 0
436 while 순번 < 노드수읽기.값 {
437 let 코드 = 가변정수읽기(본문, 위치)?; 위치 = 코드.다음
438 let 부모차 = 가변정수읽기(본문, 위치)?; 위치 = 부모차.다음
439 let 자식필드코드 = 가변정수읽기(본문, 위치)?; 위치 = 자식필드코드.다음
440 let 자식색인코드 = 가변정수읽기(본문, 위치)?; 위치 = 자식색인코드.다음
441 let 시작읽기 = 가변정수읽기(본문, 위치)?; 위치 = 시작읽기.다음
442 let 끝읽기 = 가변정수읽기(본문, 위치)?; 위치 = 끝읽기.다음
443 let 스칼라수 = 가변정수읽기(본문, 위치)?; 위치 = 스칼라수.다음
444 if 자식필드코드.값 > 자식읽기.값들.length { return Err("자식 필드 사전 색인이 틀립니다") }
445 let mut 스칼라들: Array<구조스칼라> = []
446 let mut 스칼라색인 = 0
447 let mut 이전필드 = -1
448 while 스칼라색인 < 스칼라수.값 {
449 let 필드색인 = 가변정수읽기(본문, 위치)?; 위치 = 필드색인.다음
450 if 필드색인.값 >= 필드읽기.값들.length || 필드색인.값 <= 이전필드 { return Err("스칼라 필드가 정규 순서가 아닙니다") }
451 이전필드 = 필드색인.값
452 if 위치 >= 본문.length { return Err("스칼라 태그가 잘렸습니다") }
453 let 태그 = 본문[위치]; 위치 = 위치 + 1
454 let mut 호스트태그 = 태그
455 let mut 정수값 = 0
456 let mut 문자열값 = ""
457 if 태그 == 3 || 태그 == 4 {
458 let 정수읽기값 = 가변정수읽기(본문, 위치)?; 위치 = 정수읽기값.다음
459 정수값 = 정수읽기값.값
460 if 태그 == 4 && 정수값 == 0 { return Err("음수 영은 허용되지 않습니다") }
461 } else if 태그 == 5 {
462 let 문자열색인 = 가변정수읽기(본문, 위치)?; 위치 = 문자열색인.다음
463 if 문자열색인.값 >= 문자읽기.값들.length { return Err("스칼라 문자열 사전 색인이 틀립니다") }
464 let 문자값 = 문자읽기.값들[문자열색인.값]
465 if 문자값.안전 { 문자열값 = 문자값.안전값 }
466 else { 호스트태그 = 6; 문자열값 = 문자값.키 }
467 } else if 태그 < 0 || 태그 > 2 { return Err("스칼라 태그가 틀립니다") }
468 스칼라들.push(구조스칼라 {
469 필드: 필드읽기.값들[필드색인.값], 태그: 호스트태그,
470 정수값: 정수값, 문자열값: 문자열값
471 })
472 스칼라색인 = 스칼라색인 + 1
473 }
474 if 와이어버전 == 4 {
475 let 시작기하 = 압축원본문자위치(원본행들, 시작읽기.값)?
476 let 끝기하 = 압축원본문자위치(원본행들, 끝읽기.값)?
477 스칼라들.push(구조스칼라 { 필드: "startRow", 태그: 3, 정수값: 시작기하[0], 문자열값: "" })
478 스칼라들.push(구조스칼라 { 필드: "startColumn", 태그: 3, 정수값: 시작기하[1], 문자열값: "" })
479 스칼라들.push(구조스칼라 { 필드: "endRow", 태그: 3, 정수값: 끝기하[0], 문자열값: "" })
480 스칼라들.push(구조스칼라 { 필드: "endColumn", 태그: 3, 정수값: 끝기하[1], 문자열값: "" })
481 스칼라들 = 구조스칼라필드정렬(스칼라들)
482 }
483 let 식별자있음 = 식별자표[순번]
484 let mut 식별자류번호 = 0
485 if 식별자있음 {
486 let 식별자읽기 = 가변정수읽기(본문, 위치)?; 위치 = 식별자읽기.다음
487 식별자류번호 = 식별자읽기.값
488 }
489 노드들.push(구조노드 {
490 코드워드: 코드.값,
491 부모순번: if 순번 == 0 { -1 } else { 순번 - 부모차.값 },
492 자식필드있음: 자식필드코드.값 != 0,
493 자식필드: if 자식필드코드.값 == 0 { "" } else { 자식읽기.값들[자식필드코드.값 - 1] },
494 자식색인: if 자식색인코드.값 == 0 { -1 } else { 자식색인코드.값 - 1 },
495 시작: 시작읽기.값,
496 끝: 끝읽기.값,
497 스칼라들: 스칼라들,
498 식별자있음: 식별자있음,
499 식별자류번호: 식별자류번호
500 })
501 순번 = 순번 + 1
502 }
503 if 위치 != 본문.length { return Err("구조 와이어 뒤에 바이트가 남았습니다") }
504 let 구조 = 구조입력 { 분리본문키해시: 분리본문키해시, 분리본문값수: 본문수읽기.값, 노드들: 노드들 }
505 let 언어번호 = 구조언어번호(구조)
506 let 예상버전 = if 언어번호 == 1 || 언어번호 == 2 { 4 } else { 1 }
507 if 와이어버전 != 예상버전 { return Err("구조 와이어 버전이 언어와 맞지 않습니다") }
508 구조입력검사(언어번호, 구조)?
509 if !배열같음(구조인코드배열(구조)?, 전체) { return Err("구조 와이어가 정규 인코딩이 아닙니다") }
510 json.stringify(구조)
513export function 노드스칼라(노드: 구조노드, 필드: string) -> 구조스칼라 {
514 for 스칼라 in 노드.스칼라들 { if 스칼라.필드 == 필드 { return 스칼라 } }
515 구조스칼라 { 필드: "", 태그: 0, 정수값: 0, 문자열값: "" }
518export function 스칼라있음(노드: 구조노드, 필드: string) -> bool { 노드스칼라(노드, 필드).필드 != "" }
519export function 스칼라문자(노드: 구조노드, 필드: string) -> string { 노드스칼라(노드, 필드).문자열값 }
520export function 스칼라논리(노드: 구조노드, 필드: string) -> bool { 노드스칼라(노드, 필드).태그 == 2 }
521export function 스칼라정수(노드: 구조노드, 필드: string) -> int {
522 let 값 = 노드스칼라(노드, 필드)
523 if 값.태그 == 4 { -값.정수값 } else { 값.정수값 }

SHA256 061425cc359393de90b973775c94d2a7fc2b25999b2614916a44cb26dd55474c