@sccharts-lab/engine 0.0.0-stage → 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (279) hide show
  1. package/LICENSE +277 -0
  2. package/README.md +125 -2
  3. package/dist/codegen/expr.d.ts +36 -0
  4. package/dist/codegen/expr.js +252 -0
  5. package/dist/codegen/expr.js.map +1 -0
  6. package/dist/codegen/index.d.ts +4 -0
  7. package/dist/codegen/index.js +238 -0
  8. package/dist/codegen/index.js.map +1 -0
  9. package/dist/codegen/layout.d.ts +57 -0
  10. package/dist/codegen/layout.js +306 -0
  11. package/dist/codegen/layout.js.map +1 -0
  12. package/dist/codegen/logic.d.ts +31 -0
  13. package/dist/codegen/logic.js +258 -0
  14. package/dist/codegen/logic.js.map +1 -0
  15. package/dist/codegen/methods.d.ts +17 -0
  16. package/dist/codegen/methods.js +242 -0
  17. package/dist/codegen/methods.js.map +1 -0
  18. package/dist/codegen/reset.d.ts +6 -0
  19. package/dist/codegen/reset.js +110 -0
  20. package/dist/codegen/reset.js.map +1 -0
  21. package/dist/codegen/types.d.ts +81 -0
  22. package/dist/codegen/types.js +3 -0
  23. package/dist/codegen/types.js.map +1 -0
  24. package/dist/format.d.ts +136 -0
  25. package/dist/format.js +872 -0
  26. package/dist/format.js.map +1 -0
  27. package/dist/index.d.ts +120 -0
  28. package/dist/index.js +507 -0
  29. package/dist/index.js.map +1 -0
  30. package/dist/internal.d.ts +1 -0
  31. package/dist/internal.js +4 -0
  32. package/dist/internal.js.map +1 -0
  33. package/dist/parser/ids.d.ts +4 -0
  34. package/dist/parser/ids.js +172 -0
  35. package/dist/parser/ids.js.map +1 -0
  36. package/dist/parser/imports.d.ts +2 -0
  37. package/dist/parser/imports.js +28 -0
  38. package/dist/parser/imports.js.map +1 -0
  39. package/dist/parser/interface.d.ts +10 -0
  40. package/dist/parser/interface.js +93 -0
  41. package/dist/parser/interface.js.map +1 -0
  42. package/dist/parser/kielerWording.d.ts +2 -0
  43. package/dist/parser/kielerWording.js +196 -0
  44. package/dist/parser/kielerWording.js.map +1 -0
  45. package/dist/parser/lexer.d.ts +25 -0
  46. package/dist/parser/lexer.js +334 -0
  47. package/dist/parser/lexer.js.map +1 -0
  48. package/dist/parser/parser.d.ts +29 -0
  49. package/dist/parser/parser.js +3249 -0
  50. package/dist/parser/parser.js.map +1 -0
  51. package/dist/parser/resolve.d.ts +46 -0
  52. package/dist/parser/resolve.js +919 -0
  53. package/dist/parser/resolve.js.map +1 -0
  54. package/dist/parser/source.d.ts +15 -0
  55. package/dist/parser/source.js +42 -0
  56. package/dist/parser/source.js.map +1 -0
  57. package/dist/parser/validate.d.ts +5 -0
  58. package/dist/parser/validate.js +1430 -0
  59. package/dist/parser/validate.js.map +1 -0
  60. package/dist/sim/abortRegions.d.ts +9 -0
  61. package/dist/sim/abortRegions.js +192 -0
  62. package/dist/sim/abortRegions.js.map +1 -0
  63. package/dist/sim/analysis.d.ts +113 -0
  64. package/dist/sim/analysis.js +1104 -0
  65. package/dist/sim/analysis.js.map +1 -0
  66. package/dist/sim/codegen.d.ts +30 -0
  67. package/dist/sim/codegen.js +730 -0
  68. package/dist/sim/codegen.js.map +1 -0
  69. package/dist/sim/compile.d.ts +43 -0
  70. package/dist/sim/compile.js +1062 -0
  71. package/dist/sim/compile.js.map +1 -0
  72. package/dist/sim/deps.d.ts +73 -0
  73. package/dist/sim/deps.js +481 -0
  74. package/dist/sim/deps.js.map +1 -0
  75. package/dist/sim/describe.d.ts +22 -0
  76. package/dist/sim/describe.js +272 -0
  77. package/dist/sim/describe.js.map +1 -0
  78. package/dist/sim/describePreemption.d.ts +22 -0
  79. package/dist/sim/describePreemption.js +90 -0
  80. package/dist/sim/describePreemption.js.map +1 -0
  81. package/dist/sim/describeStructure.d.ts +75 -0
  82. package/dist/sim/describeStructure.js +293 -0
  83. package/dist/sim/describeStructure.js.map +1 -0
  84. package/dist/sim/eval.d.ts +99 -0
  85. package/dist/sim/eval.js +644 -0
  86. package/dist/sim/eval.js.map +1 -0
  87. package/dist/sim/exec.d.ts +212 -0
  88. package/dist/sim/exec.js +874 -0
  89. package/dist/sim/exec.js.map +1 -0
  90. package/dist/sim/fold.d.ts +2 -0
  91. package/dist/sim/fold.js +40 -0
  92. package/dist/sim/fold.js.map +1 -0
  93. package/dist/sim/goblock.d.ts +16 -0
  94. package/dist/sim/goblock.js +171 -0
  95. package/dist/sim/goblock.js.map +1 -0
  96. package/dist/sim/guardIndices.d.ts +13 -0
  97. package/dist/sim/guardIndices.js +137 -0
  98. package/dist/sim/guardIndices.js.map +1 -0
  99. package/dist/sim/index.d.ts +43 -0
  100. package/dist/sim/index.js +138 -0
  101. package/dist/sim/index.js.map +1 -0
  102. package/dist/sim/lower.d.ts +33 -0
  103. package/dist/sim/lower.js +716 -0
  104. package/dist/sim/lower.js.map +1 -0
  105. package/dist/sim/memory.d.ts +47 -0
  106. package/dist/sim/memory.js +328 -0
  107. package/dist/sim/memory.js.map +1 -0
  108. package/dist/sim/model.d.ts +487 -0
  109. package/dist/sim/model.js +772 -0
  110. package/dist/sim/model.js.map +1 -0
  111. package/dist/sim/passes/abort.d.ts +2 -0
  112. package/dist/sim/passes/abort.js +269 -0
  113. package/dist/sim/passes/abort.js.map +1 -0
  114. package/dist/sim/passes/abortRegion.d.ts +10 -0
  115. package/dist/sim/passes/abortRegion.js +62 -0
  116. package/dist/sim/passes/abortRegion.js.map +1 -0
  117. package/dist/sim/passes/arrayAssignment.d.ts +2 -0
  118. package/dist/sim/passes/arrayAssignment.js +147 -0
  119. package/dist/sim/passes/arrayAssignment.js.map +1 -0
  120. package/dist/sim/passes/codeEffects.d.ts +2 -0
  121. package/dist/sim/passes/codeEffects.js +14 -0
  122. package/dist/sim/passes/codeEffects.js.map +1 -0
  123. package/dist/sim/passes/complexFinalState.d.ts +4 -0
  124. package/dist/sim/passes/complexFinalState.js +77 -0
  125. package/dist/sim/passes/complexFinalState.js.map +1 -0
  126. package/dist/sim/passes/connector.d.ts +2 -0
  127. package/dist/sim/passes/connector.js +18 -0
  128. package/dist/sim/passes/connector.js.map +1 -0
  129. package/dist/sim/passes/contained.d.ts +37 -0
  130. package/dist/sim/passes/contained.js +198 -0
  131. package/dist/sim/passes/contained.js.map +1 -0
  132. package/dist/sim/passes/context.d.ts +39 -0
  133. package/dist/sim/passes/context.js +3 -0
  134. package/dist/sim/passes/context.js.map +1 -0
  135. package/dist/sim/passes/countDelay.d.ts +2 -0
  136. package/dist/sim/passes/countDelay.js +51 -0
  137. package/dist/sim/passes/countDelay.js.map +1 -0
  138. package/dist/sim/passes/dataflow.d.ts +11 -0
  139. package/dist/sim/passes/dataflow.js +319 -0
  140. package/dist/sim/passes/dataflow.js.map +1 -0
  141. package/dist/sim/passes/deferred.d.ts +2 -0
  142. package/dist/sim/passes/deferred.js +345 -0
  143. package/dist/sim/passes/deferred.js.map +1 -0
  144. package/dist/sim/passes/detect.d.ts +10 -0
  145. package/dist/sim/passes/detect.js +33 -0
  146. package/dist/sim/passes/detect.js.map +1 -0
  147. package/dist/sim/passes/during.d.ts +2 -0
  148. package/dist/sim/passes/during.js +67 -0
  149. package/dist/sim/passes/during.js.map +1 -0
  150. package/dist/sim/passes/entry.d.ts +5 -0
  151. package/dist/sim/passes/entry.js +93 -0
  152. package/dist/sim/passes/entry.js.map +1 -0
  153. package/dist/sim/passes/enum.d.ts +2 -0
  154. package/dist/sim/passes/enum.js +22 -0
  155. package/dist/sim/passes/enum.js.map +1 -0
  156. package/dist/sim/passes/exit.d.ts +4 -0
  157. package/dist/sim/passes/exit.js +120 -0
  158. package/dist/sim/passes/exit.js.map +1 -0
  159. package/dist/sim/passes/finalRegion.d.ts +2 -0
  160. package/dist/sim/passes/finalRegion.js +21 -0
  161. package/dist/sim/passes/finalRegion.js.map +1 -0
  162. package/dist/sim/passes/followedBy.d.ts +2 -0
  163. package/dist/sim/passes/followedBy.js +78 -0
  164. package/dist/sim/passes/followedBy.js.map +1 -0
  165. package/dist/sim/passes/forRegion.d.ts +9 -0
  166. package/dist/sim/passes/forRegion.js +230 -0
  167. package/dist/sim/passes/forRegion.js.map +1 -0
  168. package/dist/sim/passes/history.d.ts +12 -0
  169. package/dist/sim/passes/history.js +115 -0
  170. package/dist/sim/passes/history.js.map +1 -0
  171. package/dist/sim/passes/hostCode.d.ts +2 -0
  172. package/dist/sim/passes/hostCode.js +152 -0
  173. package/dist/sim/passes/hostCode.js.map +1 -0
  174. package/dist/sim/passes/index.d.ts +4 -0
  175. package/dist/sim/passes/index.js +84 -0
  176. package/dist/sim/passes/index.js.map +1 -0
  177. package/dist/sim/passes/inheritance.d.ts +8 -0
  178. package/dist/sim/passes/inheritance.js +233 -0
  179. package/dist/sim/passes/inheritance.js.map +1 -0
  180. package/dist/sim/passes/initOperator.d.ts +2 -0
  181. package/dist/sim/passes/initOperator.js +68 -0
  182. package/dist/sim/passes/initOperator.js.map +1 -0
  183. package/dist/sim/passes/initialization.d.ts +2 -0
  184. package/dist/sim/passes/initialization.js +69 -0
  185. package/dist/sim/passes/initialization.js.map +1 -0
  186. package/dist/sim/passes/ode.d.ts +2 -0
  187. package/dist/sim/passes/ode.js +14 -0
  188. package/dist/sim/passes/ode.js.map +1 -0
  189. package/dist/sim/passes/period.d.ts +2 -0
  190. package/dist/sim/passes/period.js +106 -0
  191. package/dist/sim/passes/period.js.map +1 -0
  192. package/dist/sim/passes/prTransitions.d.ts +2 -0
  193. package/dist/sim/passes/prTransitions.js +12 -0
  194. package/dist/sim/passes/prTransitions.js.map +1 -0
  195. package/dist/sim/passes/pre.d.ts +4 -0
  196. package/dist/sim/passes/pre.js +326 -0
  197. package/dist/sim/passes/pre.js.map +1 -0
  198. package/dist/sim/passes/quirks.d.ts +2 -0
  199. package/dist/sim/passes/quirks.js +169 -0
  200. package/dist/sim/passes/quirks.js.map +1 -0
  201. package/dist/sim/passes/reference.d.ts +60 -0
  202. package/dist/sim/passes/reference.js +386 -0
  203. package/dist/sim/passes/reference.js.map +1 -0
  204. package/dist/sim/passes/regionActions.d.ts +2 -0
  205. package/dist/sim/passes/regionActions.js +56 -0
  206. package/dist/sim/passes/regionActions.js.map +1 -0
  207. package/dist/sim/passes/sequentialFollowedBy.d.ts +2 -0
  208. package/dist/sim/passes/sequentialFollowedBy.js +72 -0
  209. package/dist/sim/passes/sequentialFollowedBy.js.map +1 -0
  210. package/dist/sim/passes/signal.d.ts +2 -0
  211. package/dist/sim/passes/signal.js +230 -0
  212. package/dist/sim/passes/signal.js.map +1 -0
  213. package/dist/sim/passes/static.d.ts +5 -0
  214. package/dist/sim/passes/static.js +67 -0
  215. package/dist/sim/passes/static.js.map +1 -0
  216. package/dist/sim/passes/suspend.d.ts +10 -0
  217. package/dist/sim/passes/suspend.js +71 -0
  218. package/dist/sim/passes/suspend.js.map +1 -0
  219. package/dist/sim/passes/termination.d.ts +9 -0
  220. package/dist/sim/passes/termination.js +69 -0
  221. package/dist/sim/passes/termination.js.map +1 -0
  222. package/dist/sim/passes/timedAutomata.d.ts +10 -0
  223. package/dist/sim/passes/timedAutomata.js +437 -0
  224. package/dist/sim/passes/timedAutomata.js.map +1 -0
  225. package/dist/sim/passes/unpackClasses.d.ts +2 -0
  226. package/dist/sim/passes/unpackClasses.js +54 -0
  227. package/dist/sim/passes/unpackClasses.js.map +1 -0
  228. package/dist/sim/passes/userSchedule.d.ts +2 -0
  229. package/dist/sim/passes/userSchedule.js +43 -0
  230. package/dist/sim/passes/userSchedule.js.map +1 -0
  231. package/dist/sim/passes/weakSuspend.d.ts +2 -0
  232. package/dist/sim/passes/weakSuspend.js +145 -0
  233. package/dist/sim/passes/weakSuspend.js.map +1 -0
  234. package/dist/sim/preemptionLog.d.ts +41 -0
  235. package/dist/sim/preemptionLog.js +133 -0
  236. package/dist/sim/preemptionLog.js.map +1 -0
  237. package/dist/sim/random.d.ts +12 -0
  238. package/dist/sim/random.js +40 -0
  239. package/dist/sim/random.js.map +1 -0
  240. package/dist/sim/reasons.d.ts +29 -0
  241. package/dist/sim/reasons.js +168 -0
  242. package/dist/sim/reasons.js.map +1 -0
  243. package/dist/sim/scg.d.ts +124 -0
  244. package/dist/sim/scg.js +723 -0
  245. package/dist/sim/scg.js.map +1 -0
  246. package/dist/sim/sfr.d.ts +4 -0
  247. package/dist/sim/sfr.js +264 -0
  248. package/dist/sim/sfr.js.map +1 -0
  249. package/dist/sim/stringConditions.d.ts +3 -0
  250. package/dist/sim/stringConditions.js +42 -0
  251. package/dist/sim/stringConditions.js.map +1 -0
  252. package/dist/sim/structure/copy.d.ts +4 -0
  253. package/dist/sim/structure/copy.js +140 -0
  254. package/dist/sim/structure/copy.js.map +1 -0
  255. package/dist/sim/structure/delays.d.ts +30 -0
  256. package/dist/sim/structure/delays.js +127 -0
  257. package/dist/sim/structure/delays.js.map +1 -0
  258. package/dist/sim/structure/instance.d.ts +15 -0
  259. package/dist/sim/structure/instance.js +69 -0
  260. package/dist/sim/structure/instance.js.map +1 -0
  261. package/dist/sim/structure/methods.d.ts +19 -0
  262. package/dist/sim/structure/methods.js +550 -0
  263. package/dist/sim/structure/methods.js.map +1 -0
  264. package/dist/sim/structure/rewrite.d.ts +20 -0
  265. package/dist/sim/structure/rewrite.js +113 -0
  266. package/dist/sim/structure/rewrite.js.map +1 -0
  267. package/dist/sim/structure/track.d.ts +22 -0
  268. package/dist/sim/structure/track.js +123 -0
  269. package/dist/sim/structure/track.js.map +1 -0
  270. package/dist/sim/tracker.d.ts +77 -0
  271. package/dist/sim/tracker.js +265 -0
  272. package/dist/sim/tracker.js.map +1 -0
  273. package/dist/sim/values.d.ts +31 -0
  274. package/dist/sim/values.js +103 -0
  275. package/dist/sim/values.js.map +1 -0
  276. package/dist/types.d.ts +670 -0
  277. package/dist/types.js +9 -0
  278. package/dist/types.js.map +1 -0
  279. package/package.json +58 -3
