codeimage.io

STUDIO HAZE · image

Topaz source

Open by house policy. Topaz is our own language.

Topaz 5.21 · 113 files

topaz/src/printers/r.tpz

Topaz · 15351 B · Original file

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

SHA256 33a8d59a867cc189934fce9e4e258574b0778ccad23484365cc074eefe1f1825