codeimage.io

STUDIO HAZE · image

Topaz source

Open by house policy. Topaz is our own language.

Topaz 5.21 · 113 files

topaz/src/printers/scala.tpz

Topaz · 16526 B · Original file

1// Scala structure validation and canonical source printing.
3import names { 익명할당계획이름들 }
4import names.scala { 스칼라감싼식별자인가, 스칼라감싼식별자자식인가 }
5import nodes { 노드종류 }
6import printer_common { 선행가로배치인가 }
7import printer_cursor { 러스트열폭, 러스트행들여쓰기, 본문위치전진 }
8import printer_setup { 인쇄상태만들기, 인쇄상태익명이름들바꾸기 }
9import printer_state { 식별자이름 }
10import printer_text { 선형원본만들기, 선형원본줄끝인가, 선형원본추가, 선형원본평평하게 }
11import schema { 스칼라댓글코드, 스칼라원자본문코드 }
12import structure { 구조노드, 구조스칼라, 구조입력, 구조입력검사, 노드스칼라, 스칼라문자, 스칼라있음 }
14function 스칼라정수스칼라검사(노드: 구조노드, 필드: string) -> Result<int, string> {
15 let 값 = 노드스칼라(노드, 필드)
16 if 값.필드 == "" || 값.태그 != 3 || 값.정수값 < 0 {
17 return Err("Scala 구조 정수 스칼라가 정규형이 아닙니다: {필드}")
18 }
19 Ok(값.정수값)
22export function 스칼라인쇄구조검사(구조: 구조입력) -> Result<bool, string> {
23 구조입력검사(14, 구조)?
24 if 구조.노드들.length == 0 {
25 return Err("Scala 인쇄 구조에 컴파일 단위 노드가 필요합니다")
26 }
27 if 구조.노드들[0].코드워드 != 157 ||
28 구조.노드들[0].부모순번 != -1 || 구조.노드들[0].자식필드있음 ||
29 구조.노드들[0].자식필드 != "" || 구조.노드들[0].자식색인 != -1 {
30 return Err("Scala 인쇄 구조 뿌리가 컴파일 단위 노드가 아닙니다")
31 }
32 let mut 자식수들: Array<int> = []
33 let mut 순번 = 0
34 while 순번 < 구조.노드들.length { 자식수들.push(0); 순번 = 순번 + 1 }
35 let mut 분리본문발생수 = 0
36 let mut 다음식별자류번호 = 0
37 순번 = 0
38 while 순번 < 구조.노드들.length {
39 let 노드 = 구조.노드들[순번]
40 if 노드종류(14, 노드.코드워드) == 0 {
41 return Err("Scala 투영 인쇄기가 지원하지 않는 노드입니다: 순번 {순번}, 코드 {노드.코드워드}")
42 }
43 if 순번 > 0 {
44 if 노드.부모순번 < 0 || 노드.부모순번 >= 순번 ||
45 !노드.자식필드있음 || 노드.자식필드 == "" || 노드.자식색인 < 0 {
46 return Err("Scala 인쇄 구조의 부모 또는 자식 위치가 정규형이 아닙니다: 순번 {순번}")
47 }
48 자식수들[노드.부모순번] = 자식수들[노드.부모순번] + 1
49 }
50 if 노드.시작 < 0 || 노드.끝 < 노드.시작 {
51 return Err("Scala 인쇄 구조의 원본 범위가 틀립니다: 순번 {순번}")
52 }
53 let 자식수 = 스칼라정수스칼라검사(노드, "childCount")?
54 let 시작행 = 스칼라정수스칼라검사(노드, "startRow")?
55 let 시작열 = 스칼라정수스칼라검사(노드, "startColumn")?
56 let 끝행 = 스칼라정수스칼라검사(노드, "endRow")?
57 let 끝열 = 스칼라정수스칼라검사(노드, "endColumn")?
58 if 끝행 < 시작행 || (끝행 == 시작행 && 끝열 < 시작열) {
59 return Err("Scala 인쇄 구조의 원본 좌표가 틀립니다: 순번 {순번}")
60 }
61 if !스칼라있음(노드, "named") || !스칼라있음(노드, "extra") {
62 return Err("Scala 인쇄 구조의 노드 표지 스칼라가 없습니다: 순번 {순번}")
63 }
64 if 스칼라있음(노드, "sourceBom") {
65 return Err("Scala 구조에 허용되지 않는 원본 BOM 표지가 있습니다: 순번 {순번}")
66 }
67 if 스칼라있음(노드, "leadingHorizontalLayout") &&
68 (!선행가로배치인가(노드, false, true) ||
69 !(자식수 == 0 || 스칼라원자본문코드(노드.코드워드) ||
70 스칼라감싼식별자인가(구조, 순번))) {
71 return Err("Scala 선행 가로 배치가 정규형이 아닙니다: 순번 {순번}")
72 }
73 if 노드.코드워드 == 416 && (자식수 == 0 || 스칼라감싼식별자인가(구조, 순번)) {
74 if 노드.식별자있음 {
75 if 스칼라있음(노드, "text") {
76 return Err("Scala 식별자 이름이 이미지와 분리 본문에 함께 있습니다")
77 }
78 if 노드.식별자류번호 < 0 || 노드.식별자류번호 > 다음식별자류번호 {
79 return Err("Scala 식별자 알파류가 첫 사용 정규형이 아닙니다: 순번 {순번}")
80 }
81 if 노드.식별자류번호 == 다음식별자류번호 {
82 다음식별자류번호 = 다음식별자류번호 + 1
83 }
84 분리본문발생수 = 분리본문발생수 + 1
85 } else if 노드.식별자류번호 != 0 || !스칼라있음(노드, "text") ||
86 노드스칼라(노드, "text").태그 != 5 {
87 return Err("Scala 이미지 식별자 이름이 정규형이 아닙니다: 순번 {순번}")
88 }
89 } else {
90 if 노드.식별자있음 || 노드.식별자류번호 != 0 {
91 return Err("Scala 식별자가 아닌 노드에 알파류가 있습니다: 순번 {순번}")
92 }
93 if 스칼라댓글코드(노드.코드워드) {
94 if 스칼라있음(노드, "text") {
95 return Err("Scala 댓글 원문은 분리 본문에만 있어야 합니다: 순번 {순번}")
96 }
97 분리본문발생수 = 분리본문발생수 + 1
98 } else if 스칼라감싼식별자자식인가(구조, 순번) {
99 if 스칼라있음(노드, "text") {
100 return Err("Scala 감싼 식별자 자식에 중복 토큰 원문이 있습니다: 순번 {순번}")
101 }
102 } else if 자식수 == 0 || 스칼라원자본문코드(노드.코드워드) {
103 if !스칼라있음(노드, "text") || 노드스칼라(노드, "text").태그 != 5 {
104 return Err("Scala 인쇄 토큰의 원문이 없습니다: 순번 {순번}")
105 }
106 } else if 스칼라있음(노드, "text") {
107 return Err("Scala 가지 노드에 토큰 원문이 있습니다: 순번 {순번}")
108 }
109 }
110 순번 = 순번 + 1
111 }
112 순번 = 0
113 while 순번 < 구조.노드들.length {
114 if 스칼라정수스칼라검사(구조.노드들[순번], "childCount")? != 자식수들[순번] {
115 return Err("Scala 노드 자식 수가 구조와 다릅니다: 순번 {순번}")
116 }
117 순번 = 순번 + 1
118 }
119 if 구조.분리본문값수 < 0 || 구조.분리본문값수 != 분리본문발생수 {
120 return Err("Scala 분리 본문 값 수가 식별자와 댓글 발생 수에 맞지 않습니다")
121 }
122 Ok(true)
125function 스칼라잎앞섬(구조: 구조입력, 왼쪽: int, 오른쪽: int) -> bool {
126 let 왼쪽노드 = 구조.노드들[왼쪽]
127 let 오른쪽노드 = 구조.노드들[오른쪽]
128 if 왼쪽노드.시작 != 오른쪽노드.시작 {
129 return 왼쪽노드.시작 < 오른쪽노드.시작
130 }
131 if 왼쪽노드.끝 != 오른쪽노드.끝 {
132 return 왼쪽노드.끝 < 오른쪽노드.끝
133 }
134 왼쪽 < 오른쪽
137function 스칼라잎순번들(구조: 구조입력) -> Result<Array<int>, string> {
138 let mut 잎들: Array<int> = []
139 let mut 순번 = 0
140 while 순번 < 구조.노드들.length {
141 let 노드 = 구조.노드들[순번]
142 let mut 부모순번 = 노드.부모순번
143 let mut 원자본문조상있음 = false
144 while 부모순번 >= 0 {
145 if 스칼라원자본문코드(구조.노드들[부모순번].코드워드) ||
146 스칼라감싼식별자인가(구조, 부모순번) {
147 원자본문조상있음 = true
148 부모순번 = -1
149 } else {
150 부모순번 = 구조.노드들[부모순번].부모순번
151 }
152 }
153 if !원자본문조상있음 &&
154 (스칼라원자본문코드(노드.코드워드) || 스칼라감싼식별자인가(구조, 순번) ||
155 스칼라정수스칼라검사(노드, "childCount")? == 0) {
156 잎들.push(순번)
157 }
158 순번 = 순번 + 1
159 }
160 let mut 색인 = 1
161 while 색인 < 잎들.length {
162 let 값 = 잎들[색인]
163 let mut 자리 = 색인
164 while 자리 > 0 && 스칼라잎앞섬(구조, 값, 잎들[자리 - 1]) {
165 잎들[자리] = 잎들[자리 - 1]
166 자리 = 자리 - 1
167 }
168 잎들[자리] = 값
169 색인 = 색인 + 1
170 }
171 Ok(잎들)
174export function 스칼라원본인쇄(구조: 구조입력) -> Result<string, string> {
175 스칼라인쇄구조검사(구조)?
176 let 기본준비 = 인쇄상태만들기(14, 구조, [], [], false, false)
177 let 준비 = 인쇄상태익명이름들바꾸기(기본준비, 익명할당계획이름들(기본준비)?)
178 let 잎들 = 스칼라잎순번들(구조)?
179 let mut 다음보이는행들: Array<int> = []
180 let mut 채움 = 0
181 while 채움 < 잎들.length { 다음보이는행들.push(-1); 채움 = 채움 + 1 }
182 let mut 다음보이는행 = -1
183 let mut 역색인 = 잎들.length
184 while 역색인 > 0 {
185 역색인 = 역색인 - 1
186 다음보이는행들[역색인] = 다음보이는행
187 let 역노드 = 구조.노드들[잎들[역색인]]
188 let 역생략댓글 = 스칼라댓글코드(역노드.코드워드) && !스칼라있음(역노드, "text")
189 if !역생략댓글 {
190 다음보이는행 = 스칼라정수스칼라검사(역노드, "startRow")?
191 }
192 }
193 // Every source row an omitted comment occupies. A carried run is in-line
194 // whitespace whose role the Scala scanner reads off the whole row it stands
195 // in, so it is emitted only into a row this mode prints unchanged. Keyed
196 // decode prints every comment and therefore every run; image-only decode
197 // prints no comment, and on a row it has emptied the same scalar is read as
198 // that row's first or last content instead of as a gap between two tokens.
199 let mut 최대행 = 0
200 let mut 행훑기 = 0
201 while 행훑기 < 잎들.length {
202 let 행노드 = 구조.노드들[잎들[행훑기]]
203 let 행끝 = 스칼라정수스칼라검사(행노드, "endRow")?
204 if 행끝 > 최대행 { 최대행 = 행끝 }
205 행훑기 = 행훑기 + 1
206 }
207 let mut 생략댓글행들: Array<bool> = []
208 let mut 행채움 = 0
209 while 행채움 <= 최대행 { 생략댓글행들.push(false); 행채움 = 행채움 + 1 }
210 let mut 댓글훑기 = 0
211 while 댓글훑기 < 잎들.length {
212 let 댓글노드 = 구조.노드들[잎들[댓글훑기]]
213 if 스칼라댓글코드(댓글노드.코드워드) && !스칼라있음(댓글노드, "text") {
214 let 댓글시작행 = 스칼라정수스칼라검사(댓글노드, "startRow")?
215 let 댓글끝행 = 스칼라정수스칼라검사(댓글노드, "endRow")?
216 let mut 댓글행 = 댓글시작행
217 while 댓글행 <= 댓글끝행 {
218 if 댓글행 >= 0 && 댓글행 < 생략댓글행들.length {
219 생략댓글행들[댓글행] = true
220 }
221 댓글행 = 댓글행 + 1
222 }
223 }
224 댓글훑기 = 댓글훑기 + 1
225 }
226 let 원본 = 선형원본만들기()
227 let mut 출력행 = 0
228 let mut 출력열 = 0
229 let mut 이전끝행 = 0
230 let mut 이전끝열 = 0
231 let mut 이전끝스칼라열 = 0
232 let mut 이전있음 = false
233 let mut 생략행조정 = 0
234 let mut 생략행조정끝행 = -1
235 let mut 토큰색인 = 0
236 while 토큰색인 < 잎들.length {
237 let 순번 = 잎들[토큰색인]
238 let 노드 = 구조.노드들[순번]
239 let 시작행 = 스칼라정수스칼라검사(노드, "startRow")?
240 let 시작열 = 스칼라정수스칼라검사(노드, "startColumn")?
241 let 끝행 = 스칼라정수스칼라검사(노드, "endRow")?
242 let 끝열 = 스칼라정수스칼라검사(노드, "endColumn")?
243 let 대체폭 = if 시작행 == 끝행 { 끝열 - 시작열 } else { 끝열 }
244 let 식별자노드 = 노드.코드워드 == 416 &&
245 (스칼라정수스칼라검사(노드, "childCount")? == 0 || 스칼라감싼식별자인가(구조, 순번))
246 let 분리식별자 = 식별자노드 && 노드.식별자있음
247 let 생략댓글 = 스칼라댓글코드(노드.코드워드) && !스칼라있음(노드, "text")
248 let 토큰 = if 생략댓글 { "" } else if 식별자노드 {
249 식별자이름(준비, 순번)?
250 } else { 스칼라문자(노드, "text") }
251 let 원본스칼라폭 = if 분리식별자 {
252 러스트열폭(노드, "identifier", "Scalar", 대체폭)
253 } else if 생략댓글 {
254 러스트열폭(노드, "comment", "Scalar", 대체폭)
255 } else {
256 본문위치전진(14, 0, 0, 토큰)[1]
257 }
258 let 원본시작스칼라열 = if 이전있음 && 시작행 == 이전끝행 {
259 이전끝스칼라열 + 시작열 - 이전끝열
260 } else { 시작열 }
261 let 원본끝스칼라열 = if 끝행 == 시작행 {
262 원본시작스칼라열 + 원본스칼라폭
263 } else { 원본스칼라폭 }
264 let 구분필요 = 이전있음 && 시작행 == 이전끝행 && 시작열 > 이전끝열
265 let 배치행비었음 = 시작행 < 0 || 시작행 >= 생략댓글행들.length ||
266 !생략댓글행들[시작행]
267 let 가로배치있음 = 스칼라있음(노드, "leadingHorizontalLayout") && 배치행비었음
268 if 가로배치있음 {
269 let 조정 = if 시작행 > 생략행조정끝행 { 0 } else { 생략행조정 }
270 let 실린시작행 = 시작행 - 조정
271 if 실린시작행 < 0 { return Err("Scala 투영의 보이는 행 배치가 잘못되었습니다") }
272 let 가로배치 = 스칼라문자(노드, "leadingHorizontalLayout")
273 let 가로크기 = 본문위치전진(14, 0, 0, 가로배치)
274 let 실은행수 = 가로크기[0]
275 let 꼬리폭 = 가로크기[1]
276 if 실은행수 == 0 {
277 let 실기전열 = if 원본시작스칼라열 > 꼬리폭 { 원본시작스칼라열 - 꼬리폭 } else { 0 }
278 while 출력행 < 실린시작행 {
279 선형원본추가(원본, "\n"); 출력행 = 출력행 + 1; 출력열 = 0
280 }
281 while 출력열 < 실기전열 {
282 선형원본추가(원본, " "); 출력열 = 출력열 + 1
283 }
284 } else {
285 while 출력행 + 실은행수 < 실린시작행 {
286 선형원본추가(원본, "\n"); 출력행 = 출력행 + 1; 출력열 = 0
287 }
288 }
289 선형원본추가(원본, 가로배치)
290 let 가로위치 = 본문위치전진(14, 출력행, 출력열, 가로배치)
291 출력행 = 가로위치[0]
292 출력열 = 가로위치[1]
293 if 출력행 != 실린시작행 {
294 return Err("Scala 실린 가로 배치가 기록된 행과 어긋납니다: 순번 {순번}")
295 }
296 }
297 if 생략댓글 {
298 let 다음행 = 다음보이는행들[토큰색인]
299 if 다음행 == 끝행 && 이전있음 && 시작행 == 이전끝행 && 끝행 > 시작행 {
300 let 바라는행 = 출력행 + 1
301 생략행조정 = 다음행 - 바라는행
302 생략행조정끝행 = 끝행
303 }
304 토큰색인 = 토큰색인 + 1
305 continue
306 } else {
307 if 시작행 > 생략행조정끝행 {
308 생략행조정 = 0
309 생략행조정끝행 = -1
310 }
311 let 출력시작행 = 시작행 - 생략행조정
312 if 출력시작행 < 0 { return Err("Scala 투영의 보이는 행 배치가 잘못되었습니다") }
313 let 행들여쓰기 = 러스트행들여쓰기(노드, 원본시작스칼라열)
314 if 출력행 < 출력시작행 {
315 while 출력행 < 출력시작행 {
316 선형원본추가(원본, "\n"); 출력행 = 출력행 + 1; 출력열 = 0
317 }
318 선형원본추가(원본, 행들여쓰기)
319 출력열 = 행들여쓰기.scalars().length
320 while 출력열 < 원본시작스칼라열 {
321 선형원본추가(원본, " "); 출력열 = 출력열 + 1
322 }
323 } else if 출력행 == 출력시작행 && 출력열 < 원본시작스칼라열 {
324 while 출력열 < 원본시작스칼라열 {
325 선형원본추가(원본, " "); 출력열 = 출력열 + 1
326 }
327 } else if 출력행 == 출력시작행 && 구분필요 && !가로배치있음 {
328 선형원본추가(원본, " "); 출력열 = 출력열 + 1
329 }
330 선형원본추가(원본, 토큰)
331 let 출력위치 = 본문위치전진(14, 출력행, 출력열, 토큰)
332 출력행 = 출력위치[0]
333 출력열 = 출력위치[1]
334 }
335 이전끝행 = 끝행
336 이전끝열 = 끝열
337 이전끝스칼라열 = 원본끝스칼라열
338 이전있음 = true
339 토큰색인 = 토큰색인 + 1
340 }
341 if !선형원본줄끝인가(원본) { 선형원본추가(원본, "\n") }
342 Ok(선형원본평평하게(원본))

SHA256 d5eb5bd96230634f8215ff653045cf895a0d6740b120f783d3e20f80c7441073