codeimage.io

STUDIO HAZE · image

Topaz source

Open by house policy. Topaz is our own language.

Topaz 5.21 · 113 files

topaz/src/printer_setup.tpz

Topaz · 20247 B · Original file

1// Printer state construction: child links, comment tables, and anonymous
2// identifier names.
4import names { 러스트짧은이름, 익명이름예약 }
5import names.ascii { 아스키이름들 }
6import names.c { 씨전처리예약이름들 }
7import names.coffeescript { 커피스크립트보간이름들 }
8import names.elisp { 이맥스리습인턴이름 }
9import names.java { 자바정규식별자 }
10import names.kotlin { 코틀린정규식별자 }
11import names.objc { 오브젝티브씨전처리이름들, 오브젝티브씨정규식별자 }
12import names.python { 파이썬후보가제안만듦 }
13import names.ruby { 루비정규식캡처이름들 }
14import names.rust { 러스트정규식별자 }
15import names.scala { 스칼라감싼식별자인가, 스칼라정규식별자 }
16import nodes { 노드종류 }
17import print { 댓글코드, 인쇄조각판만들기 }
18import printer_state { 고정식별자이름, 준비된인쇄상태 }
19import structure { 구조노드, 구조입력, 스칼라문자, 스칼라있음, 스칼라정수 }
20import types { 댓글고정 }
21import util { 문자열배열에있음 }
23function 구조조상코드있음(구조: 구조입력, 순번: int, 코드워드: int) -> bool {
24 let mut 부모 = 구조.노드들[순번].부모순번
25 while 부모 >= 0 {
26 if 구조.노드들[부모].코드워드 == 코드워드 { return true }
27 부모 = 구조.노드들[부모].부모순번
28 }
29 false
32function 구조자식필드있음(
33 구조: 구조입력,
34 부모순번: int,
35 필드: string
36) -> bool {
37 for 노드 in 구조.노드들 {
38 if 노드.부모순번 == 부모순번 && 노드.자식필드있음 &&
39 노드.자식필드 == 필드 {
40 return true
41 }
42 }
43 false
46export function 인쇄상태만들기(
47 언어번호: int,
48 구조: 구조입력,
49 값들: Array<string>,
50 댓글고정들: Array<댓글고정>,
51 소비추적: bool,
52 오프셋배치: bool
53) -> 준비된인쇄상태 {
54 let mut 첫자식들: Array<int> = []
55 let mut 다음형제들: Array<int> = []
56 let mut 마지막자식들: Array<int> = []
57 let mut 본문색인들: Array<int> = []
58 let mut 소비자식들: Array<bool> = []
59 let mut 인머리들: Array<bool> = []
60 let mut 기계저장세대들: Array<int> = []
61 let mut 기계저장깊이들: Array<int> = []
62 let mut 기계저장상태들: Array<int> = []
63 let mut 기계저장조각들: Array<int> = []
64 let mut 기계저장오류들: Array<string> = []
65 let mut 보존이름들: Array<string> = []
66 let mut 파이썬보이는이름들: Array<string> = []
67 let mut 댓글시작들: Array<int> = []
68 let mut 댓글끝들: Array<int> = []
69 let mut 댓글행들: Array<int> = []
70 let mut 댓글바이트누적들: Array<int> = [0]
71 let mut 줄댓글수누적들: Array<int> = [0]
72 let mut 영상댓글누적추가행들: Array<int> = []
73 let mut 식별자류수 = 0
74 let mut 순번 = 0
75 while 순번 < 구조.노드들.length {
76 첫자식들.push(-1); 다음형제들.push(-1); 마지막자식들.push(-1); 본문색인들.push(-1)
77 인머리들.push(false)
78 영상댓글누적추가행들.push(0)
79 if 소비추적 { 소비자식들.push(false) }
80 let mut 모드 = 0
81 while 모드 < 3 {
82 기계저장세대들.push(0); 기계저장깊이들.push(0)
83 기계저장상태들.push(0); 기계저장조각들.push(0); 기계저장오류들.push("")
84 모드 = 모드 + 1
85 }
86 순번 = 순번 + 1
87 }
88 let mut 값색인 = 0
89 순번 = 0
90 while 순번 < 구조.노드들.length {
91 let 노드 = 구조.노드들[순번]
92 if 노드.부모순번 >= 0 {
93 let 부모 = 노드.부모순번
94 if 첫자식들[부모] < 0 { 첫자식들[부모] = 순번 }
95 else { 다음형제들[마지막자식들[부모]] = 순번 }
96 마지막자식들[부모] = 순번
97 }
98 if 노드.식별자있음 || 댓글코드(언어번호, 노드.코드워드) { 본문색인들[순번] = 값색인; 값색인 = 값색인 + 1 }
99 if 노드.식별자있음 && 식별자류수 <= 노드.식별자류번호 {
100 식별자류수 = 노드.식별자류번호 + 1
101 }
102 let 종류 = 노드종류(언어번호, 노드.코드워드)
103 if 종류 == 119 || 종류 == 120 {
104 댓글시작들.push(노드.시작)
105 댓글끝들.push(노드.끝)
106 댓글행들.push(if 종류 == 120 { 스칼라정수(노드, "startRow") } else { -1 })
107 댓글바이트누적들.push(
108 댓글바이트누적들[댓글바이트누적들.length - 1] + 노드.끝 - 노드.시작
109 )
110 줄댓글수누적들.push(
111 줄댓글수누적들[줄댓글수누적들.length - 1] + (if 종류 == 120 { 1 } else { 0 })
112 )
113 }
114 if !노드.식별자있음 && (종류 == 106 || 종류 == 714 ||
115 (언어번호 == 12 && 노드.코드워드 == 419) ||
116 (언어번호 == 13 && 노드.코드워드 == 393 && 스칼라정수(노드, "childCount") == 0) ||
117 (언어번호 == 14 && 노드.코드워드 == 416 &&
118 (스칼라정수(노드, "childCount") == 0 || 스칼라감싼식별자인가(구조, 순번))) ||
119 (언어번호 == 15 && 노드.코드워드 == 90 && 스칼라정수(노드, "childCount") == 0) ||
120 (언어번호 == 16 && 노드.코드워드 == 418 && 스칼라정수(노드, "childCount") == 0) ||
121 (언어번호 == 17 && 노드.코드워드 == 139 && 스칼라정수(노드, "childCount") == 0) ||
122 (언어번호 == 18 && 노드.코드워드 == 340 && 스칼라정수(노드, "childCount") == 0) ||
123 (언어번호 == 19 && 노드.코드워드 == 190 && 스칼라정수(노드, "childCount") == 0) ||
124 (언어번호 == 20 && 노드.코드워드 == 214 && 스칼라정수(노드, "childCount") == 0) ||
125 (언어번호 == 21 && (노드.코드워드 == 109 || 노드.코드워드 == 269) && 스칼라정수(노드, "childCount") == 0) ||
126 (언어번호 == 22 && 노드.코드워드 == 419 && 스칼라정수(노드, "childCount") == 0) ||
127 (언어번호 == 23 && 노드.코드워드 == 8 && 스칼라정수(노드, "childCount") == 0) ||
128 (언어번호 == 24 && 노드.코드워드 == 204 && 스칼라정수(노드, "childCount") == 0) ||
129 (언어번호 == 25 && 노드.코드워드 == 221 && 스칼라정수(노드, "childCount") == 0) ||
130 (언어번호 == 26 && 노드.코드워드 == 474 && 스칼라정수(노드, "childCount") == 0) ||
131 (언어번호 == 27 && 노드.코드워드 == 218 && 스칼라정수(노드, "childCount") == 0) ||
132 (언어번호 == 28 && 노드.코드워드 == 238 && 스칼라정수(노드, "childCount") == 0) ||
133 (언어번호 == 9 && 노드.코드워드 == 203) ||
134 (언어번호 == 4 && (노드.코드워드 == 150 || 노드.코드워드 == 208 ||
135 노드.코드워드 == 371 || 노드.코드워드 == 430 || 노드.코드워드 == 439))) {
136 let 원문이름 = 스칼라문자(노드, if 언어번호 == 3 || 언어번호 == 4 ||
137 언어번호 == 5 || 언어번호 == 6 || 언어번호 == 7 ||
138 언어번호 == 8 || 언어번호 == 9 || 언어번호 == 10 || 언어번호 == 11 || 언어번호 == 12 || 언어번호 == 13 || 언어번호 == 14 || 언어번호 == 15 || 언어번호 == 16 || 언어번호 == 17 || 언어번호 == 18 || 언어번호 == 19 || 언어번호 == 20 || 언어번호 == 21 || 언어번호 == 22 || 언어번호 == 23 || 언어번호 == 24 || 언어번호 == 25 || 언어번호 == 26 || 언어번호 == 27 || 언어번호 == 28 { "text" } else { "name" })
139 let 이름 = if 언어번호 == 3 && 종류 == 106 {
140 스칼라문자(노드, "pythonNfkcText")
141 } else { 원문이름 }
142 if 이름 != "" {
143 let 보존이름 = if 언어번호 == 5 { 러스트정규식별자(이름) }
144 else if 언어번호 == 6 { 자바정규식별자(이름) }
145 else if 언어번호 == 13 { 코틀린정규식별자(이름) }
146 else if 언어번호 == 14 { 스칼라정규식별자(이름) }
147 else if 언어번호 == 25 { 오브젝티브씨정규식별자(이름) }
148 else { 이름 }
149 if !문자열배열에있음(보존이름들, 보존이름) { 보존이름들.push(보존이름) }
150 if 언어번호 == 3 && !문자열배열에있음(파이썬보이는이름들, 이름) {
151 파이썬보이는이름들.push(이름)
152 }
153 }
154 }
155 if 언어번호 == 25 && 노드.코드워드 == 229 && 스칼라있음(노드, "text") {
156 for 이름 in 오브젝티브씨전처리이름들(스칼라문자(노드, "text")) {
157 if !문자열배열에있음(보존이름들, 이름) { 보존이름들.push(이름) }
158 }
159 }
160 if 언어번호 == 7 && 스칼라있음(노드, "preprocessorText") {
161 for 이름 in 씨전처리예약이름들(스칼라문자(노드, "preprocessorText")) {
162 if !문자열배열에있음(보존이름들, 이름) { 보존이름들.push(이름) }
163 }
164 }
165 if 언어번호 == 10 {
166 if 스칼라정수(노드, "childCount") == 0 &&
167 (노드.코드워드 == 119 || 구조조상코드있음(구조, 순번, 119)) {
168 for 이름 in 루비정규식캡처이름들(스칼라문자(노드, "text")) {
169 if !문자열배열에있음(보존이름들, 이름) { 보존이름들.push(이름) }
170 }
171 }
172 if 노드.코드워드 == 241 && 스칼라있음(노드, "text") &&
173 노드.부모순번 >= 0 {
174 let 부모 = 구조.노드들[노드.부모순번]
175 if 부모.코드워드 == 44 ||
176 (부모.코드워드 == 178 &&
177 !구조자식필드있음(구조, 노드.부모순번, "value")) {
178 let 이름 = 스칼라문자(노드, "text")
179 if !문자열배열에있음(보존이름들, 이름) { 보존이름들.push(이름) }
180 }
181 }
182 }
183 if 언어번호 == 24 && 스칼라있음(노드, "text") {
184 let mut 이름들: Array<string> = []
185 if 노드.코드워드 == 209 {
186 이름들 = 아스키이름들(스칼라문자(노드, "text"))
187 } else if 노드.코드워드 == 207 || 노드.코드워드 == 208 {
188 이름들 = 커피스크립트보간이름들(스칼라문자(노드, "text"))
189 }
190 for 이름 in 이름들 {
191 if !문자열배열에있음(보존이름들, 이름) { 보존이름들.push(이름) }
192 }
193 }
194 if 언어번호 == 26 && 노드.코드워드 == 474 && 스칼라있음(노드, "text") {
195 let 이름 = 이맥스리습인턴이름(스칼라문자(노드, "text"))
196 if !문자열배열에있음(보존이름들, 이름) { 보존이름들.push(이름) }
197 }
198 순번 = 순번 + 1
199 }
200 let mut 고정류들: Array<bool> = []
201 let mut 류 = 0
202 while 류 < 식별자류수 { 고정류들.push(false); 류 = 류 + 1 }
203 let mut 러스트최대폭들: Array<int> = []
204 류 = 0
205 while 류 < 식별자류수 { 러스트최대폭들.push(2147483647); 류 = 류 + 1 }
206 순번 = 0
207 while 순번 < 구조.노드들.length {
208 let 노드 = 구조.노드들[순번]
209 if 노드.식별자있음 && 고정식별자이름(언어번호, 구조, 순번) != "" {
210 고정류들[노드.식별자류번호] = true
211 }
212 if (언어번호 == 5 || 언어번호 == 6 || 언어번호 == 7 || 언어번호 == 8 || 언어번호 == 9 || 언어번호 == 10 || 언어번호 == 11 || 언어번호 == 12 || 언어번호 == 13 || 언어번호 == 14 || 언어번호 == 15 || 언어번호 == 16 || 언어번호 == 17 || 언어번호 == 18 || 언어번호 == 19 || 언어번호 == 20 || 언어번호 == 21 || 언어번호 == 22 || 언어번호 == 23 || 언어번호 == 24 || 언어번호 == 25 || 언어번호 == 26 || 언어번호 == 27 || 언어번호 == 28) && 노드.식별자있음 &&
213 스칼라정수(노드, "startRow") == 스칼라정수(노드, "endRow") {
214 let 폭 = if 스칼라있음(노드, "identifierScalarColumnSpan") {
215 스칼라정수(노드, "identifierScalarColumnSpan")
216 } else {
217 스칼라정수(노드, "endColumn") - 스칼라정수(노드, "startColumn")
218 }
219 if 폭 < 러스트최대폭들[노드.식별자류번호] {
220 러스트최대폭들[노드.식별자류번호] = 폭
221 }
222 }
223 순번 = 순번 + 1
224 }
225 let mut 익명이름들: Array<string> = []
226 let mut 다음이름번호 = 1
227 류 = 0
228 while 류 < 식별자류수 {
229 if 고정류들[류] { 익명이름들.push("") }
230 else {
231 let mut 후보 = "v" + "{다음이름번호}"
232 while 문자열배열에있음(보존이름들, 후보) ||
233 (언어번호 == 3 && 파이썬후보가제안만듦(후보, 파이썬보이는이름들)) ||
234 ((언어번호 == 5 || 언어번호 == 6 || 언어번호 == 7 || 언어번호 == 8 || 언어번호 == 9 || 언어번호 == 10 || 언어번호 == 11 || 언어번호 == 12 || 언어번호 == 13 || 언어번호 == 14 || 언어번호 == 15 || 언어번호 == 16 || 언어번호 == 17 || 언어번호 == 18 || 언어번호 == 19 || 언어번호 == 20 || 언어번호 == 21 || 언어번호 == 22 || 언어번호 == 23 || 언어번호 == 24 || 언어번호 == 25 || 언어번호 == 26 || 언어번호 == 27 || 언어번호 == 28) && 익명이름예약(언어번호, 후보)) {
235 다음이름번호 = 다음이름번호 + 1
236 후보 = "v" + "{다음이름번호}"
237 }
238 if (언어번호 == 5 || 언어번호 == 6 || 언어번호 == 7 || 언어번호 == 8 || 언어번호 == 9 || 언어번호 == 10 || 언어번호 == 11 || 언어번호 == 12 || 언어번호 == 13 || 언어번호 == 14 || 언어번호 == 15 || 언어번호 == 16 || 언어번호 == 17 || 언어번호 == 18 || 언어번호 == 19 || 언어번호 == 20 || 언어번호 == 21 || 언어번호 == 22 || 언어번호 == 23 || 언어번호 == 24 || 언어번호 == 25 || 언어번호 == 26 || 언어번호 == 27 || 언어번호 == 28) &&
239 후보.scalars().length > 러스트최대폭들[류] {
240 let 짧은이름 = 러스트짧은이름(
241 언어번호, 러스트최대폭들[류], 보존이름들
242 )
243 if 짧은이름 != "" { 후보 = 짧은이름 }
244 }
245 익명이름들.push(후보)
246 보존이름들.push(후보)
247 다음이름번호 = 다음이름번호 + 1
248 }
249 류 = 류 + 1
250 }
251 if 언어번호 == 2 {
252 let mut 부모순번 = 0
253 while 부모순번 < 구조.노드들.length {
254 let 부모 = 구조.노드들[부모순번]
255 let 부모종류 = 노드종류(언어번호, 부모.코드워드)
256 let 목록필드 = if 부모종류 == 511 { "consequent" }
257 else if 부모종류 == 102 || 부모종류 == 410 || 부모종류 == 603 ||
258 부모종류 == 609 || 부모종류 == 731 { "body" }
259 else { "" }
260 if 목록필드 != "" {
261 let mut 기준행 = 스칼라정수(부모, "startRow")
262 let mut 이전순번 = -1
263 let mut 누적추가행 = 0
264 let mut 자식 = 첫자식들[부모순번]
265 while 자식 >= 0 {
266 let 현재 = 구조.노드들[자식]
267 if 이전순번 < 0 &&
268 (현재.자식필드 == "directives" || 현재.자식필드 == "interpreter") {
269 기준행 = 스칼라정수(현재, "endRow")
270 }
271 if 현재.자식필드 == 목록필드 {
272 let 원본간격 = 스칼라정수(현재, "startRow") -
273 (if 이전순번 < 0 { 기준행 }
274 else { 스칼라정수(구조.노드들[이전순번], "endRow") })
275 let 보이는간격값 = 원본간격 - 누적추가행
276 let 보이는간격 = if 보이는간격값 < 0 { 0 } else { 보이는간격값 }
277 let 계획행 = 스칼라정수(현재, "emission.imageOnlyLeadingLineCommentRows")
278 let 출력간격 = if 보이는간격 > 계획행 { 보이는간격 } else { 계획행 }
279 누적추가행 = 누적추가행 + 출력간격 - 원본간격
280 영상댓글누적추가행들[자식] = 누적추가행
281 이전순번 = 자식
282 }
283 자식 = 다음형제들[자식]
284 }
285 }
286 부모순번 = 부모순번 + 1
287 }
288 }
289 준비된인쇄상태 {
290 언어번호: 언어번호, 오프셋배치: 오프셋배치, 구조: 구조, 본문값들: 값들,
291 첫자식들: 첫자식들, 다음형제들: 다음형제들, 본문색인들: 본문색인들,
292 익명이름들: 익명이름들,
293 댓글고정들: 댓글고정들,
294 댓글시작들: 댓글시작들,
295 댓글끝들: 댓글끝들,
296 댓글행들: 댓글행들,
297 댓글바이트누적들: 댓글바이트누적들,
298 줄댓글수누적들: 줄댓글수누적들,
299 영상댓글누적추가행들: 영상댓글누적추가행들,
300 소비자식들: 소비자식들,
301 인머리들: 인머리들,
302 조각판: 인쇄조각판만들기(),
303 기계활성들: [false], 기계세대들: [0],
304 기계필요모드들: [0], 기계필요순번들: [0], 기계필요깊이들: [0],
305 기계저장세대들: 기계저장세대들, 기계저장깊이들: 기계저장깊이들,
306 기계저장상태들: 기계저장상태들, 기계저장조각들: 기계저장조각들,
307 기계저장오류들: 기계저장오류들
308 }
311export function 인쇄상태조각판새로(준비: 준비된인쇄상태) -> 준비된인쇄상태 {
312 준비된인쇄상태 {
313 언어번호: 준비.언어번호,
314 오프셋배치: 준비.오프셋배치,
315 구조: 준비.구조,
316 본문값들: 준비.본문값들,
317 첫자식들: 준비.첫자식들,
318 다음형제들: 준비.다음형제들,
319 본문색인들: 준비.본문색인들,
320 익명이름들: 준비.익명이름들,
321 댓글고정들: 준비.댓글고정들,
322 댓글시작들: 준비.댓글시작들,
323 댓글끝들: 준비.댓글끝들,
324 댓글행들: 준비.댓글행들,
325 댓글바이트누적들: 준비.댓글바이트누적들,
326 줄댓글수누적들: 준비.줄댓글수누적들,
327 영상댓글누적추가행들: 준비.영상댓글누적추가행들,
328 소비자식들: 준비.소비자식들,
329 인머리들: 준비.인머리들,
330 조각판: 인쇄조각판만들기(),
331 기계활성들: 준비.기계활성들,
332 기계세대들: 준비.기계세대들,
333 기계필요모드들: 준비.기계필요모드들,
334 기계필요순번들: 준비.기계필요순번들,
335 기계필요깊이들: 준비.기계필요깊이들,
336 기계저장세대들: 준비.기계저장세대들,
337 기계저장깊이들: 준비.기계저장깊이들,
338 기계저장상태들: 준비.기계저장상태들,
339 기계저장조각들: 준비.기계저장조각들,
340 기계저장오류들: 준비.기계저장오류들
341 }
344export function 인쇄상태익명이름들바꾸기(
345 준비: 준비된인쇄상태,
346 익명이름들: Array<string>
347) -> 준비된인쇄상태 {
348 준비된인쇄상태 {
349 언어번호: 준비.언어번호,
350 오프셋배치: 준비.오프셋배치,
351 구조: 준비.구조,
352 본문값들: 준비.본문값들,
353 첫자식들: 준비.첫자식들,
354 다음형제들: 준비.다음형제들,
355 본문색인들: 준비.본문색인들,
356 익명이름들: 익명이름들,
357 댓글고정들: 준비.댓글고정들,
358 댓글시작들: 준비.댓글시작들,
359 댓글끝들: 준비.댓글끝들,
360 댓글행들: 준비.댓글행들,
361 댓글바이트누적들: 준비.댓글바이트누적들,
362 줄댓글수누적들: 준비.줄댓글수누적들,
363 영상댓글누적추가행들: 준비.영상댓글누적추가행들,
364 소비자식들: 준비.소비자식들,
365 인머리들: 준비.인머리들,
366 조각판: 준비.조각판,
367 기계활성들: 준비.기계활성들,
368 기계세대들: 준비.기계세대들,
369 기계필요모드들: 준비.기계필요모드들,
370 기계필요순번들: 준비.기계필요순번들,
371 기계필요깊이들: 준비.기계필요깊이들,
372 기계저장세대들: 준비.기계저장세대들,
373 기계저장깊이들: 준비.기계저장깊이들,
374 기계저장상태들: 준비.기계저장상태들,
375 기계저장조각들: 준비.기계저장조각들,
376 기계저장오류들: 준비.기계저장오류들
377 }

SHA256 e407a09e779f0e44da0e26c2feadb145fd77b29b712d5cc4c234174fc26aaf25