codeimage.io

STUDIO HAZE · image

Topaz source

Open by house policy. Topaz is our own language.

Topaz 5.21 · 113 files

topaz/src/printers/c.tpz

Topaz · 15664 B · Original file

1// C 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("C 구조 정수 스칼라가 정규형이 아닙니다: {필드}")
15 }
16 Ok(값.정수값)
19function 씨전처리원문있음(노드: 구조노드) -> bool {
20 스칼라있음(노드, "preprocessorText")
23function 씨전처리원자(노드: 구조노드) -> bool {
24 씨전처리원문있음(노드) && 스칼라논리(노드, "preprocessorAtomic")
27export function 씨인쇄구조검사(구조: 구조입력) -> Result<bool, string> {
28 구조입력검사(7, 구조)?
29 if 구조.노드들.length == 0 {
30 return Err("C 인쇄 구조에 번역 단위 노드가 필요합니다")
31 }
32 if 구조.노드들[0].코드워드 != 289 ||
33 구조.노드들[0].부모순번 != -1 || 구조.노드들[0].자식필드있음 ||
34 구조.노드들[0].자식필드 != "" || 구조.노드들[0].자식색인 != -1 {
35 return Err("C 인쇄 구조 뿌리가 번역 단위 노드가 아닙니다")
36 }
37 let mut 자식수들: Array<int> = []
38 let mut 순번 = 0
39 while 순번 < 구조.노드들.length { 자식수들.push(0); 순번 = 순번 + 1 }
40 let mut 다음식별자류번호 = 0
41 let mut 분리본문발생수 = 0
42 let mut 이전시작 = 0
43 순번 = 0
44 while 순번 < 구조.노드들.length {
45 let 노드 = 구조.노드들[순번]
46 let 종류 = 노드종류(7, 노드.코드워드)
47 if 종류 == 0 {
48 return Err("C 투영 인쇄기가 지원하지 않는 노드입니다: 순번 {순번}, 코드 {노드.코드워드}")
49 }
50 if 순번 > 0 {
51 if 노드.부모순번 < 0 || 노드.부모순번 >= 순번 ||
52 !노드.자식필드있음 || 노드.자식필드 == "" || 노드.자식색인 < 0 {
53 return Err("C 인쇄 구조의 부모 또는 자식 위치가 정규형이 아닙니다: 순번 {순번}")
54 }
55 if 노드.시작 < 이전시작 {
56 return Err("C 인쇄 구조의 원본 순서가 정규형이 아닙니다: 순번 {순번}")
57 }
58 자식수들[노드.부모순번] = 자식수들[노드.부모순번] + 1
59 }
60 이전시작 = 노드.시작
61 if 노드.시작 < 0 || 노드.끝 < 노드.시작 {
62 return Err("C 인쇄 구조의 원본 범위가 틀립니다: 순번 {순번}")
63 }
64 let 자식수 = 씨정수스칼라검사(노드, "childCount")?
65 let 시작행 = 씨정수스칼라검사(노드, "startRow")?
66 let 시작열 = 씨정수스칼라검사(노드, "startColumn")?
67 let 끝행 = 씨정수스칼라검사(노드, "endRow")?
68 let 끝열 = 씨정수스칼라검사(노드, "endColumn")?
69 if 끝행 < 시작행 || (끝행 == 시작행 && 끝열 < 시작열) {
70 return Err("C 인쇄 구조의 원본 좌표가 틀립니다: 순번 {순번}")
71 }
72 if !스칼라있음(노드, "named") || !스칼라있음(노드, "extra") {
73 return Err("C 인쇄 구조의 노드 표지 스칼라가 없습니다: 순번 {순번}")
74 }
75 let 전처리원문 = 씨전처리원문있음(노드)
76 if 전처리원문 {
77 if 노드스칼라(노드, "preprocessorText").태그 != 5 ||
78 !스칼라있음(노드, "preprocessorAtomic") ||
79 (노드스칼라(노드, "preprocessorAtomic").태그 != 1 &&
80 노드스칼라(노드, "preprocessorAtomic").태그 != 2) {
81 return Err("C 전처리 원문 스칼라가 정규형이 아닙니다: 순번 {순번}")
82 }
83 if 씨전처리원자(노드) {
84 if 스칼라있음(노드, "preprocessorHeaderEndRow") ||
85 스칼라있음(노드, "preprocessorHeaderEndColumn") {
86 return Err("C 원자 전처리 원문에 머리 범위가 있습니다: 순번 {순번}")
87 }
88 } else {
89 let 머리끝행 = 씨정수스칼라검사(노드, "preprocessorHeaderEndRow")?
90 let 머리끝열 = 씨정수스칼라검사(노드, "preprocessorHeaderEndColumn")?
91 if 머리끝행 < 시작행 || (머리끝행 == 시작행 && 머리끝열 < 시작열) ||
92 머리끝행 > 끝행 || (머리끝행 == 끝행 && 머리끝열 > 끝열) {
93 return Err("C 전처리 머리 범위가 원본 범위를 벗어납니다: 순번 {순번}")
94 }
95 }
96 } else if 스칼라있음(노드, "preprocessorAtomic") {
97 return Err("C 전처리 원자 표지에 원문이 없습니다: 순번 {순번}")
98 }
99 if 종류 == 106 {
100 if 노드.식별자있음 {
101 if 스칼라있음(노드, "text") {
102 return Err("C 식별자 이름이 이미지와 분리 본문에 함께 있습니다")
103 }
104 if 노드.식별자류번호 < 0 || 노드.식별자류번호 > 다음식별자류번호 {
105 return Err("C 식별자 알파류가 첫 사용 정규형이 아닙니다: 순번 {순번}")
106 }
107 if 노드.식별자류번호 == 다음식별자류번호 {
108 다음식별자류번호 = 다음식별자류번호 + 1
109 }
110 분리본문발생수 = 분리본문발생수 + 1
111 } else {
112 if 노드.식별자류번호 != 0 || !스칼라있음(노드, "text") ||
113 노드스칼라(노드, "text").태그 != 5 {
114 return Err("C 이미지 식별자 이름이 정규형이 아닙니다: 순번 {순번}")
115 }
116 }
117 } else {
118 if 노드.식별자있음 || 노드.식별자류번호 != 0 {
119 return Err("C 식별자가 아닌 노드에 알파류가 있습니다: 순번 {순번}")
120 }
121 if 씨댓글코드(노드.코드워드) {
122 if 스칼라있음(노드, "text") {
123 return Err("C 댓글 원문은 분리 본문에만 있어야 합니다: 순번 {순번}")
124 }
125 분리본문발생수 = 분리본문발생수 + 1
126 } else if !전처리원문 && 자식수 == 0 {
127 if !스칼라있음(노드, "text") || 노드스칼라(노드, "text").태그 != 5 {
128 return Err("C 인쇄 토큰의 원문이 없습니다: 순번 {순번}")
129 }
130 }
131 }
132 순번 = 순번 + 1
133 }
134 순번 = 0
135 while 순번 < 구조.노드들.length {
136 if 씨정수스칼라검사(구조.노드들[순번], "childCount")? != 자식수들[순번] {
137 return Err("C 노드 자식 수가 구조와 다릅니다: 순번 {순번}")
138 }
139 순번 = 순번 + 1
140 }
141 if 구조.분리본문값수 < 0 || 구조.분리본문값수 != 분리본문발생수 {
142 return Err("C 분리 본문 값 수가 식별자와 댓글 발생 수에 맞지 않습니다")
143 }
144 Ok(true)
147function 씨전처리원자조상(구조: 구조입력, 순번: int) -> bool {
148 let mut 부모순번 = 구조.노드들[순번].부모순번
149 while 부모순번 >= 0 {
150 if 씨전처리원자(구조.노드들[부모순번]) { return true }
151 부모순번 = 구조.노드들[부모순번].부모순번
152 }
153 false
156function 씨전처리머리조상(구조: 구조입력, 순번: int) -> Result<bool, string> {
157 let 시작행 = 씨정수스칼라검사(구조.노드들[순번], "startRow")?
158 let 시작열 = 씨정수스칼라검사(구조.노드들[순번], "startColumn")?
159 let mut 부모순번 = 구조.노드들[순번].부모순번
160 while 부모순번 >= 0 {
161 let 부모 = 구조.노드들[부모순번]
162 if 씨전처리원문있음(부모) && !씨전처리원자(부모) {
163 let 머리끝행 = 씨정수스칼라검사(부모, "preprocessorHeaderEndRow")?
164 let 머리끝열 = 씨정수스칼라검사(부모, "preprocessorHeaderEndColumn")?
165 if 시작행 < 머리끝행 || (시작행 == 머리끝행 && 시작열 < 머리끝열) {
166 return Ok(true)
167 }
168 }
169 부모순번 = 부모.부모순번
170 }
171 Ok(false)
174function 씨원자본문코드(코드워드: int) -> bool {
175 코드워드 == 50 || 코드워드 == 298
178function 씨원자본문조상(구조: 구조입력, 순번: int) -> bool {
179 let mut 부모순번 = 구조.노드들[순번].부모순번
180 while 부모순번 >= 0 {
181 if 씨원자본문코드(구조.노드들[부모순번].코드워드) { return true }
182 부모순번 = 구조.노드들[부모순번].부모순번
183 }
184 false
187export function 씨원본인쇄(구조: 구조입력) -> Result<string, string> {
188 씨인쇄구조검사(구조)?
189 let 준비 = 인쇄상태만들기(7, 구조, [], [], false, false)
190 let 단독복귀배치 = 스칼라논리(구조.노드들[0], "loneCrLayout")
191 let 끝줄이음 = if 스칼라있음(구조.노드들[0], "eofLineSplice") {
192 스칼라문자(구조.노드들[0], "eofLineSplice")
193 } else { "" }
194 if 끝줄이음 != "" && 끝줄이음 != "\\\n" && 끝줄이음 != "\\\r" &&
195 끝줄이음 != "\\\r\n" && 끝줄이음 != "??/\n" &&
196 끝줄이음 != "??/\r" && 끝줄이음 != "??/\r\n" {
197 return Err("C 투영의 파일 끝 줄 이음이 잘못되었습니다")
198 }
199 let mut 토큰순번들: Array<int> = []
200 let mut 순번 = 0
201 while 순번 < 구조.노드들.length {
202 let 노드 = 구조.노드들[순번]
203 let 자식수 = 씨정수스칼라검사(노드, "childCount")?
204 if !씨전처리원자조상(구조, 순번) &&
205 !씨전처리머리조상(구조, 순번)? &&
206 !씨원자본문조상(구조, 순번) &&
207 (씨전처리원문있음(노드) || 씨원자본문코드(노드.코드워드) || 자식수 == 0) {
208 토큰순번들.push(순번)
209 }
210 순번 = 순번 + 1
211 }
212 let 원본 = 선형원본만들기()
213 let mut 출력행 = 0
214 let mut 출력열 = 0
215 let mut 이전끝행 = 0
216 let mut 이전끝열 = 0
217 let mut 이전끝스칼라열 = 0
218 let mut 이전있음 = false
219 let mut 토큰색인 = 0
220 while 토큰색인 < 토큰순번들.length {
221 순번 = 토큰순번들[토큰색인]
222 let 노드 = 구조.노드들[순번]
223 let 시작행 = 씨정수스칼라검사(노드, "startRow")?
224 let 시작열 = 씨정수스칼라검사(노드, "startColumn")?
225 let 끝행 = if 스칼라있음(노드, "preprocessorHeaderEndRow") {
226 씨정수스칼라검사(노드, "preprocessorHeaderEndRow")?
227 } else { 씨정수스칼라검사(노드, "endRow")? }
228 let 끝열 = if 스칼라있음(노드, "preprocessorHeaderEndColumn") {
229 씨정수스칼라검사(노드, "preprocessorHeaderEndColumn")?
230 } else { 씨정수스칼라검사(노드, "endColumn")? }
231 let 대체폭 = if 시작행 == 끝행 { 끝열 - 시작열 } else { 끝열 }
232 let 분리식별자 = 노드종류(7, 노드.코드워드) == 106 && 노드.식별자있음
233 let 생략댓글 = 씨댓글코드(노드.코드워드) && !스칼라있음(노드, "text")
234 let 행들여쓰기 = 러스트행들여쓰기(노드, 시작열)
235 let 토큰 = if 생략댓글 { "" } else if 씨전처리원문있음(노드) {
236 스칼라문자(노드, "preprocessorText")
237 } else if 노드종류(7, 노드.코드워드) == 106 {
238 식별자이름(준비, 순번)?
239 } else { 스칼라문자(노드, "text") }
240 let 원본스칼라폭 = if 분리식별자 {
241 러스트열폭(노드, "identifier", "Scalar", 대체폭)
242 } else if 생략댓글 {
243 러스트열폭(노드, "comment", "Scalar", 대체폭)
244 } else {
245 씨본문위치전진(단독복귀배치, 0, 0, 토큰)[1]
246 }
247 let 원본시작스칼라열 = if 이전있음 && 시작행 == 이전끝행 {
248 이전끝스칼라열 + 시작열 - 이전끝열
249 } else { 시작열 }
250 let 원본끝스칼라열 = if 끝행 == 시작행 {
251 원본시작스칼라열 + 원본스칼라폭
252 } else { 원본스칼라폭 }
253 let 구분필요 = 이전있음 && 시작행 == 이전끝행 && 시작열 > 이전끝열
254 if 생략댓글 {
255 let 다음시작행 = if 토큰색인 + 1 < 토큰순번들.length {
256 씨정수스칼라검사(
257 구조.노드들[토큰순번들[토큰색인 + 1]], "startRow"
258 )?
259 } else { -1 }
260 let 끝행에다음토큰없음 = 다음시작행 < 0 || 다음시작행 > 끝행
261 if 끝행에다음토큰없음 {
262 while 출력행 < 끝행 {
263 선형원본추가(원본, "\n"); 출력행 = 출력행 + 1; 출력열 = 0
264 }
265 } else {
266 if 출력행 < 시작행 {
267 while 출력행 < 시작행 {
268 선형원본추가(원본, "\n"); 출력행 = 출력행 + 1; 출력열 = 0
269 }
270 선형원본추가(원본, 행들여쓰기)
271 출력열 = 행들여쓰기.scalars().length
272 while 출력열 < 원본시작스칼라열 {
273 선형원본추가(원본, " "); 출력열 = 출력열 + 1
274 }
275 } else if 출력행 == 시작행 && 단독복귀배치 {
276 if 구분필요 { 선형원본추가(원본, " "); 출력열 = 출력열 + 1 }
277 } else if 출력행 == 시작행 && 출력열 < 원본시작스칼라열 {
278 while 출력열 < 원본시작스칼라열 {
279 선형원본추가(원본, " "); 출력열 = 출력열 + 1
280 }
281 } else if 출력행 == 시작행 && 구분필요 {
282 선형원본추가(원본, " "); 출력열 = 출력열 + 1
283 }
284 if 출력행 < 끝행 {
285 while 출력행 < 끝행 {
286 선형원본추가(원본, "\n"); 출력행 = 출력행 + 1; 출력열 = 0
287 }
288 while 출력열 < 원본끝스칼라열 {
289 선형원본추가(원본, " "); 출력열 = 출력열 + 1
290 }
291 } else if 출력행 == 끝행 && 출력열 < 원본끝스칼라열 {
292 while 출력열 < 원본끝스칼라열 {
293 선형원본추가(원본, " "); 출력열 = 출력열 + 1
294 }
295 }
296 }
297 } else {
298 if 출력행 < 시작행 {
299 while 출력행 < 시작행 {
300 선형원본추가(원본, "\n"); 출력행 = 출력행 + 1; 출력열 = 0
301 }
302 선형원본추가(원본, 행들여쓰기)
303 출력열 = 행들여쓰기.scalars().length
304 while 출력열 < 원본시작스칼라열 {
305 선형원본추가(원본, " "); 출력열 = 출력열 + 1
306 }
307 } else if 출력행 == 시작행 && 단독복귀배치 {
308 if 구분필요 { 선형원본추가(원본, " "); 출력열 = 출력열 + 1 }
309 } else if 출력행 == 시작행 && 출력열 < 원본시작스칼라열 {
310 while 출력열 < 원본시작스칼라열 {
311 선형원본추가(원본, " "); 출력열 = 출력열 + 1
312 }
313 } else if 출력행 == 시작행 && 구분필요 {
314 선형원본추가(원본, " "); 출력열 = 출력열 + 1
315 }
316 선형원본추가(원본, 토큰)
317 let 출력위치 = 씨본문위치전진(단독복귀배치, 출력행, 출력열, 토큰)
318 출력행 = 출력위치[0]
319 출력열 = 출력위치[1]
320 }
321 이전끝행 = 끝행
322 이전끝열 = 끝열
323 이전끝스칼라열 = 원본끝스칼라열
324 이전있음 = true
325 토큰색인 = 토큰색인 + 1
326 }
327 선형원본끝공백제거(원본)
328 선형원본추가(원본, "\n")
329 if 끝줄이음 != "" { 선형원본추가(원본, 끝줄이음) }
330 Ok(선형원본평평하게(원본))

SHA256 189cf16259196270ca8554ca1785fae8c62133a66752a1982287a667b5375b0b