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, and2
// structure validation with canonical wire encoding and decoding.4
import std.bytes { Bytes }5
import std.json6
import hash { 해시배열 }7
import nodes { 노드종류 }8
import util { 바이트로, 바이트배열로, 바이트추가, 배열같음, 부분배열 }9
import wire {10
가변정수쓰기,11
가변정수읽기,12
널문자있음,13
사전색인,14
사전쓰기,15
사전읽기,16
사전해석,17
삼십이쓰기,18
삼십이읽기,19
안전문자열코드단위키,20
정렬고유,21
정수읽기,22
짝없는대리자있음,23
코드단위문자열,24
코드단위문자열만들기,25
코드단위사전쓰기,26
코드단위사전읽기,27
코드단위사전해석,28
코드단위키읽기,29
}31
export record 구조스칼라 {32
필드: string,33
태그: int,34
정수값: int,35
문자열값: string36
}38
export record 구조노드 {39
코드워드: int,40
부모순번: int,41
자식필드있음: bool,42
자식필드: string,43
자식색인: int,44
시작: int,45
끝: int,46
스칼라들: Array<구조스칼라>,47
식별자있음: bool,48
식별자류번호: int49
}51
export record 구조입력 {52
분리본문키해시: string,53
분리본문값수: int,54
노드들: Array<구조노드>55
}57
export record 이미지요청 {58
언어번호: int,59
팔레트번호: int,60
프로필해시: string,61
구조해시: string,62
키해시: string,63
크롬번호: int,64
제목: string,65
원본줄수: int,66
구조: 구조입력67
}69
// JSON readers. A record is read from JSON in the module that declares it, so70
// the image request, which embeds a structure, is declared here as well.71
export function 구조입력읽기(글: string) -> Result<구조입력, string> {72
json.parseAs<구조입력>(글)73
}75
export function 이미지요청읽기(글: string) -> Result<이미지요청, string> {76
json.parseAs<이미지요청>(글)77
}79
export 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
0113
}115
function 코드단위태그허용(언어번호: int, 노드: 구조노드, 스칼라: 구조스칼라) -> bool {116
if 언어번호 != 1 && 언어번호 != 2 { return false }117
let 종류 = 노드종류(언어번호, 노드.코드워드)118
(종류 == 108 && 스칼라.필드 == "value") ||119
(종류 == 116 && 스칼라.필드 == "value.cooked")120
}122
function 구조스칼라검사(언어번호: 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) ?? 0133
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("지원하지 않는 구조 스칼라 태그입니다")172
}174
export function 구조입력검사(언어번호: int, 구조: 구조입력) -> Result<bool, string> {175
for 노드 in 구조.노드들 {176
let mut 첫필드 = true177
let mut 이전필드 = ""178
for 스칼라 in 노드.스칼라들 {179
if !첫필드 && 이전필드 >= 스칼라.필드 { return Err("구조 스칼라 필드가 정규 순서가 아닙니다") }180
구조스칼라검사(언어번호, 노드, 스칼라)?181
이전필드 = 스칼라.필드182
첫필드 = false183
}184
}185
Ok(true)186
}188
function 구조스칼라코드단위문자열(스칼라: 구조스칼라) -> Result<코드단위문자열, string> {189
if 스칼라.태그 == 5 {190
let 키 = 안전문자열코드단위키(스칼라.문자열값)191
return Ok(코드단위문자열 { 키: 키, 안전값: 스칼라.문자열값, 안전: true })192
}193
if 스칼라.태그 == 6 { return 코드단위문자열만들기(스칼라.문자열값) }194
Err("문자열이 아닌 구조 스칼라입니다")195
}197
export record 압축원본행 {198
행: int,199
시작: int200
}202
function 원본기하필드인가(필드: string) -> bool {203
필드 == "startRow" || 필드 == "startColumn" ||204
필드 == "endRow" || 필드 == "endColumn"205
}207
function 압축원본행들(구조: 구조입력) -> Result<Array<압축원본행>, string> {208
let mut 행들: Array<압축원본행> = []209
for 노드 in 구조.노드들 {210
let mut 모서리 = 0211
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 찾음 = false224
for 기존 in 행들 {225
if 기존.행 == 행 {226
if 기존.시작 != 행시작 { return Err("한 원본 행의 시작 오프셋이 서로 다릅니다") }227
찾음 = true228
}229
}230
if !찾음 { 행들.push(압축원본행 { 행: 행, 시작: 행시작 }) }231
모서리 = 모서리 + 1232
}233
}234
let mut 왼쪽 = 0235
while 왼쪽 < 행들.length {236
let mut 오른쪽 = 왼쪽 + 1237
while 오른쪽 < 행들.length {238
if 행들[오른쪽].행 < 행들[왼쪽].행 {239
let 임시 = 행들[왼쪽]240
행들[왼쪽] = 행들[오른쪽]241
행들[오른쪽] = 임시242
}243
오른쪽 = 오른쪽 + 1244
}245
왼쪽 = 왼쪽 + 1246
}247
let mut 색인 = 1248
while 색인 < 행들.length {249
if 행들[색인].시작 <= 행들[색인 - 1].시작 {250
return Err("원본 행 시작 오프셋이 엄격히 증가하지 않습니다")251
}252
색인 = 색인 + 1253
}254
Ok(행들)255
}257
function 압축원본문자위치(258
행들: Array<압축원본행>,259
오프셋: int260
) -> Result<Array<int>, string> {261
let mut 아래 = -1262
let mut 위 = 행들.length263
while 아래 + 1 < 위 {264
let 가운데 = (아래 + 위) / 2265
if 행들[가운데].시작 <= 오프셋 { 아래 = 가운데 } else { 위 = 가운데 }266
}267
if 아래 < 0 { return Err("노드 오프셋이 첫 원본 행보다 앞섭니다") }268
Ok([행들[아래].행, 오프셋 - 행들[아래].시작])269
}271
function 구조스칼라필드정렬(값들: Array<구조스칼라>) -> Array<구조스칼라> {272
let mut 결과 = 값들273
let mut 왼쪽 = 0274
while 왼쪽 < 결과.length {275
let mut 오른쪽 = 왼쪽 + 1276
while 오른쪽 < 결과.length {277
if 결과[오른쪽].필드 < 결과[왼쪽].필드 {278
let 임시 = 결과[왼쪽]279
결과[왼쪽] = 결과[오른쪽]280
결과[오른쪽] = 임시281
}282
오른쪽 = 오른쪽 + 1283
}284
왼쪽 = 왼쪽 + 1285
}286
결과287
}289
function 구조인코드배열(구조: 구조입력) -> Result<Array<int>, string> {290
let 언어번호 = 구조언어번호(구조)291
let 압축기하 = 언어번호 == 1 || 언어번호 == 2292
구조입력검사(언어번호, 구조)?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 이전행 = -1320
let mut 이전시작 = 0321
for 행 in 원본행들 {322
내용 = 가변정수쓰기(내용, 행.행 - 이전행)323
내용 = 가변정수쓰기(내용, 행.시작 - 이전시작)324
이전행 = 행.행325
이전시작 = 행.시작326
}327
}328
내용 = 사전쓰기(내용, 자식사전)?329
내용 = 사전쓰기(내용, 스칼라필드사전)?330
내용 = 코드단위사전쓰기(내용, 스칼라문자사전)?331
let mut 순번 = 0332
let mut 스칼라문자순번 = 0333
for 노드 in 구조.노드들 {334
내용 = 가변정수쓰기(내용, 노드.코드워드)335
내용 = 가변정수쓰기(내용, if 노드.부모순번 < 0 { 0 } else { 순번 - 노드.부모순번 })336
내용 = 가변정수쓰기(내용, if 노드.자식필드있음 { 사전색인(자식사전, 노드.자식필드) + 1 } else { 0 })337
내용 = 가변정수쓰기(내용, if 노드.자식색인 < 0 { 0 } else { 노드.자식색인 + 1 })338
내용 = 가변정수쓰기(내용, 노드.시작)339
내용 = 가변정수쓰기(내용, 노드.끝)340
let mut 스칼라수 = 0341
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
스칼라문자순번 = 스칼라문자순번 + 1359
}360
}361
}362
if 노드.식별자있음 { 내용 = 가변정수쓰기(내용, 노드.식별자류번호) }363
순번 = 순번 + 1364
}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(결과)375
}377
export function 구조인코드(입력: string) -> Result<Bytes, string> {378
let 구조 = json.parseAs<구조입력>(입력)?379
바이트로(구조인코드배열(구조)?)380
}382
export 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 위치 = 16396
let 해시끝 = 위치 + 32397
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 이전행 = -1410
let mut 이전시작 = 0411
let mut 행색인 = 0412
while 행색인 < 행수읽기.값 {413
let 행차 = 가변정수읽기(본문, 위치)?; 위치 = 행차.다음414
let 시작차 = 가변정수읽기(본문, 위치)?; 위치 = 시작차.다음415
if 행차.값 == 0 || (행색인 > 0 && 시작차.값 == 0) {416
return Err("원본 행들이 엄격히 증가하지 않습니다")417
}418
let 행 = 이전행 + 행차.값419
let 시작 = 이전시작 + 시작차.값420
원본행들.push(압축원본행 { 행: 행, 시작: 시작 })421
이전행 = 행422
이전시작 = 시작423
행색인 = 행색인 + 1424
}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 순번 = 0436
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 스칼라색인 = 0447
let mut 이전필드 = -1448
while 스칼라색인 < 스칼라수.값 {449
let 필드색인 = 가변정수읽기(본문, 위치)?; 위치 = 필드색인.다음450
if 필드색인.값 >= 필드읽기.값들.length || 필드색인.값 <= 이전필드 { return Err("스칼라 필드가 정규 순서가 아닙니다") }451
이전필드 = 필드색인.값452
if 위치 >= 본문.length { return Err("스칼라 태그가 잘렸습니다") }453
let 태그 = 본문[위치]; 위치 = 위치 + 1454
let mut 호스트태그 = 태그455
let mut 정수값 = 0456
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
스칼라색인 = 스칼라색인 + 1473
}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 식별자류번호 = 0485
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
순번 = 순번 + 1502
}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(구조)511
}513
export function 노드스칼라(노드: 구조노드, 필드: string) -> 구조스칼라 {514
for 스칼라 in 노드.스칼라들 { if 스칼라.필드 == 필드 { return 스칼라 } }515
구조스칼라 { 필드: "", 태그: 0, 정수값: 0, 문자열값: "" }516
}518
export function 스칼라있음(노드: 구조노드, 필드: string) -> bool { 노드스칼라(노드, 필드).필드 != "" }519
export function 스칼라문자(노드: 구조노드, 필드: string) -> string { 노드스칼라(노드, 필드).문자열값 }520
export function 스칼라논리(노드: 구조노드, 필드: string) -> bool { 노드스칼라(노드, 필드).태그 == 2 }521
export function 스칼라정수(노드: 구조노드, 필드: string) -> int {522
let 값 = 노드스칼라(노드, 필드)523
if 값.태그 == 4 { -값.정수값 } else { 값.정수값 }524
}SHA256 061425cc359393de90b973775c94d2a7fc2b25999b2614916a44cb26dd55474c