codeimage.io

STUDIO HAZE · image

Topaz source

Open by house policy. Topaz is our own language.

Topaz 5.21 · 113 files

topaz/src/printers/elisp.tpz

Topaz · 13390 B · Original file

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

SHA256 089c91f364942497c5ddcd49930db8e2511b129f1154cee75f375f722e2df4aa