STUDIO HAZE · image
Topaz source
Open by house policy. Topaz is our own language.
Topaz 5.21 · 113 files
topaz/src/printers/javascript.tpz
Topaz · 118825 B · Original file
1
// JavaScript and TypeScript printing machine: the node printers and the iterative2
// driver that computes each child piece they request.4
import nodes { 노드종류 }5
import print { 글자합치기, 인쇄글조각, 인쇄조각같음, 인쇄조각이음, 인쇄조각자름, 인쇄조각접미, 인쇄호출 }6
import printer_state { 댓글고정있음, 식별자이름, 인쇄글조각결과, 인쇄조각결과합치기, 자식순번, 자식순번들, 준비된인쇄상태 }7
import printers.javascript.comments { 댓글붙이기조각 }8
import printers.javascript.layout {9
가장자리접두,10
노드들여쓰기,11
리터럴닫기접두,12
리터럴사이접두,13
리터럴열,14
리터럴첫줄수,15
매개기준끝행,16
매개뒤형식접두,17
명세닫기공백,18
모듈출처접두,19
문장부족행,20
문장접두,21
블록닫기접두,22
유효시작행,23
절접두,24
조각끝행,25
줄접두,26
직접앞끝행,27
함수몸접두,28
호출대상끝행,29
화살표괄호생략인가,30
화살표머리첫잎이매개인가,31
}32
import printers.javascript.literals { 철자문자열리터럴 }33
import printers.javascript.precedence { 우선순위, 인괄호필요, 인머리끄기, 인머리내림, 인머리켜기 }34
import printers.javascript.store { 인쇄글결과조각, 인쇄기계저장쓰기, 인쇄기계저장조각읽기 }35
import schema { 들여쓰기 }36
import structure { 구조노드, 구조스칼라, 구조입력, 노드스칼라, 스칼라논리, 스칼라문자, 스칼라있음, 스칼라정수 }37
import types { 인쇄조각판 }39
function 들사이조각인쇄(준비: 준비된인쇄상태, 순번들: Array<int>, 깊이: int, 사이: string) -> Result<int, string> {40
let mut 합 = 0; let mut 색인 = 041
while 색인 < 순번들.length {42
if 색인 > 0 { 합 = 인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, 사이)) }43
합 = 인쇄조각이음(준비.조각판, 합, 순번인쇄조각(준비, 순번들[색인], 깊이)?)44
색인 = 색인 + 145
}46
Ok(합)47
}49
// A named import/export clause prints `{`, its specifier list, then `}` as a50
// plain token, so the brace stays on the last specifier's row; the space before51
// it is suppressed exactly when the last specifier carries the clause's52
// trailing comma, because the reference printer drops the queued space that53
// follows a structural trailing comma. The list's own rows and columns come54
// from the one edge primitive, like every other edge.55
function 명세들조각인쇄(56
준비: 준비된인쇄상태,57
순번들: Array<int>,58
깊이: int59
) -> Result<int, string> {60
let mut 합 = 061
let mut 색인 = 062
while 색인 < 순번들.length {63
if 색인 > 0 {64
합 = 인쇄조각이음(65
준비.조각판,66
합,67
인쇄글조각(준비.조각판, "," + 가장자리접두(준비, 순번들[색인], " "))68
)69
}70
합 = 인쇄조각이음(준비.조각판, 합, 순번인쇄조각(준비, 순번들[색인], 깊이)?)71
색인 = 색인 + 172
}73
Ok(합)74
}76
function 형식목록조각인쇄(77
준비: 준비된인쇄상태,78
부모순번: int,79
순번들: Array<int>,80
깊이: int81
) -> Result<int, string> {82
if !준비.오프셋배치 || 순번들.length == 0 {83
return 들사이조각인쇄(준비, 순번들, 깊이, ", ")84
}85
let 부모 = 준비.구조.노드들[부모순번]86
let mut 합 = 087
let mut 색인 = 088
while 색인 < 순번들.length {89
let 현재 = 준비.구조.노드들[순번들[색인]]90
if 색인 == 0 {91
let 줄수 = 스칼라정수(현재, "startRow") - 스칼라정수(부모, "startRow")92
if 줄수 > 0 {93
합 = 인쇄조각이음(94
준비.조각판, 합,95
인쇄글조각(준비.조각판, 줄접두(줄수, 노드들여쓰기(준비, 순번들[색인])))96
)97
}98
} else {99
let 이전 = 준비.구조.노드들[순번들[색인 - 1]]100
let 줄수 = 스칼라정수(현재, "startRow") - 스칼라정수(이전, "endRow")101
let 사이 = if 줄수 > 0 {102
"," + 줄접두(줄수, 노드들여쓰기(준비, 순번들[색인]))103
} else { ", " }104
합 = 인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, 사이))105
}106
합 = 인쇄조각이음(107
준비.조각판, 합, 순번인쇄조각(준비, 순번들[색인], 깊이)?108
)109
색인 = 색인 + 1110
}111
Ok(합)112
}114
function 매개들조각인쇄(115
준비: 준비된인쇄상태,116
부모순번: int,117
순번들: Array<int>,118
깊이: int119
) -> Result<int, string> {120
if !준비.오프셋배치 || 순번들.length == 0 {121
return 들사이조각인쇄(준비, 순번들, 깊이, ", ")122
}123
let 들여쓰기값 = 노드들여쓰기(준비, 부모순번)124
let 기준끝행 = 매개기준끝행(준비, 부모순번)125
let mut 합 = 0126
let mut 색인 = 0127
while 색인 < 순번들.length {128
let 현재 = 준비.구조.노드들[순번들[색인]]129
if 색인 == 0 {130
let 줄수 = 스칼라정수(현재, "startRow") - 기준끝행131
if 줄수 > 0 {132
합 = 인쇄조각이음(133
준비.조각판,134
합,135
인쇄글조각(준비.조각판, 줄접두(줄수, 들여쓰기값))136
)137
}138
} else {139
let 이전 = 준비.구조.노드들[순번들[색인 - 1]]140
let 줄수 = 스칼라정수(현재, "startRow") - 스칼라정수(이전, "endRow")141
let 사이 = if 줄수 > 0 { "," + 줄접두(줄수, 들여쓰기값) } else { ", " }142
합 = 인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, 사이))143
}144
합 = 인쇄조각이음(145
준비.조각판,146
합,147
순번인쇄조각(준비, 순번들[색인], 깊이)?148
)149
색인 = 색인 + 1150
}151
Ok(합)152
}154
function 순번인쇄조각계산(준비: 준비된인쇄상태, 순번: int, 깊이: int) -> Result<int, string> {155
let mut 장식들 = 자식순번들(준비, 순번, "decorators")156
let 종류 = 노드종류(준비.언어번호, 준비.구조.노드들[순번].코드워드)157
let mut 장식소유자 = 순번158
if 장식들.length == 0 && 종류 == 306 {159
let 왼 = 자식순번(준비, 순번, "left")160
if 왼 >= 0 {161
장식들 = 자식순번들(준비, 왼, "decorators")162
장식소유자 = 왼163
}164
}165
let mut 합 = 0166
let mut 장식색인 = 0167
while 장식색인 < 장식들.length {168
let 장식 = 장식들[장식색인]169
match 순번인쇄조각(준비, 장식, 깊이) {170
case Ok(조각) => {171
합 = 인쇄조각이음(준비.조각판, 합, 조각)172
let mut 다음행 = 스칼라정수(준비.구조.노드들[순번], "startRow")173
if 장식색인 + 1 < 장식들.length {174
다음행 = 스칼라정수(준비.구조.노드들[장식들[장식색인 + 1]], "startRow")175
} else if 종류 != 601 && 종류 != 602 {176
let mut 다음시작 = 준비.구조.노드들[장식소유자].끝 + 1177
for 후보 in 준비.구조.노드들 {178
if 후보.부모순번 == 장식소유자 && 후보.자식필드 != "decorators" &&179
후보.시작 < 다음시작 {180
다음시작 = 후보.시작181
다음행 = 스칼라정수(후보, "startRow")182
}183
}184
}185
let 줄수 = 다음행 -186
스칼라정수(준비.구조.노드들[장식], "endRow")187
합 = 인쇄조각이음(188
준비.조각판,189
합,190
인쇄글조각(191
준비.조각판,192
if 준비.오프셋배치 && 줄수 > 0 {193
줄접두(줄수, 노드들여쓰기(준비, 순번))194
} else if 준비.오프셋배치 { " " }195
else { "\n" + 들여쓰기(깊이) }196
)197
)198
}199
case Err(오류) => return Err(오류)200
}201
장식색인 = 장식색인 + 1202
}203
let mut 몸 = if 댓글고정있음(준비) { 댓글노드인쇄조각(준비, 순번, 깊이)? }204
else { 노드인쇄조각(준비, 순번, 깊이)? }205
let 노드 = 준비.구조.노드들[순번]206
let 부모종류 = if 노드.부모순번 < 0 { 0 }207
else { 노드종류(준비.언어번호, 준비.구조.노드들[노드.부모순번].코드워드) }208
let 부모연산 = if 노드.부모순번 < 0 { "" }209
else { 스칼라문자(준비.구조.노드들[노드.부모순번], "operator") }210
// The v4 spelling scalar is the exact number of explicit parenthesis groups211
// on every expression kind. Apply all of them here; precedence printing212
// below suppresses its synthetic group when an explicit group already does213
// that job, so nested binary groups are neither dropped nor duplicated.214
let 괄호수 = 스칼라정수(노드, "spelling.parentheses")215
if 괄호수 > 0 {216
let mut 열기 = ""217
let mut 닫기 = ""218
let mut 괄호 = 0219
while 괄호 < 괄호수 {220
열기 = 열기 + "("221
닫기 = 닫기 + ")"222
괄호 = 괄호 + 1223
}224
let 앞끝행 = if 노드.부모순번 < 0 { 스칼라정수(노드, "startRow") }225
else { 직접앞끝행(준비, 노드.부모순번, 순번) }226
let 안쪽줄수 = 스칼라정수(노드, "startRow") - 앞끝행227
몸 = 인쇄조각결과합치기(준비, [228
인쇄글조각결과(준비, 열기 + if 준비.오프셋배치 && 안쪽줄수 > 0 {229
줄접두(안쪽줄수, 노드들여쓰기(준비, 순번))230
} else { "" }),231
Ok(몸), 인쇄글조각결과(준비, 닫기)232
])?233
}234
if 스칼라논리(준비.구조.노드들[순번], "spelling.trailingComma") {235
몸 = 인쇄조각결과합치기(준비, [Ok(몸), 인쇄글조각결과(준비, ",")])?236
}237
Ok(인쇄조각이음(준비.조각판, 합, 몸))238
}240
function 자식조각인쇄(준비: 준비된인쇄상태, 부모: int, 필드: string, 깊이: int) -> Result<int, string> {241
let 순번 = 자식순번(준비, 부모, 필드)242
if 순번 < 0 { Ok(0) }243
else { 순번인쇄조각(준비, 순번, 깊이) }244
}246
// The same single child, printed through the one edge primitive: the caller247
// gives the spelling this edge takes when parent and child share a row, and the248
// primitive decides whether that spelling or the carried row break is what the249
// edge prints.250
function 자식조각인쇄접두(251
준비: 준비된인쇄상태,252
부모: int,253
필드: string,254
깊이: int,255
같은행: string256
) -> Result<int, string> {257
let 순번 = 자식순번(준비, 부모, 필드)258
if 순번 < 0 { return Ok(0) }259
인쇄조각결과합치기(준비, [260
인쇄글조각결과(준비, 가장자리접두(준비, 순번, 같은행)),261
순번인쇄조각(준비, 순번, 깊이)262
])263
}265
function 문장목록조각인쇄(준비: 준비된인쇄상태, 순번들: Array<int>, 깊이: int) -> Result<int, string> {266
let mut 합 = 0; let mut 색인 = 0267
let mut 이전부족행 = 0268
while 색인 < 순번들.length {269
if 준비.오프셋배치 {270
합 = 인쇄조각이음(271
준비.조각판, 합,272
인쇄글조각(준비.조각판, 문장접두(준비, 순번들, 색인, 이전부족행))273
)274
} else {275
if 색인 > 0 { 합 = 인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, "\n")) }276
합 = 인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, 들여쓰기(깊이)))277
}278
let 문장조각 = 순번인쇄조각(준비, 순번들[색인], 깊이)?279
합 = 인쇄조각이음(준비.조각판, 합, 문장조각)280
이전부족행 = if 준비.오프셋배치 {281
문장부족행(준비, 순번들[색인], 문장조각)282
} else { 0 }283
색인 = 색인 + 1284
}285
Ok(합)286
}288
function 문장블록조각인쇄(준비: 준비된인쇄상태, 순번: int, 깊이: int, 머리: string) -> Result<int, string> {289
let 지시들 = 자식순번들(준비, 순번, "directives")290
let 본문들 = 자식순번들(준비, 순번, "body")291
if 지시들.length == 0 && 본문들.length == 0 {292
if 준비.오프셋배치 {293
let 노드 = 준비.구조.노드들[순번]294
let 줄수 = 스칼라정수(노드, "endRow") - 스칼라정수(노드, "startRow")295
if 줄수 > 0 {296
let 닫기공백 = 노드들여쓰기(준비, 순번)297
return 인쇄글조각결과(준비, 머리 + "\{" + 줄접두(줄수, 닫기공백) + "\}")298
}299
}300
return 인쇄글조각결과(준비, 머리 + "\{\}")301
}302
if 준비.오프셋배치 {303
let mut 내용들: Array<int> = []304
for 지시 in 지시들 { 내용들.push(지시) }305
for 본문 in 본문들 { 내용들.push(본문) }306
let 내용조각 = 문장목록조각인쇄(준비, 내용들, 깊이 + 1)?307
let 마지막부족행 = if 내용들.length == 0 { 0 } else {308
문장부족행(309
준비,310
내용들[내용들.length - 1],311
순번인쇄조각(준비, 내용들[내용들.length - 1], 깊이 + 1)?312
)313
}314
return 인쇄조각결과합치기(준비, [315
인쇄글조각결과(준비, 머리 + "\{"),316
Ok(내용조각),317
인쇄글조각결과(준비, 블록닫기접두(준비, 순번, 내용들, 마지막부족행) + "\}")318
])319
}320
인쇄조각결과합치기(준비, [321
인쇄글조각결과(준비, 머리 + "\{\n"),322
문장목록조각인쇄(준비, 지시들, 깊이 + 1),323
인쇄글조각결과(준비, if 지시들.length > 0 && 본문들.length > 0 { "\n\n" } else { "" }),324
문장목록조각인쇄(준비, 본문들, 깊이 + 1),325
인쇄글조각결과(준비, "\n" + 들여쓰기(깊이) + "\}")326
])327
}329
function 하위식조각인쇄(준비: 준비된인쇄상태, 순번: int, 깊이: int, 최소: int) -> Result<int, string> {330
let 명시괄호 = 스칼라정수(준비.구조.노드들[순번], "spelling.parentheses") > 0331
let 정밀괄호 = !명시괄호 && 우선순위(준비, 순번) < 최소332
if 정밀괄호 { 인머리끄기(준비, 순번) }333
let 인괄호 = !명시괄호 && !정밀괄호 && 인괄호필요(준비, 순번)334
let 식 = 순번인쇄조각(준비, 순번, 깊이)?335
if 정밀괄호 || 인괄호 {336
return 인쇄조각결과합치기(준비, [337
인쇄글조각결과(준비, "("), Ok(식), 인쇄글조각결과(준비, ")")338
])339
}340
Ok(식)341
}343
function 하위식들조각인쇄(344
준비: 준비된인쇄상태,345
순번들: Array<int>,346
깊이: int,347
최소: int348
) -> Result<int, string> {349
let mut 합 = 0350
let mut 색인 = 0351
while 색인 < 순번들.length {352
if 색인 > 0 {353
합 = 인쇄조각이음(354
준비.조각판,355
합,356
인쇄글조각(준비.조각판, "," + 가장자리접두(준비, 순번들[색인], " "))357
)358
}359
합 = 인쇄조각이음(360
준비.조각판,361
합,362
하위식조각인쇄(준비, 순번들[색인], 깊이, 최소)?363
)364
색인 = 색인 + 1365
}366
Ok(합)367
}369
function 호출인수들조각인쇄(370
준비: 준비된인쇄상태,371
부모순번: int,372
순번들: Array<int>,373
깊이: int,374
최소: int375
) -> Result<int, string> {376
if !준비.오프셋배치 {377
return 하위식들조각인쇄(준비, 순번들, 깊이, 최소)378
}379
let 부모 = 준비.구조.노드들[부모순번]380
let 대상순번 = 자식순번(준비, 부모순번, "callee")381
let 대상끝행 = 호출대상끝행(준비, 부모순번)382
let mut 대상끝열 = if 대상순번 < 0 { 스칼라정수(부모, "startColumn") }383
else { 스칼라정수(준비.구조.노드들[대상순번], "endColumn") }384
let 형식인수 = if 자식순번(준비, 부모순번, "typeArguments") >= 0 {385
자식순번(준비, 부모순번, "typeArguments")386
} else { 자식순번(준비, 부모순번, "typeParameters") }387
if 형식인수 >= 0 {388
대상끝열 = 스칼라정수(준비.구조.노드들[형식인수], "endColumn")389
}390
// The reference printer catches the closing parenthesis up to the call's391
// carried END row whether or not the list has any arguments.392
if 순번들.length == 0 {393
let 빈닫기줄수 = 스칼라정수(부모, "endRow") - 대상끝행394
if 빈닫기줄수 > 0 {395
return Ok(인쇄글조각(396
준비.조각판,397
줄접두(빈닫기줄수, 노드들여쓰기(준비, 부모순번))398
))399
}400
return Ok(0)401
}402
let 인수들여쓰기 = 노드들여쓰기(준비, 순번들[0])403
let 첫구분자너비 = if 노드종류(준비.언어번호, 부모.코드워드) == 211 &&404
스칼라논리(부모, "optional") { 3 } else { 1 }405
let mut 합 = 0406
let mut 색인 = 0407
while 색인 < 순번들.length {408
let 현재 = 준비.구조.노드들[순번들[색인]]409
if 색인 == 0 {410
// An argument the image carries parentheses for takes its row break411
// inside them, so this edge stays on the callee's row.412
let 첫줄수 = if 스칼라정수(현재, "spelling.parentheses") > 0 { 0 }413
else { 유효시작행(준비, 순번들[색인]) - 대상끝행 }414
if 첫줄수 > 0 {415
합 = 인쇄조각이음(416
준비.조각판,417
합,418
인쇄글조각(준비.조각판, 줄접두(첫줄수, 인수들여쓰기))419
)420
} else {421
// A first argument whose parameter list prints without parentheses is422
// reached by the reference printer's bare-arrow branch, which catches423
// the row up before the delimiter gap can be applied, so the carried424
// gap is not part of that edge.425
let mut 공백수 = if 화살표괄호생략인가(준비, 순번들[색인]) { 0 }426
else {427
스칼라정수(현재, "startColumn") - 대상끝열 -428
첫구분자너비 - 스칼라정수(현재, "spelling.parentheses")429
}430
let mut 공백 = ""431
while 공백수 > 0 { 공백 = 공백 + " "; 공백수 = 공백수 - 1 }432
if 공백 != "" {433
합 = 인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, 공백))434
}435
}436
} else {437
let 이전 = 준비.구조.노드들[순번들[색인 - 1]]438
let 줄수 = 유효시작행(준비, 순번들[색인]) - 스칼라정수(이전, "endRow")439
let 사이 = if 줄수 > 0 { "," + 줄접두(줄수, 인수들여쓰기) } else { ", " }440
합 = 인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, 사이))441
}442
합 = 인쇄조각이음(443
준비.조각판,444
합,445
하위식조각인쇄(준비, 순번들[색인], 깊이, 최소)?446
)447
색인 = 색인 + 1448
}449
let 닫기줄수 = 스칼라정수(부모, "endRow") - 조각끝행(준비, 대상끝행, 합)450
if 닫기줄수 > 0 {451
합 = 인쇄조각이음(452
준비.조각판,453
합,454
인쇄글조각(준비.조각판, 줄접두(닫기줄수, 노드들여쓰기(준비, 부모순번)))455
)456
}457
Ok(합)458
}460
function 연쇄대상조각인쇄(준비: 준비된인쇄상태, 순번: int, 깊이: int, 연속: bool) -> Result<int, string> {461
let 종류 = 노드종류(준비.언어번호, 준비.구조.노드들[순번].코드워드)462
if !연속 && (종류 == 211 || 종류 == 209) &&463
스칼라정수(준비.구조.노드들[순번], "spelling.parentheses") == 0 {464
인머리끄기(준비, 순번)465
return 인쇄조각결과합치기(준비, [466
인쇄글조각결과(준비, "("),467
순번인쇄조각(준비, 순번, 깊이),468
인쇄글조각결과(준비, ")")469
])470
}471
하위식조각인쇄(준비, 순번, 깊이, 17)472
}474
function 함수머리조각인쇄(준비: 준비된인쇄상태, 순번: int, 깊이: int, 이름있음: bool) -> Result<int, string> {475
let 노드 = 준비.구조.노드들[순번]476
let mut 머리 = (if 스칼라논리(노드, "async") { "async " } else { "" }) + "function"477
if 스칼라논리(노드, "generator") { 머리 = 머리 + "*" }478
if !이름있음 { 머리 = 머리 + " " }479
let mut 합 = 인쇄글조각(준비.조각판, 머리)480
if 이름있음 {481
합 = 인쇄조각이음(482
준비.조각판, 합, 자식조각인쇄접두(준비, 순번, "id", 깊이, " ")?483
)484
}485
let 형식매개 = 자식조각인쇄접두(준비, 순번, "typeParameters", 깊이, "")?486
if 준비.조각판.길이들[형식매개] > 0 {487
합 = 인쇄조각이음(준비.조각판, 합, 형식매개)488
}489
let 매개들 = 자식순번들(준비, 순번, "params")490
합 = 인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, "("))491
합 = 인쇄조각이음(492
준비.조각판,493
합,494
매개들조각인쇄(준비, 순번, 매개들, 깊이)?495
)496
합 = 인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, ")"))497
let 반환 = 자식조각인쇄(준비, 순번, "returnType", 깊이)?498
if 준비.조각판.길이들[반환] > 0 {499
합 = 인쇄조각결과합치기(준비, [500
Ok(합), 인쇄글조각결과(준비, 매개뒤형식접두(준비, 순번, 매개들)), Ok(반환)501
])?502
}503
Ok(합)504
}506
function 메서드조각인쇄(준비: 준비된인쇄상태, 순번: int, 깊이: int) -> Result<int, string> {507
let 노드 = 준비.구조.노드들[순번]508
let 종류 = 노드종류(준비.언어번호, 노드.코드워드)509
let mut 머리 = ""510
if 스칼라논리(노드, "declare") { 머리 = 머리 + "declare " }511
let 접근 = 스칼라문자(노드, "accessibility")512
if 접근 != "" { 머리 = 머리 + 접근 + " " }513
if 스칼라논리(노드, "abstract") { 머리 = 머리 + "abstract " }514
if 스칼라논리(노드, "static") { 머리 = 머리 + "static " }515
if 스칼라논리(노드, "override") { 머리 = 머리 + "override " }516
if 스칼라논리(노드, "async") { 머리 = 머리 + "async " }517
let 꼴 = 스칼라문자(노드, "kind")518
if 꼴 == "get" || 꼴 == "set" { 머리 = 머리 + 꼴 + " " }519
if 스칼라논리(노드, "generator") { 머리 = 머리 + "*" }520
// The reference printer carries the method's key row across the WHOLE head:521
// a `get` whose name the source puts on the following row is emitted on the522
// name's row, not on its own. A decorated member's rows are placed by the523
// decorator separator, which has already put the printer on the key's row, so524
// the separator owns the edge there and a second carry would double it.525
let 계산 = 스칼라논리(노드, "computed")526
let 키순번 = 자식순번(준비, 순번, "key")527
let 머리앞 = if 자식순번들(준비, 순번, "decorators").length > 0 { "" }528
else { 가장자리접두(준비, 키순번, "") }529
let mut 합 = 인쇄글조각(준비.조각판, 머리앞 + 머리)530
let 키 = if 계산 && 키순번 >= 0 {531
하위식조각인쇄(준비, 키순번, 깊이, 2)?532
} else { 자식조각인쇄(준비, 순번, "key", 깊이)? }533
if 계산 {534
합 = 인쇄조각결과합치기(준비, [535
Ok(합), 인쇄글조각결과(준비, "["), Ok(키), 인쇄글조각결과(준비, "]")536
])?537
} else {538
합 = 인쇄조각이음(준비.조각판, 합, 키)539
}540
if 스칼라논리(노드, "optional") {541
합 = 인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, "?"))542
}543
let 형식매개 = 자식조각인쇄접두(준비, 순번, "typeParameters", 깊이, "")?544
if 준비.조각판.길이들[형식매개] > 0 {545
합 = 인쇄조각이음(준비.조각판, 합, 형식매개)546
}547
let 매개들 = 자식순번들(준비, 순번, "params")548
합 = 인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, "("))549
합 = 인쇄조각이음(550
준비.조각판,551
합,552
매개들조각인쇄(준비, 순번, 매개들, 깊이)?553
)554
합 = 인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, ")"))555
let 반환 = 자식조각인쇄(준비, 순번, "returnType", 깊이)?556
if 준비.조각판.길이들[반환] > 0 {557
합 = 인쇄조각결과합치기(준비, [558
Ok(합), 인쇄글조각결과(준비, 매개뒤형식접두(준비, 순번, 매개들)), Ok(반환)559
])?560
}561
let 몸 = 자식조각인쇄(준비, 순번, "body", 깊이)?562
if 준비.조각판.길이들[몸] > 0 {563
let 몸순번 = 자식순번(준비, 순번, "body")564
합 = 인쇄조각결과합치기(준비, [565
Ok(합), 인쇄글조각결과(준비, 함수몸접두(준비, 순번, 몸순번)), Ok(몸)566
])?567
} else if 종류 == 604 || 종류 == 605 || 종류 == 606 {568
합 = 인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, ";"))569
}570
Ok(합)571
}573
function 중괄호목록조각인쇄(준비: 준비된인쇄상태, 순번들: Array<int>, 깊이: int, 세미콜론: bool) -> Result<int, string> {574
if 순번들.length == 0 { return 인쇄글조각결과(준비, "\{\}") }575
if 준비.오프셋배치 && 세미콜론 {576
let 부모순번 = 준비.구조.노드들[순번들[0]].부모순번577
let 부모 = 준비.구조.노드들[부모순번]578
let mut 이전행 = 스칼라정수(부모, "startRow")579
let mut 합 = 인쇄글조각(준비.조각판, "\{")580
for 멤버 in 순번들 {581
let 멤버노드 = 준비.구조.노드들[멤버]582
let 줄수 = 스칼라정수(멤버노드, "startRow") - 이전행583
if 줄수 > 0 {584
합 = 인쇄조각이음(585
준비.조각판,586
합,587
인쇄글조각(준비.조각판, 줄접두(줄수, 노드들여쓰기(준비, 멤버)))588
)589
}590
합 = 인쇄조각이음(준비.조각판, 합, 순번인쇄조각(준비, 멤버, 깊이 + 1)?)591
let 구분자 = if 스칼라논리(준비.구조.노드들[멤버], "spelling.typeMemberComma") { "," } else { ";" }592
합 = 인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, 구분자))593
이전행 = 스칼라정수(멤버노드, "endRow")594
}595
let 닫기줄수 = 스칼라정수(부모, "endRow") - 이전행596
let 닫기접두 = if 닫기줄수 > 0 {597
줄접두(닫기줄수, 노드들여쓰기(준비, 부모순번))598
} else { "" }599
return 인쇄조각결과합치기(준비, [600
Ok(합), 인쇄글조각결과(준비, 닫기접두 + "\}")601
])602
}603
if 준비.오프셋배치 && !세미콜론 {604
let 부모순번 = 준비.구조.노드들[순번들[0]].부모순번605
let 첫줄수 = 리터럴첫줄수(준비, 부모순번, 순번들[0])606
let mut 몸 = 인쇄글조각(607
준비.조각판,608
if 첫줄수 > 0 { 줄접두(첫줄수, 리터럴열(준비, 순번들[0])) } else { " " }609
)610
let mut 색인 = 0611
while 색인 < 순번들.length {612
if 색인 > 0 {613
let 접두 = 리터럴사이접두(준비, 순번들[색인 - 1], 순번들[색인])614
몸 = 인쇄조각이음(준비.조각판, 몸, 인쇄글조각(준비.조각판, "," + 접두))615
}616
몸 = 인쇄조각이음(준비.조각판, 몸, 순번인쇄조각(준비, 순번들[색인], 깊이 + 1)?)617
색인 = 색인 + 1618
}619
let 닫기접두 = 리터럴닫기접두(준비, 부모순번, 몸)?620
let 닫기 = if 닫기접두 != "" { 닫기접두 + "\}" } else { " \}" }621
return 인쇄조각결과합치기(준비, [622
인쇄글조각결과(준비, "\{"), Ok(몸), 인쇄글조각결과(준비, 닫기)623
])624
}625
let mut 합 = 인쇄글조각(준비.조각판, "\{\n"); let mut 색인 = 0626
while 색인 < 순번들.length {627
합 = 인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, 들여쓰기(깊이 + 1)))628
합 = 인쇄조각이음(준비.조각판, 합, 순번인쇄조각(준비, 순번들[색인], 깊이 + 1)?)629
if 세미콜론 {630
let 구분자 = if 스칼라논리(631
준비.구조.노드들[순번들[색인]],632
"spelling.typeMemberComma"633
) { "," } else { ";" }634
합 = 인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, 구분자))635
} else if 색인 + 1 < 순번들.length {636
합 = 인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, ","))637
}638
합 = 인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, "\n"))639
색인 = 색인 + 1640
}641
합 = 인쇄조각이음(642
준비.조각판,643
합,644
인쇄글조각(준비.조각판, 들여쓰기(깊이) + "\}")645
)646
Ok(합)647
}649
function 원시노드조각인쇄(준비: 준비된인쇄상태, 순번: int, 깊이: int) -> Result<int, string> {650
if 순번 < 0 || 순번 >= 준비.구조.노드들.length { return Err("인쇄 노드 순번이 범위를 벗어났습니다") }651
let 노드 = 준비.구조.노드들[순번]652
let 종류 = 노드종류(준비.언어번호, 노드.코드워드)653
if 종류 == 0 { return Err("인쇄기에 없는 노드 코드입니다: {노드.코드워드}") }655
if 종류 == 101 { return 자식조각인쇄(준비, 순번, "program", 깊이) }656
if 종류 == 102 {657
let 지시들 = 자식순번들(준비, 순번, "directives")658
let 본문들 = 자식순번들(준비, 순번, "body")659
if 준비.오프셋배치 {660
return 인쇄조각결과합치기(준비, [661
문장목록조각인쇄(준비, 지시들, 0),662
문장목록조각인쇄(준비, 본문들, 0)663
])664
}665
return 인쇄조각결과합치기(준비, [666
문장목록조각인쇄(준비, 지시들, 0),667
인쇄글조각결과(준비, if 지시들.length > 0 && 본문들.length > 0 { "\n\n" } else { "" }),668
문장목록조각인쇄(준비, 본문들, 0)669
])670
}671
if 종류 == 103 {672
return 인쇄조각결과합치기(준비, [673
자식조각인쇄(준비, 순번, "value", 깊이),674
인쇄글조각결과(준비, ";")675
])676
}677
if 종류 == 104 {678
if 스칼라있음(노드, "spelling.singleQuote") ||679
스칼라있음(노드, "spelling.escapeBody") {680
return 인쇄글결과조각(준비, 철자문자열리터럴(노드))681
}682
let 값 = 스칼라문자(노드, "value")683
let mut 역빗금수 = 0; let mut 큰따옴표 = false; let mut 작은따옴표 = false684
for 글자 in 값.scalars() {685
if 글자 == "\\" { 역빗금수 = 역빗금수 + 1 }686
else {687
if 역빗금수 % 2 == 0 {688
if 글자 == "\"" { 큰따옴표 = true }689
if 글자 == "'" { 작은따옴표 = true }690
}691
역빗금수 = 0692
}693
}694
if !큰따옴표 { return 인쇄글조각결과(준비, "\"" + 값 + "\"") }695
if !작은따옴표 { return 인쇄글조각결과(준비, "'" + 값 + "'") }696
return Err("지시문 리터럴에 탈출하지 않은 두 따옴표가 함께 있습니다")697
}698
if 종류 == 105 {699
let 식순번 = 자식순번(준비, 순번, "expression")700
let mut 밑순번 = 식순번701
if 밑순번 >= 0 &&702
노드종류(준비.언어번호, 준비.구조.노드들[밑순번].코드워드) == 210 {703
밑순번 = 자식순번(준비, 밑순번, "callee")704
}705
while 밑순번 >= 0 &&706
노드종류(준비.언어번호, 준비.구조.노드들[밑순번].코드워드) == 208 &&707
!스칼라논리(준비.구조.노드들[밑순번], "computed") {708
밑순번 = 자식순번(준비, 밑순번, "object")709
}710
// An explicit expression wrapper already supplies the grouping required711
// by decorator syntax. Babel does not add another synthetic pair around712
// it, so preserve that same canonical boundary here.713
let 그대로 = 스칼라정수(준비.구조.노드들[식순번], "spelling.parentheses") > 0 ||714
(밑순번 >= 0 &&715
노드종류(준비.언어번호, 준비.구조.노드들[밑순번].코드워드) == 106)716
return 인쇄조각결과합치기(준비, [717
인쇄글조각결과(준비, if 그대로 { "@" } else { "@(" }),718
순번인쇄조각(준비, 식순번, 깊이),719
인쇄글조각결과(준비, if 그대로 { "" } else { ")" })720
])721
}722
if 종류 == 106 {723
let mut 합 = 인쇄글조각(준비.조각판, 식별자이름(준비, 순번)?)724
if 스칼라논리(노드, "optional") {725
합 = 인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, "?"))726
}727
if 노드.부모순번 >= 0 && 노드.자식필드 == "id" {728
let 부모 = 준비.구조.노드들[노드.부모순번]729
if 노드종류(준비.언어번호, 부모.코드워드) == 408 &&730
스칼라논리(부모, "definite") {731
합 = 인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, "!"))732
}733
}734
let 형식 = 자식조각인쇄접두(준비, 순번, "typeAnnotation", 깊이, "")?735
return Ok(인쇄조각이음(준비.조각판, 합, 형식))736
}737
if 종류 == 107 {738
return 인쇄조각결과합치기(준비, [739
인쇄글조각결과(준비, "#"),740
자식조각인쇄(준비, 순번, "id", 깊이)741
])742
}743
if 종류 == 108 { return 인쇄글결과조각(준비, 철자문자열리터럴(노드)) }744
if 종류 == 109 { return 인쇄글조각결과(준비, 스칼라문자(노드, "value") + "n") }745
if 종류 == 110 {746
if 스칼라있음(노드, "spelling.numericLexeme") {747
return 인쇄글조각결과(준비, 스칼라문자(노드, "spelling.numericLexeme"))748
}749
let 값 = 노드스칼라(노드, "value")750
if 값.태그 == 5 {751
let 원본 = 값.문자열값752
if 원본 == "number:-0" { return 인쇄글조각결과(준비, "0") }753
if 원본 == "number:NaN" { return 인쇄글조각결과(준비, "0 / 0") }754
if 원본 == "number:Infinity" { return 인쇄글조각결과(준비, "1e999") }755
if 원본 == "number:-Infinity" { return 인쇄글조각결과(준비, "-1e999") }756
return 인쇄글조각결과(준비, 글자합치기(원본.scalars(), 7, 원본.scalars().length))757
}758
let 숫자 = 스칼라정수(노드, "value")759
return 인쇄글조각결과(준비, "{숫자}")760
}761
if 종류 == 111 { return 인쇄글조각결과(준비, if 스칼라논리(노드, "value") { "true" } else { "false" }) }762
if 종류 == 112 { return 인쇄글조각결과(준비, "null") }763
if 종류 == 113 { return 인쇄글조각결과(준비, "this") }764
if 종류 == 114 { return 인쇄글조각결과(준비, "super") }765
if 종류 == 115 {766
return 인쇄글조각결과(767
준비,768
"/" + 스칼라문자(노드, "pattern") + "/" + 스칼라문자(노드, "flags")769
)770
}771
if 종류 == 116 { return 인쇄글조각결과(준비, 스칼라문자(노드, "value.raw")) }772
if 종류 == 117 {773
let 준문자들 = 자식순번들(준비, 순번, "quasis")774
let 식들 = 자식순번들(준비, 순번, "expressions")775
let mut 합 = 인쇄글조각(준비.조각판, "`"); let mut 색인 = 0776
while 색인 < 준문자들.length {777
let 준문자인쇄 = if 댓글고정있음(준비) { 댓글노드인쇄조각(준비, 준문자들[색인], 깊이) }778
else { 노드인쇄조각(준비, 준문자들[색인], 깊이) }779
합 = 인쇄조각이음(준비.조각판, 합, 준문자인쇄?)780
if 색인 < 식들.length {781
let 준문자 = 준비.구조.노드들[준문자들[색인]]782
let 식노드 = 준비.구조.노드들[식들[색인]]783
let 식줄수 = 스칼라정수(식노드, "startRow") - 스칼라정수(준문자, "endRow")784
let 인괄호 = 인괄호필요(준비, 식들[색인])785
let 식인쇄 = if 댓글고정있음(준비) { 댓글노드인쇄조각(준비, 식들[색인], 깊이) }786
else { 노드인쇄조각(준비, 식들[색인], 깊이) }787
합 = 인쇄조각이음(788
준비.조각판, 합,789
인쇄글조각(790
준비.조각판,791
(if 인괄호 { "$\{(" } else { "$\{" }) +792
(if 준비.오프셋배치 && 식줄수 > 0 { 줄접두(식줄수, 0) } else { "" })793
)794
)795
합 = 인쇄조각이음(준비.조각판, 합, 식인쇄?)796
합 = 인쇄조각이음(797
준비.조각판, 합,798
인쇄글조각(준비.조각판, if 인괄호 { ")\}" } else { "\}" })799
)800
}801
색인 = 색인 + 1802
}803
return Ok(인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, "`")))804
}805
if 종류 == 118 {806
let 이름있음 = 자식순번(준비, 순번, "id") >= 0807
let 몸순번 = 자식순번(준비, 순번, "body")808
return 인쇄조각결과합치기(준비, [809
함수머리조각인쇄(준비, 순번, 깊이, 이름있음),810
인쇄글조각결과(준비, 함수몸접두(준비, 순번, 몸순번)),811
자식조각인쇄(준비, 순번, "body", 깊이)812
])813
}814
Err("원시 노드 인쇄 규칙을 찾지 못했습니다: {종류}")815
}817
function 모음노드조각인쇄(준비: 준비된인쇄상태, 순번: int, 깊이: int) -> Result<int, string> {818
let 노드 = 준비.구조.노드들[순번]819
let 종류 = 노드종류(준비.언어번호, 노드.코드워드)820
if 종류 == 201 || 종류 == 202 {821
let 무늬 = 종류 == 202822
if !스칼라있음(노드, "child.elements.length") { return Err("배열 요소 길이가 없습니다") }823
let 길이 = 스칼라정수(노드, "child.elements.length")824
if 길이 < 0 { return Err("배열 요소 길이가 음수입니다") }825
let mut 요소들: Array<int> = []826
let mut 색인 = 0827
while 색인 < 길이 { 요소들.push(-1); 색인 = 색인 + 1 }828
for 자식 in 자식순번들(준비, 순번, "elements") {829
let 요소 = 준비.구조.노드들[자식]830
if 요소.자식색인 < 0 || 요소.자식색인 >= 길이 || 요소들[요소.자식색인] >= 0 {831
return Err("배열 요소 색인이 정규형이 아닙니다")832
}833
요소들[요소.자식색인] = 자식834
}835
if 준비.오프셋배치 {836
let mut 첫요소 = -1837
let mut 마지막요소 = -1838
for 요소순번 in 요소들 {839
if 요소순번 >= 0 {840
if 첫요소 < 0 { 첫요소 = 요소순번 }841
마지막요소 = 요소순번842
}843
}844
let mut 몸 = 0845
let mut 이전요소 = -1846
색인 = 0847
while 색인 < 요소들.length {848
if 색인 > 0 { 몸 = 인쇄조각이음(준비.조각판, 몸, 인쇄글조각(준비.조각판, ",")) }849
if 요소들[색인] >= 0 {850
let 접두 = if 이전요소 < 0 {851
let 첫줄수 = 리터럴첫줄수(준비, 순번, 요소들[색인])852
if 첫줄수 > 0 { 줄접두(첫줄수, 리터럴열(준비, 요소들[색인])) }853
else if 색인 > 0 { " " } else { "" }854
} else {855
리터럴사이접두(준비, 이전요소, 요소들[색인])856
}857
몸 = 인쇄조각이음(준비.조각판, 몸, 인쇄글조각(준비.조각판, 접두))858
let 요소깊이 = if 노드종류(859
준비.언어번호,860
준비.구조.노드들[요소들[색인]].코드워드861
) == 201 { 깊이 + 1 } else { 깊이 }862
let 요소결과 = if 무늬 { 순번인쇄조각(준비, 요소들[색인], 깊이) }863
else { 하위식조각인쇄(준비, 요소들[색인], 요소깊이, 2) }864
match 요소결과 {865
case Ok(값) => { 몸 = 인쇄조각이음(준비.조각판, 몸, 값) }866
case Err(오류) => return Err(오류)867
}868
이전요소 = 요소들[색인]869
}870
색인 = 색인 + 1871
}872
if 요소들.length > 0 && 요소들[요소들.length - 1] < 0 {873
몸 = 인쇄조각이음(준비.조각판, 몸, 인쇄글조각(준비.조각판, ","))874
}875
let mut 합 = 인쇄조각이음(준비.조각판, 인쇄글조각(준비.조각판, "["), 몸)876
if 마지막요소 >= 0 {877
let 닫기접두 = 리터럴닫기접두(준비, 순번, 몸)?878
if 닫기접두 != "" {879
합 = 인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, 닫기접두))880
}881
}882
합 = 인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, "]"))883
if 무늬 { 합 = 인쇄조각이음(준비.조각판, 합, 자식조각인쇄접두(준비, 순번, "typeAnnotation", 깊이, "")?) }884
return Ok(합)885
}886
let mut 합 = 인쇄글조각(준비.조각판, "[")887
색인 = 0888
while 색인 < 요소들.length {889
if 색인 > 0 { 합 = 인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, ",")) }890
if 요소들[색인] >= 0 {891
if 색인 > 0 { 합 = 인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, " ")) }892
let 요소결과 = if 무늬 { 순번인쇄조각(준비, 요소들[색인], 깊이) }893
else { 하위식조각인쇄(준비, 요소들[색인], 깊이, 2) }894
match 요소결과 {895
case Ok(값) => { 합 = 인쇄조각이음(준비.조각판, 합, 값) }896
case Err(오류) => return Err(오류)897
}898
}899
색인 = 색인 + 1900
}901
if 요소들.length > 0 && 요소들[요소들.length - 1] < 0 {902
합 = 인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, ","))903
}904
합 = 인쇄조각이음(준비.조각판, 합, 인쇄글조각(준비.조각판, "]"))905
if 무늬 {906
match 자식조각인쇄접두(준비, 순번, "typeAnnotation", 깊이, "") {907
case Ok(형식) => { 합 = 인쇄조각이음(준비.조각판, 합, 형식) }908
case Err(오류) => return Err(오류)909
}910
}911
return Ok(합)912
}913
if 종류 == 203 { return 중괄호목록조각인쇄(준비, 자식순번들(준비, 순번, "properties"), 깊이, false) }914
if 종류 == 204 { return 중괄호목록조각인쇄(준비, 자식순번들(준비, 순번, "properties"), 깊이, false) }915
if 종류 == 205 {916
let 키순번 = 자식순번(준비, 순번, "key")917
let 값순번 = 자식순번(준비, 순번, "value")918
let 계산 = 스칼라논리(노드, "computed")919
let 키 = match if 계산 && 키순번 >= 0 { 하위식조각인쇄(준비, 키순번, 깊이, 2) }920
else if 댓글고정있음(준비) { 댓글노드인쇄조각(준비, 키순번, 깊이) }921
else { 노드인쇄조각(준비, 키순번, 깊이) } {922
case Ok(조각) => 조각923
case Err(오류) => return Err(오류)924
}925
let 값 = match 하위식조각인쇄(준비, 값순번, 깊이, 2) {926
case Ok(조각) => 조각927
case Err(오류) => return Err(오류)928
}929
if 스칼라논리(노드, "shorthand") {930
if 인쇄조각같음(준비.조각판, 키, 값)? { return Ok(키) }931
if 노드종류(준비.언어번호, 준비.구조.노드들[값순번].코드워드) == 306 {932
let 왼순번 = 자식순번(준비, 값순번, "left")933
if 왼순번 >= 0 &&934
노드종류(준비.언어번호, 준비.구조.노드들[왼순번].코드워드) == 106 &&935
인쇄조각같음(936
준비.조각판,937
키,938
인쇄글조각(준비.조각판, 식별자이름(준비, 왼순번)?)939
)? { return Ok(값) }940
}941
}942
let 키글 = if 계산 {943
인쇄조각결과합치기(준비, [944
인쇄글조각결과(준비, "[" + 가장자리접두(준비, 키순번, "")),945
Ok(키), 인쇄글조각결과(준비, "]")946
])?947
} else { 키 }948
return 인쇄조각결과합치기(준비, [949
Ok(키글), 인쇄글조각결과(준비, ":" + 가장자리접두(준비, 값순번, " ")), Ok(값)950
])951
}952
if 종류 == 206 {953
let 인수순번 = 자식순번(준비, 순번, "argument")954
return 인쇄조각결과합치기(준비, [955
인쇄글조각결과(준비, "..." + 가장자리접두(준비, 인수순번, "")),956
하위식조각인쇄(준비, 인수순번, 깊이, 2)957
])958
}959
if 종류 == 207 {960
return 인쇄조각결과합치기(준비, [961
인쇄글조각결과(준비, "..."),962
자식조각인쇄(준비, 순번, "argument", 깊이),963
자식조각인쇄접두(준비, 순번, "typeAnnotation", 깊이, "")964
])965
}966
if 종류 == 208 || 종류 == 209 {967
let 선택 = 종류 == 209968
let 대상순번 = 자식순번(준비, 순번, "object")969
let 속성순번 = 자식순번(준비, 순번, "property")970
let 대상종류 = if 대상순번 < 0 { 0 }971
else { 노드종류(준비.언어번호, 준비.구조.노드들[대상순번].코드워드) }972
let 대상 = match 연쇄대상조각인쇄(준비, 대상순번, 깊이, 선택) {973
case Ok(조각) => if 대상종류 == 727 &&974
스칼라정수(준비.구조.노드들[대상순번], "spelling.parentheses") == 0 {975
인쇄조각결과합치기(준비, [976
인쇄글조각결과(준비, "("), Ok(조각), 인쇄글조각결과(준비, ")")977
])?978
} else { 조각 }979
case Err(오류) => return Err(오류)980
}981
if 스칼라논리(노드, "computed") {982
let 접근접두 = if 대상순번 >= 0 && 속성순번 >= 0 {983
가장자리접두(준비, 속성순번, "")984
} else { "" }985
return 인쇄조각결과합치기(준비, [986
Ok(대상),987
인쇄글조각결과(준비, (if 선택 && 스칼라논리(노드, "optional") { "?." } else { "" }) + "["),988
인쇄글조각결과(준비, 접근접두),989
자식조각인쇄(준비, 순번, "property", 깊이),990
인쇄글조각결과(준비, "]")991
])992
}993
let mut 정수대상 = false994
if !선택 && 대상순번 >= 0 && 대상종류 == 110 {995
let 숫자값 = 노드스칼라(준비.구조.노드들[대상순번], "value")996
정수대상 = 숫자값.태그 == 3997
if 숫자값.태그 == 5 {998
let 글자들 = 숫자값.문자열값.scalars()999
let mut 색인 = 71000
정수대상 = 색인 < 글자들.lengthSHA256 887fab33ce619d402403f3eb50e666a165a5a42e1ddec997428415f18eef2907