codeimage.io

STUDIO HAZE · image

Topaz source

Open by house policy. Topaz is our own language.

Topaz 5.21 · 113 files

topaz/src/printers/kotlin.tpz

Topaz · 16107 B · Original file

1// Kotlin structure validation and canonical source printing.
3import nodes { 노드종류 }
4import printer_cursor { 러스트열폭, 본문위치전진 }
5import printer_setup { 인쇄상태만들기 }
6import printer_state { 식별자이름 }
7import printer_text { 선형원본끝공백제거, 선형원본만들기, 선형원본추가, 선형원본평평하게 }
8import schema { 코틀린댓글코드, 코틀린원자본문코드 }
9import structure { 구조노드, 구조스칼라, 구조입력, 구조입력검사, 노드스칼라, 스칼라문자, 스칼라있음 }
11function 코틀린정수스칼라검사(노드: 구조노드, 필드: string) -> Result<int, string> {
12 let 값 = 노드스칼라(노드, 필드)
13 if 값.필드 == "" || 값.태그 != 3 || 값.정수값 < 0 {
14 return Err("Kotlin 구조 정수 스칼라가 정규형이 아닙니다: {필드}")
15 }
16 Ok(값.정수값)
19export function 코틀린인쇄구조검사(구조: 구조입력) -> Result<bool, string> {
20 구조입력검사(13, 구조)?
21 if 구조.노드들.length == 0 {
22 return Err("Kotlin 인쇄 구조에 원본 파일 노드가 필요합니다")
23 }
24 if 구조.노드들[0].코드워드 != 13 ||
25 구조.노드들[0].부모순번 != -1 || 구조.노드들[0].자식필드있음 ||
26 구조.노드들[0].자식필드 != "" || 구조.노드들[0].자식색인 != -1 {
27 return Err("Kotlin 인쇄 구조 뿌리가 원본 파일 노드가 아닙니다")
28 }
29 let mut 자식수들: Array<int> = []
30 let mut 순번 = 0
31 while 순번 < 구조.노드들.length { 자식수들.push(0); 순번 = 순번 + 1 }
32 let mut 분리본문발생수 = 0
33 let mut 다음식별자류번호 = 0
34 순번 = 0
35 while 순번 < 구조.노드들.length {
36 let 노드 = 구조.노드들[순번]
37 if 노드종류(13, 노드.코드워드) == 0 {
38 return Err("Kotlin 투영 인쇄기가 지원하지 않는 노드입니다: 순번 {순번}, 코드 {노드.코드워드}")
39 }
40 if 순번 > 0 {
41 if 노드.부모순번 < 0 || 노드.부모순번 >= 순번 ||
42 !노드.자식필드있음 || 노드.자식필드 == "" || 노드.자식색인 < 0 {
43 return Err("Kotlin 인쇄 구조의 부모 또는 자식 위치가 정규형이 아닙니다: 순번 {순번}")
44 }
45 자식수들[노드.부모순번] = 자식수들[노드.부모순번] + 1
46 }
47 if 노드.시작 < 0 || 노드.끝 < 노드.시작 {
48 return Err("Kotlin 인쇄 구조의 원본 범위가 틀립니다: 순번 {순번}")
49 }
50 let 자식수 = 코틀린정수스칼라검사(노드, "childCount")?
51 let 시작행 = 코틀린정수스칼라검사(노드, "startRow")?
52 let 시작열 = 코틀린정수스칼라검사(노드, "startColumn")?
53 let 끝행 = 코틀린정수스칼라검사(노드, "endRow")?
54 let 끝열 = 코틀린정수스칼라검사(노드, "endColumn")?
55 if 끝행 < 시작행 || (끝행 == 시작행 && 끝열 < 시작열) {
56 return Err("Kotlin 인쇄 구조의 원본 좌표가 틀립니다: 순번 {순번}")
57 }
58 if !스칼라있음(노드, "named") || !스칼라있음(노드, "extra") {
59 return Err("Kotlin 인쇄 구조의 노드 표지 스칼라가 없습니다: 순번 {순번}")
60 }
61 if 스칼라있음(노드, "sourceBom") {
62 return Err("Kotlin 구조에 허용되지 않는 원본 BOM 표지가 있습니다: 순번 {순번}")
63 }
64 if 노드.코드워드 == 393 && 자식수 == 0 {
65 if 노드.식별자있음 {
66 if 스칼라있음(노드, "text") {
67 return Err("Kotlin 식별자 이름이 이미지와 분리 본문에 함께 있습니다")
68 }
69 if 노드.식별자류번호 < 0 || 노드.식별자류번호 > 다음식별자류번호 {
70 return Err("Kotlin 식별자 알파류가 첫 사용 정규형이 아닙니다: 순번 {순번}")
71 }
72 if 노드.식별자류번호 == 다음식별자류번호 {
73 다음식별자류번호 = 다음식별자류번호 + 1
74 }
75 분리본문발생수 = 분리본문발생수 + 1
76 } else if 노드.식별자류번호 != 0 || !스칼라있음(노드, "text") ||
77 노드스칼라(노드, "text").태그 != 5 {
78 return Err("Kotlin 이미지 식별자 이름이 정규형이 아닙니다: 순번 {순번}")
79 }
80 } else {
81 if 노드.식별자있음 || 노드.식별자류번호 != 0 {
82 return Err("Kotlin 식별자가 아닌 노드에 알파류가 있습니다: 순번 {순번}")
83 }
84 if 코틀린댓글코드(노드.코드워드) {
85 if 자식수 != 0 || 스칼라있음(노드, "text") {
86 return Err("Kotlin 댓글 원문은 분리 본문에만 있어야 합니다: 순번 {순번}")
87 }
88 분리본문발생수 = 분리본문발생수 + 1
89 } else if 자식수 == 0 || 코틀린원자본문코드(노드.코드워드) {
90 if !스칼라있음(노드, "text") || 노드스칼라(노드, "text").태그 != 5 {
91 return Err("Kotlin 인쇄 토큰의 원문이 없습니다: 순번 {순번}")
92 }
93 } else if 스칼라있음(노드, "text") {
94 return Err("Kotlin 가지 노드에 토큰 원문이 있습니다: 순번 {순번}")
95 }
96 }
97 순번 = 순번 + 1
98 }
99 순번 = 0
100 while 순번 < 구조.노드들.length {
101 if 코틀린정수스칼라검사(구조.노드들[순번], "childCount")? != 자식수들[순번] {
102 return Err("Kotlin 노드 자식 수가 구조와 다릅니다: 순번 {순번}")
103 }
104 순번 = 순번 + 1
105 }
106 if 구조.분리본문값수 < 0 || 구조.분리본문값수 != 분리본문발생수 {
107 return Err("Kotlin 분리 본문 값 수가 식별자와 댓글 발생 수에 맞지 않습니다")
108 }
109 Ok(true)
112export record 코틀린인쇄토큰 {
113 순번: int,
114 간격색인: int
117function 코틀린토큰정수(구조: 구조입력, 토큰: 코틀린인쇄토큰, 접미: string) -> Result<int, string> {
118 let 노드 = 구조.노드들[토큰.순번]
119 if 토큰.간격색인 < 0 {
120 let 필드 = if 접미 == "StartRow" { "startRow" }
121 else if 접미 == "StartColumn" { "startColumn" }
122 else if 접미 == "EndRow" { "endRow" }
123 else if 접미 == "EndColumn" { "endColumn" }
124 else { 접미 }
125 return 코틀린정수스칼라검사(노드, 필드)
126 }
127 코틀린정수스칼라검사(노드, "sourceGap{토큰.간격색인}{접미}")
130function 코틀린잎앞섬(구조: 구조입력, 왼쪽: 코틀린인쇄토큰, 오른쪽: 코틀린인쇄토큰) -> Result<bool, string> {
131 let 왼쪽시작 = if 왼쪽.간격색인 < 0 { 구조.노드들[왼쪽.순번].시작 }
132 else { 코틀린토큰정수(구조, 왼쪽, "Start")? }
133 let 오른쪽시작 = if 오른쪽.간격색인 < 0 { 구조.노드들[오른쪽.순번].시작 }
134 else { 코틀린토큰정수(구조, 오른쪽, "Start")? }
135 if 왼쪽시작 != 오른쪽시작 {
136 return Ok(왼쪽시작 < 오른쪽시작)
137 }
138 let 왼쪽끝 = if 왼쪽.간격색인 < 0 { 구조.노드들[왼쪽.순번].끝 }
139 else { 코틀린토큰정수(구조, 왼쪽, "End")? }
140 let 오른쪽끝 = if 오른쪽.간격색인 < 0 { 구조.노드들[오른쪽.순번].끝 }
141 else { 코틀린토큰정수(구조, 오른쪽, "End")? }
142 if 왼쪽끝 != 오른쪽끝 {
143 return Ok(왼쪽끝 < 오른쪽끝)
144 }
145 if 왼쪽.순번 != 오른쪽.순번 { Ok(왼쪽.순번 < 오른쪽.순번) }
146 else { Ok(왼쪽.간격색인 < 오른쪽.간격색인) }
149function 코틀린잎순번들(구조: 구조입력) -> Result<Array<코틀린인쇄토큰>, string> {
150 let mut 잎들: Array<코틀린인쇄토큰> = []
151 let mut 순번 = 0
152 while 순번 < 구조.노드들.length {
153 let 노드 = 구조.노드들[순번]
154 let mut 부모순번 = 노드.부모순번
155 let mut 원자본문조상있음 = false
156 while 부모순번 >= 0 {
157 if 코틀린원자본문코드(구조.노드들[부모순번].코드워드) {
158 원자본문조상있음 = true
159 부모순번 = -1
160 } else {
161 부모순번 = 구조.노드들[부모순번].부모순번
162 }
163 }
164 if !원자본문조상있음 &&
165 (코틀린원자본문코드(노드.코드워드) ||
166 코틀린정수스칼라검사(노드, "childCount")? == 0) {
167 잎들.push(코틀린인쇄토큰 { 순번: 순번, 간격색인: -1 })
168 }
169 if 스칼라있음(노드, "sourceGapCount") {
170 let 간격수 = 코틀린정수스칼라검사(노드, "sourceGapCount")?
171 let mut 간격색인 = 0
172 while 간격색인 < 간격수 {
173 let 시작 = 코틀린정수스칼라검사(노드, "sourceGap{간격색인}Start")?
174 let 끝 = 코틀린정수스칼라검사(노드, "sourceGap{간격색인}End")?
175 let 글 = 스칼라문자(노드, "sourceGap{간격색인}Text")
176 if 시작 < 노드.시작 || 끝 <= 시작 || 끝 > 노드.끝 || 글 == "" {
177 return Err("Kotlin 투영의 원문 간격이 잘못되었습니다")
178 }
179 잎들.push(코틀린인쇄토큰 { 순번: 순번, 간격색인: 간격색인 })
180 if 잎들.length > 구조.노드들.length * 2 {
181 return Err("Kotlin 투영에 원문 간격이 너무 많습니다")
182 }
183 간격색인 = 간격색인 + 1
184 }
185 }
186 순번 = 순번 + 1
187 }
188 let mut 색인 = 1
189 while 색인 < 잎들.length {
190 let 값 = 잎들[색인]
191 let mut 자리 = 색인
192 while 자리 > 0 && 코틀린잎앞섬(구조, 값, 잎들[자리 - 1])? {
193 잎들[자리] = 잎들[자리 - 1]
194 자리 = 자리 - 1
195 }
196 잎들[자리] = 값
197 색인 = 색인 + 1
198 }
199 Ok(잎들)
202export function 코틀린원본인쇄(구조: 구조입력) -> Result<string, string> {
203 코틀린인쇄구조검사(구조)?
204 let 준비 = 인쇄상태만들기(13, 구조, [], [], false, false)
205 let 잎들 = 코틀린잎순번들(구조)?
206 let 원본 = 선형원본만들기()
207 let mut 출력행 = 0
208 let mut 출력열 = 0
209 let mut 이전끝행 = 0
210 let mut 이전끝열 = 0
211 let mut 이전끝스칼라열 = 0
212 let mut 이전있음 = false
213 let mut 접힌댓글행수 = 0
214 let mut 접힌댓글뒤구분 = false
215 let mut 토큰색인 = 0
216 while 토큰색인 < 잎들.length {
217 let 인쇄토큰 = 잎들[토큰색인]
218 let 순번 = 인쇄토큰.순번
219 let 노드 = 구조.노드들[순번]
220 let 시작행 = 코틀린토큰정수(구조, 인쇄토큰, "StartRow")?
221 let 시작열 = 코틀린토큰정수(구조, 인쇄토큰, "StartColumn")?
222 let 끝행 = 코틀린토큰정수(구조, 인쇄토큰, "EndRow")?
223 let 끝열 = 코틀린토큰정수(구조, 인쇄토큰, "EndColumn")?
224 let 보이는시작행 = 시작행 - 접힌댓글행수
225 let 보이는끝행 = 끝행 - 접힌댓글행수
226 if 보이는시작행 < 0 || 보이는끝행 < 보이는시작행 {
227 return Err("Kotlin 투영의 보이는 행 배치가 잘못되었습니다")
228 }
229 let 대체폭 = if 시작행 == 끝행 { 끝열 - 시작열 } else { 끝열 }
230 let 원문간격 = 인쇄토큰.간격색인 >= 0
231 let 식별자노드 = !원문간격 && 노드.코드워드 == 393 && 코틀린정수스칼라검사(노드, "childCount")? == 0
232 let 분리식별자 = 식별자노드 && 노드.식별자있음
233 let 생략댓글 = !원문간격 && 코틀린댓글코드(노드.코드워드) && !스칼라있음(노드, "text")
234 let 토큰 = if 생략댓글 { "" } else if 식별자노드 {
235 식별자이름(준비, 순번)?
236 } else if 원문간격 {
237 스칼라문자(노드, "sourceGap{인쇄토큰.간격색인}Text")
238 } else { 스칼라문자(노드, "text") }
239 let 원본스칼라폭 = if 분리식별자 {
240 러스트열폭(노드, "identifier", "Scalar", 대체폭)
241 } else if 생략댓글 {
242 러스트열폭(노드, "comment", "Scalar", 대체폭)
243 } else {
244 본문위치전진(13, 0, 0, 토큰)[1]
245 }
246 let 원본시작스칼라열 = if 이전있음 && 시작행 == 이전끝행 {
247 이전끝스칼라열 + 시작열 - 이전끝열
248 } else { 시작열 }
249 let 원본끝스칼라열 = if 끝행 == 시작행 {
250 원본시작스칼라열 + 원본스칼라폭
251 } else { 원본스칼라폭 }
252 let 구분필요 = 이전있음 && 시작행 == 이전끝행 && 시작열 > 이전끝열
253 if 생략댓글 {
254 let 다음시작행 = if 토큰색인 + 1 < 잎들.length {
255 코틀린토큰정수(구조, 잎들[토큰색인 + 1], "StartRow")?
256 } else { -1 }
257 let 식안접힘 = 이전있음 && 시작행 == 이전끝행 && 끝행 > 시작행 &&
258 다음시작행 == 끝행
259 if 식안접힘 {
260 접힌댓글행수 = 접힌댓글행수 + 끝행 - 시작행
261 접힌댓글뒤구분 = true
262 토큰색인 = 토큰색인 + 1
263 continue
264 }
265 let 온줄차지 = (!이전있음 || 시작행 > 이전끝행) &&
266 (다음시작행 < 0 || 다음시작행 > 끝행)
267 let 줄끝댓글 = 이전있음 && 시작행 == 이전끝행 &&
268 (다음시작행 < 0 || 다음시작행 > 끝행)
269 if 온줄차지 {
270 while 출력행 < 보이는시작행 {
271 선형원본추가(원본, "\n"); 출력행 = 출력행 + 1; 출력열 = 0
272 }
273 while 출력행 < 보이는끝행 {
274 선형원본추가(원본, "\n"); 출력행 = 출력행 + 1; 출력열 = 0
275 }
276 } else if 줄끝댓글 {
277 이전끝행 = 끝행
278 이전끝열 = 끝열
279 이전끝스칼라열 = 원본끝스칼라열
280 이전있음 = true
281 토큰색인 = 토큰색인 + 1
282 continue
283 } else {
284 if 출력행 < 보이는시작행 {
285 while 출력행 < 보이는시작행 {
286 선형원본추가(원본, "\n"); 출력행 = 출력행 + 1; 출력열 = 0
287 }
288 while 출력열 < 원본시작스칼라열 {
289 선형원본추가(원본, " "); 출력열 = 출력열 + 1
290 }
291 } else if 출력행 == 보이는시작행 && 출력열 < 원본시작스칼라열 {
292 while 출력열 < 원본시작스칼라열 {
293 선형원본추가(원본, " "); 출력열 = 출력열 + 1
294 }
295 } else if 출력행 == 보이는시작행 && 구분필요 {
296 선형원본추가(원본, " "); 출력열 = 출력열 + 1
297 }
298 if 출력행 < 보이는끝행 {
299 while 출력행 < 보이는끝행 {
300 선형원본추가(원본, "\n"); 출력행 = 출력행 + 1; 출력열 = 0
301 }
302 while 출력열 < 원본끝스칼라열 {
303 선형원본추가(원본, " "); 출력열 = 출력열 + 1
304 }
305 } else if 출력행 == 보이는끝행 && 출력열 < 원본끝스칼라열 {
306 while 출력열 < 원본끝스칼라열 {
307 선형원본추가(원본, " "); 출력열 = 출력열 + 1
308 }
309 }
310 }
311 } else {
312 if 출력행 < 보이는시작행 {
313 while 출력행 < 보이는시작행 {
314 선형원본추가(원본, "\n"); 출력행 = 출력행 + 1; 출력열 = 0
315 }
316 while 출력열 < 원본시작스칼라열 {
317 선형원본추가(원본, " "); 출력열 = 출력열 + 1
318 }
319 } else if 출력행 == 보이는시작행 && 출력열 < 원본시작스칼라열 {
320 while 출력열 < 원본시작스칼라열 {
321 선형원본추가(원본, " "); 출력열 = 출력열 + 1
322 }
323 } else if 출력행 == 보이는시작행 && (구분필요 || 접힌댓글뒤구분) {
324 선형원본추가(원본, " "); 출력열 = 출력열 + 1
325 }
326 선형원본추가(원본, 토큰)
327 접힌댓글뒤구분 = false
328 let 출력위치 = 본문위치전진(13, 출력행, 출력열, 토큰)
329 출력행 = 출력위치[0]
330 출력열 = 출력위치[1]
331 }
332 이전끝행 = 끝행
333 이전끝열 = 끝열
334 이전끝스칼라열 = 원본끝스칼라열
335 이전있음 = true
336 토큰색인 = 토큰색인 + 1
337 }
338 선형원본끝공백제거(원본)
339 선형원본추가(원본, "\n")
340 Ok(선형원본평평하게(원본))

SHA256 cd14cdf68a6a9794eb5c4dab2d41df66709e61fa6fe60ddb02a082ed142b94e5