codeimage.io

STUDIO HAZE · image

Topaz source

Open by house policy. Topaz is our own language.

Topaz 5.21 · 113 files

topaz/src/printers/lispex.tpz

Topaz · 16805 B · Original file

1// Lispex structure validation and canonical source printing.
3import nodes { 노드종류 }
4import printer_common { 오브젝티브씨잎앞섬 }
5import printer_cursor { 러스트열폭, 본문위치전진 }
6import printer_text { 선형원본만들기, 선형원본추가, 선형원본평평하게 }
7import structure { 구조노드, 구조스칼라, 구조입력, 구조입력검사, 노드스칼라, 스칼라문자, 스칼라있음 }
9function 리스펙스정수스칼라검사(노드: 구조노드, 필드: string) -> Result<int, string> {
10 let 값 = 노드스칼라(노드, 필드)
11 if 값.필드 == "" || 값.태그 != 3 || 값.정수값 < 0 {
12 return Err("Lispex 구조 정수 스칼라가 정규형이 아닙니다: {필드}")
13 }
14 Ok(값.정수값)
17function 리스펙스가지코드(코드워드: int) -> bool {
18 코드워드 == 53 || 코드워드 == 132 || 코드워드 == 211 ||
19 코드워드 == 290 || 코드워드 == 369 || 코드워드 == 448
22function 리스펙스접두코드(코드워드: int) -> bool {
23 코드워드 == 410 || 코드워드 == 489 || 코드워드 == 56 || 코드워드 == 135
26export function 리스펙스인쇄구조검사(구조: 구조입력) -> Result<bool, string> {
27 구조입력검사(29, 구조)?
28 if 구조.노드들.length == 0 {
29 return Err("Lispex 인쇄 구조에 source_file 노드가 필요합니다")
30 }
31 if 구조.노드들[0].코드워드 != 53 ||
32 구조.노드들[0].부모순번 != -1 || 구조.노드들[0].자식필드있음 ||
33 구조.노드들[0].자식필드 != "" || 구조.노드들[0].자식색인 != -1 ||
34 구조.노드들[0].시작 != 0 {
35 return Err("Lispex 인쇄 구조 뿌리가 source_file 노드가 아닙니다")
36 }
37 let mut 자식수들: Array<int> = []
38 let mut 비댓글수들: Array<int> = []
39 let mut 첫비댓글코드들: Array<int> = []
40 let mut 마지막비댓글코드들: Array<int> = []
41 let mut 점수들: Array<int> = []
42 let mut 점전자료수들: Array<int> = []
43 let mut 점후자료수들: Array<int> = []
44 let mut 순번 = 0
45 while 순번 < 구조.노드들.length {
46 자식수들.push(0)
47 비댓글수들.push(0)
48 첫비댓글코드들.push(-1)
49 마지막비댓글코드들.push(-1)
50 점수들.push(0)
51 점전자료수들.push(0)
52 점후자료수들.push(0)
53 순번 = 순번 + 1
54 }
55 let mut 분리본문발생수 = 0
56 순번 = 0
57 while 순번 < 구조.노드들.length {
58 let 노드 = 구조.노드들[순번]
59 if 노드종류(29, 노드.코드워드) == 0 {
60 return Err("Lispex 투영 인쇄기가 지원하지 않는 노드입니다: 순번 {순번}, 코드 {노드.코드워드}")
61 }
62 if 순번 > 0 {
63 if 노드.부모순번 < 0 || 노드.부모순번 >= 순번 ||
64 !노드.자식필드있음 || 노드.자식필드 == "" || 노드.자식색인 < 0 {
65 return Err("Lispex 인쇄 구조의 부모 또는 자식 위치가 정규형이 아닙니다: 순번 {순번}")
66 }
67 let 부모 = 구조.노드들[노드.부모순번]
68 if !리스펙스가지코드(부모.코드워드) {
69 return Err("Lispex 잎 노드가 자식을 가집니다: 순번 {순번}")
70 }
71 let 부모자식수 = 리스펙스정수스칼라검사(부모, "childCount")?
72 if 노드.자식색인 != 자식수들[노드.부모순번] || 노드.자식색인 >= 부모자식수 {
73 return Err("Lispex 자식 색인이 정규 순서나 부모 자식 수와 다릅니다: 순번 {순번}")
74 }
75 let 자식필드맞음 =
76 (부모.코드워드 == 53 && 노드.자식필드 == "forms") ||
77 (부모.코드워드 == 448 && 노드.자식색인 == 0 && 노드.자식필드 == "operator") ||
78 (부모.코드워드 == 448 && 노드.코드워드 == 334 && 노드.자식색인 > 0 && 노드.자식필드 == "atmosphere") ||
79 (부모.코드워드 == 448 && 노드.코드워드 != 334 && 노드.자식색인 > 0 && 노드.자식필드 == "argument") ||
80 ((부모.코드워드 == 132 || 부모.코드워드 == 211 ||
81 부모.코드워드 == 290 || 부모.코드워드 == 369) && 노드.자식필드 == "elements")
82 if !자식필드맞음 {
83 return Err("Lispex 자식 필드가 부모 노드 종류와 다릅니다: 순번 {순번}")
84 }
85 if 노드.시작 < 부모.시작 || 노드.끝 > 부모.끝 {
86 return Err("Lispex 자식 원본 범위가 부모를 벗어납니다: 순번 {순번}")
87 }
88 if 부모.코드워드 == 132 || 부모.코드워드 == 211 {
89 if 노드.자식색인 == 0 && 노드.코드워드 != 15 {
90 return Err("Lispex 목록의 여는 괄호가 없습니다: 순번 {순번}")
91 }
92 if 노드.자식색인 == 부모자식수 - 1 && 노드.코드워드 != 94 {
93 return Err("Lispex 목록의 닫는 괄호가 없습니다: 순번 {순번}")
94 }
95 }
96 if 부모.코드워드 == 290 {
97 if 노드.자식색인 == 0 && 노드.코드워드 != 173 {
98 return Err("Lispex 벡터의 여는 토큰이 없습니다: 순번 {순번}")
99 }
100 if 노드.자식색인 == 부모자식수 - 1 && 노드.코드워드 != 94 {
101 return Err("Lispex 벡터의 닫는 괄호가 없습니다: 순번 {순번}")
102 }
103 }
104 if 부모.코드워드 == 369 {
105 if 노드.자식색인 == 0 && 노드.코드워드 != 252 {
106 return Err("Lispex 바이트벡터의 여는 토큰이 없습니다: 순번 {순번}")
107 }
108 if 노드.자식색인 == 부모자식수 - 1 && 노드.코드워드 != 94 {
109 return Err("Lispex 바이트벡터의 닫는 괄호가 없습니다: 순번 {순번}")
110 }
111 if 노드.자식색인 > 0 && 노드.자식색인 < 부모자식수 - 1 &&
112 노드.코드워드 != 176 && 노드.코드워드 != 334 {
113 return Err("Lispex 바이트벡터에 바이트가 아닌 원소가 있습니다: 순번 {순번}")
114 }
115 }
116 자식수들[노드.부모순번] = 자식수들[노드.부모순번] + 1
117 if 노드.코드워드 != 334 {
118 if 첫비댓글코드들[노드.부모순번] < 0 {
119 첫비댓글코드들[노드.부모순번] = 노드.코드워드
120 }
121 마지막비댓글코드들[노드.부모순번] = 노드.코드워드
122 비댓글수들[노드.부모순번] = 비댓글수들[노드.부모순번] + 1
123 if 노드.코드워드 == 331 {
124 점수들[노드.부모순번] = 점수들[노드.부모순번] + 1
125 } else if 노드.코드워드 != 15 && 노드.코드워드 != 94 &&
126 노드.코드워드 != 173 && 노드.코드워드 != 252 {
127 if 점수들[노드.부모순번] == 0 {
128 점전자료수들[노드.부모순번] = 점전자료수들[노드.부모순번] + 1
129 } else {
130 점후자료수들[노드.부모순번] = 점후자료수들[노드.부모순번] + 1
131 }
132 }
133 }
134 }
135 if 노드.시작 < 0 || 노드.끝 < 노드.시작 {
136 return Err("Lispex 인쇄 구조의 원본 범위가 틀립니다: 순번 {순번}")
137 }
138 let 자식수 = 리스펙스정수스칼라검사(노드, "childCount")?
139 let 시작행 = 리스펙스정수스칼라검사(노드, "startRow")?
140 let 시작열 = 리스펙스정수스칼라검사(노드, "startColumn")?
141 let 끝행 = 리스펙스정수스칼라검사(노드, "endRow")?
142 let 끝열 = 리스펙스정수스칼라검사(노드, "endColumn")?
143 if 끝행 < 시작행 || (끝행 == 시작행 && 끝열 < 시작열) {
144 return Err("Lispex 인쇄 구조의 원본 좌표가 틀립니다: 순번 {순번}")
145 }
146 if 노드.식별자있음 || 노드.식별자류번호 != 0 {
147 return Err("Lispex 이름은 모두 이미지에 있어야 합니다: 순번 {순번}")
148 }
149 if 노드.코드워드 == 334 {
150 if 자식수 != 0 || 스칼라있음(노드, "text") {
151 return Err("Lispex 댓글 원문은 분리 본문에만 있어야 합니다: 순번 {순번}")
152 }
153 분리본문발생수 = 분리본문발생수 + 1
154 } else if 노드.코드워드 == 255 &&
155 (!스칼라있음(노드, "text") || 노드스칼라(노드, "text").태그 != 5 ||
156 스칼라문자(노드, "text").scalars().length == 0) {
157 return Err("Lispex 이미지 symbol 이름이 정규형이 아닙니다: 순번 {순번}")
158 } else if 리스펙스가지코드(노드.코드워드) {
159 if 스칼라있음(노드, "text") {
160 return Err("Lispex 가지 노드에 토큰 원문이 있습니다: 순번 {순번}")
161 }
162 if 노드.코드워드 == 53 && 순번 != 0 {
163 return Err("Lispex source_file 노드는 뿌리에만 있어야 합니다")
164 }
165 } else if 자식수 != 0 || !스칼라있음(노드, "text") ||
166 노드스칼라(노드, "text").태그 != 5 {
167 return Err("Lispex 인쇄 토큰의 원문이 없습니다: 순번 {순번}")
168 }
169 순번 = 순번 + 1
170 }
171 순번 = 0
172 while 순번 < 구조.노드들.length {
173 let 노드 = 구조.노드들[순번]
174 if 리스펙스정수스칼라검사(노드, "childCount")? != 자식수들[순번] {
175 return Err("Lispex 노드 자식 수가 구조와 다릅니다: 순번 {순번}")
176 }
177 if 노드.코드워드 == 448 &&
178 (비댓글수들[순번] != 2 || !리스펙스접두코드(첫비댓글코드들[순번])) {
179 return Err("Lispex 접두 표현식 모양이 정규형이 아닙니다: 순번 {순번}")
180 }
181 if 노드.코드워드 == 132 &&
182 (첫비댓글코드들[순번] != 15 || 마지막비댓글코드들[순번] != 94 || 점수들[순번] != 0) {
183 return Err("Lispex 목록 모양이 정규형이 아닙니다: 순번 {순번}")
184 }
185 if 노드.코드워드 == 211 &&
186 (첫비댓글코드들[순번] != 15 || 마지막비댓글코드들[순번] != 94 ||
187 점수들[순번] != 1 || 점전자료수들[순번] < 1 || 점후자료수들[순번] != 1) {
188 return Err("Lispex 점 목록 모양이 정규형이 아닙니다: 순번 {순번}")
189 }
190 if 노드.코드워드 == 290 &&
191 (첫비댓글코드들[순번] != 173 || 마지막비댓글코드들[순번] != 94 || 점수들[순번] != 0) {
192 return Err("Lispex 벡터 모양이 정규형이 아닙니다: 순번 {순번}")
193 }
194 if 노드.코드워드 == 369 &&
195 (첫비댓글코드들[순번] != 252 || 마지막비댓글코드들[순번] != 94 || 점수들[순번] != 0) {
196 return Err("Lispex 바이트벡터 모양이 정규형이 아닙니다: 순번 {순번}")
197 }
198 순번 = 순번 + 1
199 }
200 if 구조.분리본문값수 < 0 || 구조.분리본문값수 != 분리본문발생수 {
201 return Err("Lispex 분리 본문 값 수가 댓글 발생 수와 맞지 않습니다")
202 }
203 Ok(true)
206function 리스펙스잎순번들(구조: 구조입력) -> Result<Array<int>, string> {
207 let mut 잎들: Array<int> = []
208 let mut 순번 = 1
209 while 순번 < 구조.노드들.length {
210 if 리스펙스정수스칼라검사(구조.노드들[순번], "childCount")? == 0 {
211 잎들.push(순번)
212 }
213 순번 = 순번 + 1
214 }
215 let mut 색인 = 1
216 while 색인 < 잎들.length {
217 let 값 = 잎들[색인]
218 let mut 자리 = 색인
219 while 자리 > 0 && 오브젝티브씨잎앞섬(구조, 값, 잎들[자리 - 1]) {
220 잎들[자리] = 잎들[자리 - 1]
221 자리 = 자리 - 1
222 }
223 잎들[자리] = 값
224 색인 = 색인 + 1
225 }
226 Ok(잎들)
229export function 리스펙스원본인쇄(구조: 구조입력) -> Result<string, string> {
230 리스펙스인쇄구조검사(구조)?
231 let 잎들 = 리스펙스잎순번들(구조)?
232 // `원본`은 실제 토큰 글자로만 자라므로 언제나 마지막으로 찍은 토큰에서
233 // 끝난다. 배치 공백은 커서만 움직이고 토큰을 찍는 자리에서 실체가 되니,
234 // 뒤에 토큰이 없는 채움 공백은 출력에 닿지 않는다. 줄 끝 채움은 다음 토큰의
235 // 열을 붙잡기 위해 있고 그 줄에 다음 토큰이 없으면 붙잡을 열이 없다.
236 // 커널 인쇄기와 같은 규칙이며, 끝을 잘라내지 않는 쪽이 규범이다. 잘라내기는
237 // 토큰 내용인 스칼라를 지울 수 있기 때문이다.
238 let 원본 = 선형원본만들기()
239 let mut 확정행 = 0
240 let mut 확정열 = 0
241 let mut 출력행 = 0
242 let mut 출력열 = 0
243 let mut 이전끝행 = 0
244 let mut 이전끝열 = 0
245 let mut 이전끝스칼라열 = 0
246 let mut 이전있음 = false
247 let mut 토큰색인 = 0
248 while 토큰색인 < 잎들.length {
249 let 순번 = 잎들[토큰색인]
250 let 노드 = 구조.노드들[순번]
251 let 시작행 = 리스펙스정수스칼라검사(노드, "startRow")?
252 let 시작열 = 리스펙스정수스칼라검사(노드, "startColumn")?
253 let 끝행 = 리스펙스정수스칼라검사(노드, "endRow")?
254 let 끝열 = 리스펙스정수스칼라검사(노드, "endColumn")?
255 let 대체폭 = if 시작행 == 끝행 { 끝열 - 시작열 } else { 끝열 }
256 let 생략댓글 = 노드.코드워드 == 334 && !스칼라있음(노드, "text")
257 let 토큰 = if 생략댓글 { "" } else { 스칼라문자(노드, "text") }
258 let 원본스칼라폭 = if 생략댓글 {
259 러스트열폭(노드, "comment", "Scalar", 대체폭)
260 } else {
261 본문위치전진(29, 0, 0, 토큰)[1]
262 }
263 let 같은원본행 = 이전있음 && 시작행 == 이전끝행
264 let 원본간격 = if 같은원본행 { 시작열 - 이전끝열 } else { 0 }
265 let 원본시작스칼라열 = if 같은원본행 {
266 if 원본간격 == 0 { 출력열 } else { 이전끝스칼라열 + 원본간격 }
267 } else { 시작열 }
268 let 원본끝스칼라열 = if 끝행 == 시작행 {
269 원본시작스칼라열 + 원본스칼라폭
270 } else { 원본스칼라폭 }
271 let 구분필요 = 이전있음 && 시작행 == 이전끝행 && 시작열 > 이전끝열
272 if 생략댓글 {
273 let 다음시작행 = if 토큰색인 + 1 < 잎들.length {
274 리스펙스정수스칼라검사(구조.노드들[잎들[토큰색인 + 1]], "startRow")?
275 } else { -1 }
276 let 온줄차지 = (!이전있음 || 시작행 > 이전끝행) &&
277 (다음시작행 < 0 || 다음시작행 > 끝행)
278 let 줄끝댓글 = 이전있음 && 시작행 == 이전끝행 &&
279 (다음시작행 < 0 || 다음시작행 > 끝행)
280 if 온줄차지 {
281 if 출력행 < 시작행 { 출력행 = 시작행; 출력열 = 0 }
282 if 출력행 < 끝행 { 출력행 = 끝행; 출력열 = 0 }
283 } else if 줄끝댓글 {
284 이전끝행 = 끝행
285 이전끝열 = 끝열
286 이전끝스칼라열 = 원본끝스칼라열
287 이전있음 = true
288 토큰색인 = 토큰색인 + 1
289 continue
290 } else {
291 if 출력행 < 시작행 {
292 출력행 = 시작행
293 출력열 = 원본시작스칼라열
294 } else if 출력행 == 시작행 && 출력열 < 원본시작스칼라열 {
295 출력열 = 원본시작스칼라열
296 } else if 출력행 == 시작행 && 구분필요 {
297 출력열 = 출력열 + 1
298 }
299 if 출력행 < 끝행 {
300 출력행 = 끝행
301 출력열 = 원본끝스칼라열
302 } else if 출력행 == 끝행 && 출력열 < 원본끝스칼라열 {
303 출력열 = 원본끝스칼라열
304 }
305 }
306 } else {
307 if 출력행 < 시작행 {
308 출력행 = 시작행
309 출력열 = 원본시작스칼라열
310 } else if 출력행 == 시작행 && 출력열 < 원본시작스칼라열 {
311 출력열 = 원본시작스칼라열
312 } else if 출력행 == 시작행 && 구분필요 {
313 출력열 = 출력열 + 1
314 }
315 if 출력행 > 확정행 {
316 let mut 남은줄 = 출력행 - 확정행
317 while 남은줄 > 0 { 선형원본추가(원본, "\n"); 남은줄 = 남은줄 - 1 }
318 let mut 첫칸 = 출력열
319 while 첫칸 > 0 { 선형원본추가(원본, " "); 첫칸 = 첫칸 - 1 }
320 } else {
321 if 출력열 < 확정열 { return Err("리스펙스 인쇄 배치 커서가 뒤로 갔습니다") }
322 let mut 남은칸 = 출력열 - 확정열
323 while 남은칸 > 0 { 선형원본추가(원본, " "); 남은칸 = 남은칸 - 1 }
324 }
325 선형원본추가(원본, 토큰)
326 let 출력위치 = 본문위치전진(29, 출력행, 출력열, 토큰)
327 출력행 = 출력위치[0]
328 출력열 = 출력위치[1]
329 확정행 = 출력행
330 확정열 = 출력열
331 }
332 이전끝행 = 끝행
333 이전끝열 = 끝열
334 이전끝스칼라열 = 원본끝스칼라열
335 이전있음 = true
336 토큰색인 = 토큰색인 + 1
337 }
338 선형원본추가(원본, "\n")
339 Ok(선형원본평평하게(원본))

SHA256 4406e422199f69b873c7ee80bdb65121ccfc0fd2f2656964f3abb210c32f32ea