@@ -0,0 +1,730 @@
1
+ // Charts KIELER accepts until its generated C code fails to compile in gcc (basics.md §10, concurrency.md R):
2
+ // the simulator rejects them too, with gcc's message in `kieler`.
3
+ import { allActionSites, allScopes, effectExprs, walkExpr } from "./model.js";
4
+ import { isInlined } from "./structure/methods.js";
5
+ import { KEYWORDS } from "../parser/lexer.js";
6
+ export const GCC_FAILED = 'Compiler did not return success (exit value != 0)';
7
+ /** C keywords: a top-level variable of that name breaks the generated C code (KIELER does not rename them). */
8
+ export const C_KEYWORDS = new Set([
9
+ 'auto', 'break', 'case', 'char', 'const', 'continue', 'default', 'do', 'double', 'else', 'enum', 'extern', 'float',
10
+ 'for', 'goto', 'if', 'inline', 'int', 'long', 'register', 'restrict', 'return', 'short', 'signed', 'sizeof', 'static',
11
+ 'struct', 'switch', 'typedef', 'union', 'unsigned', 'void', 'volatile', 'while', '_Bool', '_Complex', '_Imaginary',
12
+ '_Alignas', '_Alignof', '_Atomic', '_Generic', '_Noreturn', '_Static_assert', '_Thread_local',
13
+ ]);
14
+ /** gcc's first error for a top-level variable named after a C keyword, where it is not the usual one (probes
15
+ * rare/probe-c-keyword-*): type specifiers and qualifiers read as part of the declaration's type. */
16
+ function cKeywordError(name) {
17
+ if (name === 'char' || name === 'double')
18
+ return 'two or more data types in declaration specifiers';
19
+ if (name === 'union')
20
+ return 'expected ‘{’ before ‘;’ token';
21
+ if (name === 'volatile' || name === 'long' || name === 'short' || name === 'signed' || name === 'unsigned')
22
+ return `expected identifier before ‘${name}’`;
23
+ return `expected identifier or ‘(’ before ‘${name}’`;
24
+ }
25
+ export function checkCodegen(root) {
26
+ const out = [];
27
+ const seen = new Set();
28
+ const add = (d) => {
29
+ const key = `${d.code}:${d.span?.start ?? ''}:${d.message}`;
30
+ if (seen.has(key))
31
+ return;
32
+ seen.add(key);
33
+ out.push(d);
34
+ };
35
+ // Duplicate declarations at the top level become duplicate members of the C data struct (H-7).
36
+ const names = new Map();
37
+ for (const v of root.decls) {
38
+ if (v.const || v.declKind || v.generated)
39
+ continue;
40
+ if (C_KEYWORDS.has(v.name)) {
41
+ add({
42
+ severity: 'error', code: 'c-keyword', span: v.span,
43
+ message: `\`${v.name}\` is a keyword of C, so KIELER's generated C code cannot use it as a variable name`,
44
+ kieler: `${cKeywordError(v.name)}\n${GCC_FAILED}`,
45
+ hint: `Rename \`${v.name}\` (for example \`${v.name}Value\`).`,
46
+ related: v.decl ? [v.decl] : undefined,
47
+ });
48
+ }
49
+ names.set(v.name, (names.get(v.name) ?? 0) + 1);
50
+ if (names.get(v.name) === 2) {
51
+ add({
52
+ severity: 'error', code: 'duplicate-declaration', span: v.span,
53
+ message: `\`${v.name}\` is declared twice in the same scope`,
54
+ kieler: `duplicate member ‘${v.name}’\n${GCC_FAILED}`,
55
+ hint: 'Give each variable its own name (KIELER only warns "The variable is declared multiple times in this scope.", then its C compiler fails).',
56
+ related: v.decl ? [v.decl] : undefined,
57
+ });
58
+ }
59
+ }
60
+ // Names of KIELER's own: a chart-level variable named `_GO` or `_TERM` is a second member of that name in the tick
61
+ // data. One starting with `_g` (KIELER's guard prefix) that something writes, an initial value or an assignment,
62
+ // is dropped with the guards KIELER finds unused (CleanupValuedObjects) while the write still names it: unless a
63
+ // trigger tests it (a read in an effect is optimised away first, and `_g0`, KIELER's own first guard, goes
64
+ // whatever reads it). Inputs, signals, and `_g` variables nothing writes are fine (probes
65
+ // tests/engine/kieler/codegen/probe-reserved-*).
66
+ const written = new Set();
67
+ const tested = new Set();
68
+ for (const site of allActionSites(root)) {
69
+ const holder = site.transition ?? site.action;
70
+ for (const f of holder.effects)
71
+ if (f.k === 'assign')
72
+ written.add(f.ref.v);
73
+ walkExpr(holder.trigger, x => { if (x.k === 'ref')
74
+ tested.add(x.v); });
75
+ }
76
+ for (const v of root.decls) {
77
+ // A signal is a variable by now (the Signal processor ran): its presence keeps role 'presence'.
78
+ if (v.const || v.declKind || v.generated || v.signal || v.role === 'presence')
79
+ continue;
80
+ if (v.name === '_GO' || v.name === '_TERM') {
81
+ add({
82
+ severity: 'error', code: 'c-reserved-name', span: v.span,
83
+ message: `\`${v.name}\` is a name KIELER's generated C code uses for itself, so a variable of that name does not compile`,
84
+ kieler: `duplicate member ‘${v.name}’\n${GCC_FAILED}`,
85
+ hint: `Rename \`${v.name}\` (names starting with \`_\` are best left to KIELER).`,
86
+ related: v.decl ? [v.decl] : undefined,
87
+ });
88
+ }
89
+ else if (v.name.startsWith('_g') && !v.input && (v.init !== undefined || written.has(v)) && (v.name === '_g0' || !tested.has(v))) {
90
+ add({
91
+ severity: 'error', code: 'c-reserved-name', span: v.span,
92
+ message: `\`${v.name}\` starts with \`_g\`, the prefix of KIELER's guard variables: KIELER drops it from its generated C code, which still writes it, so the code does not compile`,
93
+ kieler: `‘TickData’ has no member named ‘${v.name}’\n${GCC_FAILED}`,
94
+ hint: `Rename \`${v.name}\` (names starting with \`_\` are best left to KIELER).`,
95
+ related: v.decl ? [v.decl] : undefined,
96
+ });
97
+ }
98
+ }
99
+ out.push(...cNames(root));
100
+ for (const d of cText(root))
101
+ add(d);
102
+ // A method's array parameter is a single int in KIELER's C code (`int p`): a method the chart calls whose body
103
+ // subscripts one does not compile. Never called, or given an array it does not subscript, it compiles (probes
104
+ // tests/engine/kieler/codegen/probe-method-array-param*).
105
+ for (const m of reachingC(root).called) {
106
+ const method = m.method;
107
+ const arrays = new Set(method.params.filter(p => p.dims.length));
108
+ if (!arrays.size)
109
+ continue;
110
+ let subscripted;
111
+ for (const e of bodyExprs(method.body))
112
+ walkExpr(e, x => { if (!subscripted && x.k === 'ref' && arrays.has(x.v) && x.idx.length)
113
+ subscripted = x.v; });
114
+ if (!subscripted)
115
+ continue;
116
+ const name = m.member ? m.member.name : m.name;
117
+ add({
118
+ severity: 'error', code: 'method-array-parameter', span: subscripted.span ?? m.span,
119
+ message: `KIELER's C code for the method \`${name}\` does not compile: its parameter \`${subscripted.name}\` is an array, which KIELER's C declares as a single int`,
120
+ kieler: `subscripted value is neither array nor pointer nor vector\n${GCC_FAILED}`,
121
+ hint: `Give \`${name}\` the elements it needs as separate parameters, or let it read the chart's array directly instead of a parameter.`,
122
+ related: m.decl ? [m.decl] : undefined,
123
+ });
124
+ }
125
+ // A method with parameters and an empty body: KIELER's C code still refers to the first parameter as a member of
126
+ // its tick data (probes structure/probe-empty-method-*).
127
+ for (const scope of allScopes(root)) {
128
+ for (const v of scope.decls) {
129
+ const m = v.method;
130
+ if (v.declKind !== 'method' || !m || !m.params.length || m.body.length || m.locals.length)
131
+ continue;
132
+ const name = v.member ? v.member.name : v.name;
133
+ add({
134
+ severity: 'error', code: 'empty-method', span: v.span,
135
+ message: `KIELER's C code for the method \`${name}\` does not compile: it has a parameter but no statements`,
136
+ kieler: `‘TickData’ has no member named ‘${m.params[0].name}’\n${GCC_FAILED}`,
137
+ hint: `KIELER's code generator fails on a method whose body is empty when it has parameters. Give \`${name}\` a statement, or leave out its parameters while it does nothing.`,
138
+ related: v.decl ? [v.decl] : undefined,
139
+ });
140
+ }
141
+ }
142
+ // A for loop whose counter is not declared in its head (`for (i = 0; ...)` with a chart variable i): KIELER's C
143
+ // code does not declare it (conformance structure/146).
144
+ for (const scope of allScopes(root)) {
145
+ for (const v of scope.decls) {
146
+ const m = v.method;
147
+ if (v.declKind !== 'method' || !m)
148
+ continue;
149
+ const local = new Set([...m.params, ...m.locals]);
150
+ const visit = (list) => {
151
+ for (const st of list) {
152
+ if (st.k === 'for') {
153
+ for (const init of st.init) {
154
+ if (init.k !== 'do' || init.f.k !== 'assign' || local.has(init.f.ref.v))
155
+ continue;
156
+ const counter = init.f.ref.v;
157
+ add({
158
+ severity: 'error', code: 'for-outer-counter', span: st.span ?? init.f.o.span,
159
+ message: `The loop counter \`${counter.display ?? counter.name}\` is a variable of the chart, which KIELER's C code for the loop does not declare`,
160
+ kieler: `\u2018${counter.name}\u2019 undeclared (first use in this function)\n${GCC_FAILED}`,
161
+ hint: `Declare the counter in the loop head, \`for (int j = 0; ...)\`, and assign the chart variable inside the loop if you need its value.`,
162
+ related: v.decl ? [v.decl] : undefined,
163
+ });
164
+ }
165
+ visit(st.body);
166
+ }
167
+ else if (st.k === 'if') {
168
+ visit(st.then);
169
+ if (st.else)
170
+ visit(st.else);
171
+ }
172
+ else if (st.k === 'while')
173
+ visit(st.body);
174
+ }
175
+ };
176
+ visit(m.body);
177
+ }
178
+ }
179
+ for (const site of allActionSites(root)) {
180
+ const holder = site.transition ?? site.action;
181
+ const by = holder.origin ?? holder.about;
182
+ const related = by ? [by] : undefined;
183
+ const exprs = holder.trigger ? [holder.trigger] : [];
184
+ for (const f of holder.effects) {
185
+ exprs.push(...effectExprs(f));
186
+ if (f.k === 'assign') {
187
+ if (f.op === '>>>=') {
188
+ add({
189
+ severity: 'error', code: 'unsigned-shift', span: f.o.span, related,
190
+ message: 'C has no >>>= operator, so KIELER\'s generated code does not compile',
191
+ kieler: `expected expression before ‘>=’ token\n${GCC_FAILED}`,
192
+ hint: 'Use `>>=` instead (an arithmetic shift).',
193
+ });
194
+ }
195
+ let target = f.ref;
196
+ while (target.sub)
197
+ target = target.sub;
198
+ const v = target.v;
199
+ if (v.dims.length > target.idx.length && f.expr && f.expr.k !== 'vector') {
200
+ add({
201
+ severity: 'error', code: 'array-assignment', span: f.o.span, related,
202
+ message: `\`${v.display ?? v.name}\` is an array: it cannot be assigned as a whole`,
203
+ kieler: `assignment to expression with array type\n${GCC_FAILED}`,
204
+ hint: `Assign the elements one by one (\`${v.name}[0] = ...\`, \`${v.name}[1] = ...\`) or with a vector, \`${v.name} = {...}\`.`,
205
+ });
206
+ }
207
+ if (f.expr?.k === 'ignore') {
208
+ add({
209
+ severity: 'error', code: 'vector-ignore', span: f.expr.span ?? f.o.span, related,
210
+ message: 'The ignore value _ in a vector assignment does not work in KIELER',
211
+ kieler: `‘_’ undeclared (first use in this function)\n${GCC_FAILED}`,
212
+ hint: 'Assign the elements you want to change one by one instead.',
213
+ });
214
+ }
215
+ }
216
+ }
217
+ for (const e of exprs) {
218
+ walkExpr(e, x => {
219
+ if (x.k !== 'op')
220
+ return;
221
+ if (x.op === '>>>') {
222
+ add({
223
+ severity: 'error', code: 'unsigned-shift', span: x.span, related,
224
+ message: 'C has no >>> operator, so KIELER\'s generated code does not compile',
225
+ kieler: `expected expression before ‘>’ token\n${GCC_FAILED}`,
226
+ hint: 'Use >> instead (an arithmetic shift, which keeps the sign).',
227
+ });
228
+ }
229
+ if (x.op === 'val') {
230
+ add({
231
+ severity: 'error', code: 'val-not-signal', span: x.span, related,
232
+ message: '`val()` only works directly on a valued signal: `val(pre(V))`, `val(S)` of a pure signal and `val(x)` of a variable do not compile',
233
+ kieler: `implicit declaration of function ‘val’ [-Wimplicit-function-declaration]\n${GCC_FAILED}`,
234
+ hint: 'For last tick\'s value of a valued signal write `pre(val(V))`.',
235
+ });
236
+ }
237
+ if ((x.op === '+' || x.op === '-' || x.op === '*' || x.op === '/' || x.op === '%') && x.args.some(isString)) {
238
+ add({
239
+ severity: 'error', code: 'string-arithmetic', span: x.span, related,
240
+ message: 'Strings cannot be joined or calculated with: KIELER\'s strings are C char pointers',
241
+ kieler: `invalid operands to binary ${x.op} (have ‘char *’ and ‘char *’)\n${GCC_FAILED}`,
242
+ hint: 'Use separate string variables, or numbers, instead of building strings.',
243
+ });
244
+ }
245
+ });
246
+ }
247
+ }
248
+ return out;
249
+ }
250
+ /**
251
+ * Names with a prime (`x'`) or an escape caret (`^max`): KIELER's grammar takes them (a valued object's name is a
252
+ * PrimeID, kept as written), but its C code uses the name as it is, and gcc fails (probes rare/probe-prime-*,
253
+ * rare/probe-caret-*). It concerns what reaches C: variables and signals at any level, class and struct members, the
254
+ * parameters and locals of a method that is called, and the name of a called method that is not inlined (with a
255
+ * prime only: a caret in a method name compiles). Constants (inlined), states and regions (the caret is dropped;
256
+ * a prime is a syntax error there) are fine.
257
+ */
258
+ function cNames(root) {
259
+ const out = [];
260
+ const prime = (name) => name.includes("'");
261
+ const caret = (name) => name.startsWith('^');
262
+ const report = (v, name, what, gcc) => {
263
+ const isPrime = prime(name);
264
+ out.push({
265
+ severity: 'error', code: 'c-name', span: v.span, related: v.decl ? [v.decl] : undefined,
266
+ message: isPrime
267
+ ? `The ${what} \`${name}\` has a prime in its name: KIELER accepts it, but its C code cannot use the name, so it does not compile`
268
+ : `The ${what} \`${name}\` keeps its \`^\` in KIELER's C code, which does not compile`,
269
+ kieler: gcc ? `${gcc}\n${GCC_FAILED}` : GCC_FAILED,
270
+ hint: isPrime
271
+ ? `C names cannot contain \`'\`. Rename it, for example \`${name.replace(/'/g, '') || 'x'}2\`.`
272
+ : KEYWORDS.has(name.slice(1))
273
+ ? `A \`^\` lets a keyword be a name in SCTX, but a ${what} keeps it in C, where it is not allowed. Choose a name that is not a keyword, for example \`${name.slice(1)}Value\` (a state or region may keep its \`^\`).`
274
+ : `A \`^\` lets a keyword be a name in SCTX, but a ${what} keeps it in C, where it is not allowed. \`${name.slice(1)}\` is not a keyword: write it without the \`^\`.`,
275
+ });
276
+ };
277
+ const PRIME_GCC = "missing terminating ' character";
278
+ const { called } = reachingC(root);
279
+ for (const scope of allScopes(root)) {
280
+ for (const v of scope.decls) {
281
+ if (v.const || v.generated)
282
+ continue;
283
+ if (v.declKind === 'method') {
284
+ const m = v.method;
285
+ if (!m || !called.has(v))
286
+ continue;
287
+ const name = v.member ? v.member.name : v.name;
288
+ if (prime(name) && !isInlined(m))
289
+ report(v, name, 'method', PRIME_GCC);
290
+ // A C function with a caret name compiles in KIELER 1.6.1 (only the 2024 extension 0.3.0 failed, S-71).
291
+ for (const p of [...m.params, ...m.locals]) {
292
+ const local = m.locals.includes(p);
293
+ if (prime(p.name))
294
+ report(p, p.name, local ? 'local variable' : 'parameter', PRIME_GCC);
295
+ // An inlined method's parameters and locals become variables of the chart (with a prefix); a C
296
+ // function's locals are its own.
297
+ else if (caret(p.name))
298
+ report(p, p.name, local ? 'local variable' : 'parameter', isInlined(m)
299
+ ? 'expected ‘:’, ‘,’, ‘;’, ‘}’ or ‘__attribute__’ before ‘^’ token'
300
+ : local ? 'expected identifier or ‘(’ before ‘^’ token' : undefined);
301
+ }
302
+ continue;
303
+ }
304
+ if (v.declKind)
305
+ continue;
306
+ const name = v.member ? v.member.name : v.name;
307
+ const what = v.member ? 'member' : v.signal ? 'signal' : 'variable';
308
+ if (prime(name))
309
+ report(v, name, what, PRIME_GCC);
310
+ // At the top level the name is a member of the tick data as it is; further in KIELER prefixes it.
311
+ else if (caret(name))
312
+ report(v, name, what, scope === root || v.member ? 'expected identifier or ‘(’ before ‘^’ token' : 'expected ‘:’, ‘,’, ‘;’, ‘}’ or ‘__attribute__’ before ‘^’ token');
313
+ }
314
+ }
315
+ return out;
316
+ }
317
+ /** The expressions of an SCL body, in order. */
318
+ function bodyExprs(list, out = []) {
319
+ const add = (e) => { if (e)
320
+ out.push(e); };
321
+ for (const st of list) {
322
+ if (st.k === 'do')
323
+ out.push(...effectExprs(st.f));
324
+ else if (st.k === 'if') {
325
+ add(st.cond);
326
+ bodyExprs(st.then, out);
327
+ if (st.else)
328
+ bodyExprs(st.else, out);
329
+ }
330
+ else if (st.k === 'while') {
331
+ add(st.cond);
332
+ bodyExprs(st.body, out);
333
+ }
334
+ else if (st.k === 'for') {
335
+ bodyExprs(st.init, out);
336
+ add(st.cond);
337
+ bodyExprs(st.update, out);
338
+ bodyExprs(st.body, out);
339
+ }
340
+ else if (st.k === 'return')
341
+ add(st.expr);
342
+ else if (st.k === 'expr')
343
+ add(st.e);
344
+ }
345
+ return out;
346
+ }
347
+ /**
348
+ * What reaches KIELER's C code: the methods that are called somewhere (an uncalled one gets no C code; code effects
349
+ * are methods too), and every expression of the triggers, effects, initial values and called methods' bodies, with
350
+ * the element it belongs to (for `related`).
351
+ */
352
+ function reachingC(root) {
353
+ const called = new Set();
354
+ const exprs = [];
355
+ const pending = [];
356
+ const visit = (e, related) => {
357
+ if (!e)
358
+ return;
359
+ exprs.push({ e, related });
360
+ walkExpr(e, x => {
361
+ if (x.k !== 'call' || !x.target)
362
+ return;
363
+ let r = x.target;
364
+ while (r.sub)
365
+ r = r.sub;
366
+ const m = r.v;
367
+ if (m.method && !called.has(m)) {
368
+ called.add(m);
369
+ pending.push(m);
370
+ }
371
+ });
372
+ };
373
+ for (const site of allActionSites(root)) {
374
+ const holder = site.transition ?? site.action;
375
+ const by = holder.origin ?? holder.about;
376
+ const related = by ? [by] : undefined;
377
+ visit(holder.trigger, related);
378
+ for (const f of holder.effects)
379
+ for (const e of effectExprs(f))
380
+ visit(e, related);
381
+ }
382
+ for (const scope of allScopes(root))
383
+ for (const v of scope.decls)
384
+ visit(v.init, v.decl ? [v.decl] : undefined);
385
+ while (pending.length) {
386
+ const m = pending.pop();
387
+ const related = m.method.by ? [m.method.by] : m.decl ? [m.decl] : undefined;
388
+ for (const e of bodyExprs(m.method.body))
389
+ visit(e, related);
390
+ }
391
+ return { called, exprs };
392
+ }
393
+ /**
394
+ * A string literal as KIELER writes it into its C code: the value between quotes, with the escapes the parser
395
+ * resolved (a `\n` is a line break in the C file, a `\"` ends the literal there). `open`: gcc's lexer finds the
396
+ * literal unterminated (`missing terminating " character`); `split`: a quote in the value ends the literal early, and
397
+ * what follows is not C (probe rare/probe-string-quotes).
398
+ */
399
+ function cStringProblem(value) {
400
+ const text = `"${value}"`;
401
+ let inString = false;
402
+ let split = false;
403
+ for (let i = 0; i < text.length; i++) {
404
+ const c = text[i];
405
+ if (inString) {
406
+ if (c === '\\')
407
+ i++;
408
+ else if (c === '"')
409
+ inString = false;
410
+ else if (c === '\n' || c === '\r')
411
+ return 'open';
412
+ }
413
+ else if (c === '"')
414
+ inString = true;
415
+ else if (!/\s/.test(c))
416
+ split = true;
417
+ }
418
+ if (inString)
419
+ return 'open';
420
+ return split ? 'split' : undefined;
421
+ }
422
+ /** gcc's name for the type of an operand, when it is certain (KIELER's `float` is C's `double`). */
423
+ function cOperandType(e) {
424
+ if (e.k === 'lit')
425
+ return e.t === 'float' ? 'double' : e.t === 'int' ? 'int' : undefined;
426
+ if (e.k === 'ref') {
427
+ let r = e;
428
+ while (r.sub)
429
+ r = r.sub;
430
+ if (r.idx.length < r.v.dims.length)
431
+ return undefined;
432
+ return r.v.type === 'float' ? 'double' : r.v.type === 'int' ? 'int' : undefined;
433
+ }
434
+ if (e.k === 'op' && (e.op === '+' || e.op === '-' || e.op === '*' || e.op === '/') && e.args.length >= 2) {
435
+ const types = e.args.map(cOperandType);
436
+ if (types.some(t => t === undefined))
437
+ return undefined;
438
+ return types.includes('double') ? 'double' : 'int';
439
+ }
440
+ return undefined;
441
+ }
442
+ const isFloatOperand = (e) => {
443
+ if (e.k === 'lit')
444
+ return e.t === 'float';
445
+ if (e.k === 'ref') {
446
+ let r = e;
447
+ while (r.sub)
448
+ r = r.sub;
449
+ return r.v.type === 'float';
450
+ }
451
+ return cOperandType(e) === 'double';
452
+ };
453
+ /**
454
+ * C text KIELER writes as it is, which gcc then rejects (probes rare/probe-string-*, rare/probe-float-modulo-*,
455
+ * rare/probe-d-*): a string literal with a line break or a quote in it, `%` on a float, and a variable `d` in a
456
+ * method KIELER keeps as a C function, whose tick data parameter is called `d`.
457
+ */
458
+ function cText(root) {
459
+ const out = [];
460
+ const { called, exprs } = reachingC(root);
461
+ for (const { e, related } of exprs) {
462
+ walkExpr(e, x => {
463
+ const problem = x.k === 'lit' && x.t === 'string' ? cStringProblem(String(x.v)) : undefined;
464
+ if (problem) {
465
+ out.push({
466
+ severity: 'error', code: 'c-string', span: x.span, related,
467
+ message: 'KIELER writes this string into its C code as it is, and the line break or the quote in it breaks the C code',
468
+ kieler: problem === 'open' ? `missing terminating " character\n${GCC_FAILED}` : GCC_FAILED,
469
+ hint: 'Leave `\\n`, `\\r` and `\\"` (and line breaks) out of strings, which KIELER\'s C code cannot hold; for a quote inside a string, use `\'`.',
470
+ });
471
+ }
472
+ // An extern function named without parentheses: KIELER writes the name as it is, which C does not know
473
+ // (the validator's warning extern-without-call comes first; probe rare/probe-extern-without-call).
474
+ if (x.k === 'ref' && x.v.extern && !x.sub) {
475
+ out.push({
476
+ severity: 'error', code: 'extern-not-called', span: x.span, related,
477
+ message: `\`${x.v.name}\` is an external function, so KIELER's C code needs a call: \`${x.v.name}(…)\``,
478
+ kieler: `‘${x.v.name}’ undeclared (first use in this function)\n${GCC_FAILED}`,
479
+ hint: `Call it with parentheses and its arguments, as in \`${x.v.name}(x)\`.`,
480
+ });
481
+ }
482
+ if (x.k === 'op' && x.op === '%' && x.args.length === 2 && x.args.some(isFloatOperand)) {
483
+ const [a, b] = x.args.map(cOperandType);
484
+ out.push({
485
+ severity: 'error', code: 'c-float-modulo', span: x.span, related,
486
+ message: 'C has no `%` for floats, so KIELER\'s generated code does not compile',
487
+ kieler: a && b ? `invalid operands to binary % (have ‘${a}’ and ‘${b}’)\n${GCC_FAILED}` : GCC_FAILED,
488
+ hint: 'Keep `%` for whole numbers (`int`). For a float, subtract the whole multiples yourself, or compute with ints.',
489
+ });
490
+ }
491
+ });
492
+ }
493
+ // `x %= 2.5` on a float target, or with a float operand.
494
+ const assigns = (list, related) => {
495
+ for (const f of list) {
496
+ if (f.k !== 'assign' || f.op !== '%=' || !f.expr)
497
+ continue;
498
+ if (!isFloatOperand(f.ref) && !isFloatOperand(f.expr))
499
+ continue;
500
+ const [a, b] = [cOperandType(f.ref), cOperandType(f.expr)];
501
+ out.push({
502
+ severity: 'error', code: 'c-float-modulo', span: f.o.span, related,
503
+ message: 'C has no `%=` for floats, so KIELER\'s generated code does not compile',
504
+ kieler: a && b ? `invalid operands to binary % (have ‘${a}’ and ‘${b}’)\n${GCC_FAILED}` : GCC_FAILED,
505
+ hint: 'Keep `%` for whole numbers (`int`). For a float, subtract the whole multiples yourself, or compute with ints.',
506
+ });
507
+ }
508
+ };
509
+ for (const site of allActionSites(root)) {
510
+ const holder = site.transition ?? site.action;
511
+ const by = holder.origin ?? holder.about;
512
+ assigns(holder.effects, by ? [by] : undefined);
513
+ }
514
+ const effectsOf = (list, acc = []) => {
515
+ for (const st of list) {
516
+ if (st.k === 'do')
517
+ acc.push(st.f);
518
+ else if (st.k === 'if') {
519
+ effectsOf(st.then, acc);
520
+ if (st.else)
521
+ effectsOf(st.else, acc);
522
+ }
523
+ else if (st.k === 'while')
524
+ effectsOf(st.body, acc);
525
+ else if (st.k === 'for') {
526
+ effectsOf(st.init, acc);
527
+ effectsOf(st.update, acc);
528
+ effectsOf(st.body, acc);
529
+ }
530
+ }
531
+ return acc;
532
+ };
533
+ for (const m of called) {
534
+ const related = m.decl ? [m.decl] : m.method.by ? [m.method.by] : undefined;
535
+ assigns(effectsOf(m.method.body), related);
536
+ // A C function's first parameter is the tick data, `TickData* d` (an inlined method's variables get a prefix).
537
+ const method = m.method;
538
+ if (isInlined(method) || m.member)
539
+ continue;
540
+ const nested = new Set();
541
+ const inner = (list, top) => {
542
+ for (const st of list) {
543
+ if (st.k === 'do' && !top && st.f.k === 'assign' && st.f.o.hidden)
544
+ nested.add(st.f.ref.v);
545
+ else if (st.k === 'if') {
546
+ inner(st.then, false);
547
+ if (st.else)
548
+ inner(st.else, false);
549
+ }
550
+ else if (st.k === 'while')
551
+ inner(st.body, false);
552
+ else if (st.k === 'for') {
553
+ inner(st.init, false);
554
+ inner(st.body, false);
555
+ }
556
+ }
557
+ };
558
+ inner(method.body, true);
559
+ const name = m.generated ? 'code block' : `method \`${m.name}\``;
560
+ for (const p of method.params) {
561
+ if (p.name !== 'd')
562
+ continue;
563
+ out.push({
564
+ severity: 'error', code: 'c-name', span: p.span ?? m.span, related: m.decl ? [m.decl] : undefined,
565
+ message: `The parameter \`d\` of the ${name} clashes with KIELER's C code, which calls the chart's data \`d\``,
566
+ kieler: p.type === 'int' || p.type === 'float' ? `conflicting types for ‘d’; have ‘${p.type === 'int' ? 'int' : 'double'}’\n${GCC_FAILED}` : GCC_FAILED,
567
+ hint: 'Rename the parameter (for example `delta`).',
568
+ });
569
+ }
570
+ for (const v of method.locals) {
571
+ if (v.name !== 'd' || nested.has(v))
572
+ continue;
573
+ out.push({
574
+ severity: 'error', code: 'c-name', span: v.span ?? m.span, related: m.decl ? [m.decl] : m.method.by ? [m.method.by] : undefined,
575
+ message: `The local variable \`d\` of the ${name} clashes with KIELER's C code, which calls the chart's data \`d\``,
576
+ kieler: `‘d’ redeclared as different kind of symbol\n${GCC_FAILED}`,
577
+ hint: 'Rename the variable (for example `delta`).',
578
+ });
579
+ }
580
+ }
581
+ return out;
582
+ }
583
+ function isString(e) {
584
+ if (e.k === 'lit')
585
+ return e.t === 'string';
586
+ if (e.k === 'ref') {
587
+ let r = e;
588
+ while (r.sub)
589
+ r = r.sub;
590
+ return r.v.type === 'string';
591
+ }
592
+ return false;
593
+ }
594
+ /**
595
+ * A conditional without an else part (`c ? a`) where KIELER's C code has nothing to put in its place. Its code
596
+ * generator writes `c ? a : __CONDSELF__` and replaces the placeholder by the target of the assignment the
597
+ * conditional is in (an inlined body's statements and a condition's guard are assignments too, ExprCompiler.selves);
598
+ * anywhere else (print, a call that is a whole effect, an assignment's target index, the conditions and returns of a
599
+ * method KIELER keeps as a C function) gcc rejects it (probes kieler/rare/probe-cond-noelse-*). Runs on the graph
600
+ * after the Methods processor, whose inlining moves arguments into the bodies.
601
+ */
602
+ export function conditionalWithoutElse(nodes) {
603
+ const out = [];
604
+ const seen = new Set();
605
+ const bare = (e) => {
606
+ walkExpr(e, x => {
607
+ if (x.k === 'op' && x.op === '?:' && x.args.length === 2 && !seen.has(x)) {
608
+ seen.add(x);
609
+ if (!out.length) {
610
+ out.push({
611
+ severity: 'error', code: 'conditional-without-else', span: x.span,
612
+ message: 'A conditional without an else part only works in an assignment or a condition: here KIELER\'s C code does not compile',
613
+ kieler: `‘__CONDSELF__’ undeclared (first use in this function)\n${GCC_FAILED}`,
614
+ hint: 'KIELER writes `(c) ? a` in `x = ...` as `(c) ? a : x`, and in a trigger it keeps the previous result when `c` is false; in `print`, in the arguments of a call on its own, in an array index you assign to or in a method KIELER compiles as a C function it has nothing to put there. Write the else part: `(c) ? a : b`.',
615
+ });
616
+ }
617
+ }
618
+ });
619
+ };
620
+ const methods = new Set();
621
+ const calls = (e) => walkExpr(e, x => { if (x.k === 'call' && !x.extern && x.target?.v.method && !isInlined(x.target.v.method))
622
+ methods.add(x.target.v); });
623
+ const effect = (f) => {
624
+ switch (f.k) {
625
+ case 'assign':
626
+ f.ref.idx.forEach(bare);
627
+ f.ref.idx.forEach(calls);
628
+ calls(f.expr);
629
+ break;
630
+ case 'emit':
631
+ f.ref.idx.forEach(bare);
632
+ calls(f.value);
633
+ break;
634
+ case 'print':
635
+ f.args.forEach(bare);
636
+ f.args.forEach(calls);
637
+ break;
638
+ case 'call':
639
+ f.call.args.forEach(bare);
640
+ calls(f.call);
641
+ break;
642
+ default: break;
643
+ }
644
+ };
645
+ for (const n of nodes) {
646
+ if (n.kind === 'cond')
647
+ calls(n.expr);
648
+ else if (n.effect)
649
+ effect(n.effect);
650
+ }
651
+ // The bodies of the methods that stay C functions (and of the methods they call).
652
+ const done = new Set();
653
+ const body = (list) => {
654
+ for (const st of list) {
655
+ switch (st.k) {
656
+ case 'do':
657
+ effect(st.f);
658
+ break;
659
+ case 'if':
660
+ bare(st.cond);
661
+ calls(st.cond);
662
+ body(st.then);
663
+ if (st.else)
664
+ body(st.else);
665
+ break;
666
+ case 'while':
667
+ bare(st.cond);
668
+ calls(st.cond);
669
+ body(st.body);
670
+ break;
671
+ case 'for':
672
+ body(st.init);
673
+ bare(st.cond);
674
+ calls(st.cond);
675
+ body(st.update);
676
+ body(st.body);
677
+ break;
678
+ case 'return':
679
+ bare(st.expr);
680
+ calls(st.expr);
681
+ break;
682
+ case 'expr':
683
+ bare(st.e);
684
+ calls(st.e);
685
+ break;
686
+ default: break;
687
+ }
688
+ }
689
+ };
690
+ for (let grew = true; grew;) {
691
+ grew = false;
692
+ for (const m of [...methods]) {
693
+ if (done.has(m))
694
+ continue;
695
+ done.add(m);
696
+ grew = true;
697
+ body(m.method.body);
698
+ }
699
+ }
700
+ return out;
701
+ }
702
+ /**
703
+ * `#code.naming "tick", "reset", "logic", "Struct"`: KIELER's simulation compiles its C with these names too, so
704
+ * names gcc cannot take reject the chart there (probes tests/engine/kieler/codegen/probe-naming-*): a C keyword, two
705
+ * functions of one name, and a logic function called `d`, the tick data parameter that tick() passes to it.
706
+ */
707
+ export function codeNamingProblems(pragmas) {
708
+ const p = pragmas.find(x => x.name === 'code.naming');
709
+ if (!p || p.values.length !== 4)
710
+ return [];
711
+ const [tick, reset, logic, struct] = p.values;
712
+ const out = [];
713
+ const add = (message, kieler) => out.push({
714
+ severity: 'error', code: 'c-naming', span: p.span, message, kieler: `${kieler}\n${GCC_FAILED}`,
715
+ hint: 'Give the tick, reset and logic functions and the struct four different names that are not keywords of C, and do not call the logic function `d`.',
716
+ });
717
+ const keyword = [tick, reset, logic, struct].find(n => C_KEYWORDS.has(n));
718
+ if (keyword)
719
+ add(`\`#code.naming\` uses \`${keyword}\`, a keyword of C, as a name, so KIELER's generated C code does not compile`, `expected identifier or ‘(’ before ‘${keyword}’`);
720
+ const functions = [tick, reset, logic];
721
+ const twice = functions.find((n, i) => functions.indexOf(n) !== i);
722
+ if (twice)
723
+ add(`\`#code.naming\` gives two functions the name \`${twice}\`, so KIELER's generated C code does not compile`, `redefinition of ‘${twice}’`);
724
+ else if (functions.includes(struct))
725
+ add(`\`#code.naming\` gives a function and the struct the name \`${struct}\`, so KIELER's generated C code does not compile`, `‘${struct}’ redeclared as different kind of symbol`);
726
+ if (logic === 'd')
727
+ add('`#code.naming` calls the logic function `d`, the name tick() gives its tick data, so KIELER\'s generated C code does not compile', "called object ‘d’ is not a function or function pointer");
728
+ return out;
729
+ }
730
+ //# sourceMappingURL=codegen.js.map