0b319a5 · elk · git.iko.soy

16 var wrappedModule = debugModule(module, runtime);

17 Elm.Debugger = debuggerInit(wrappedModule, runtime, hotSwapState);

18 dispatchElmDebuggerInit();

19− return wrappedModule.moduleInstance;

19+ return wrappedModule.debuggedModule;

20 }

21 };

22};

40 var recordedEvents = [];

41 var asyncCallbacks = [];

42 var watchTracker = Elm.Native.Debug.make(runtime).watchTracker;

43− var now = 0;

43+ var pauseTime = 0;

44

45 function wrapNotify(id, v) {

46 var timestep = runtime.timer.now();

113 programPaused = true;

114 clearAsyncCallbacks();

115 tracePath.stopRecording();

116− now = Date.now();

116+ pauseTime = Date.now();

117 }

118

119 function setContinue(position) {

120− var timerDelay = Date.now() - now;

120+ var timerDelay = Date.now() - pauseTime;

121 runtime.timer.addDelay(timerDelay);

122 programPaused = false;

123 if (position > 0) {

140 wrappedRuntime.runDelayed = wrapRunDelayed;

141

142 var assignedPropTracker = Object.create(wrappedRuntime);

143− var moduleInstance = module.make(assignedPropTracker);

143+ var debuggedModule = module.make(assignedPropTracker);

144

145 // make sure the signal graph is actually a signal & extract the visual model

146− if ( !('recv' in moduleInstance.main) ) {

146+ if ( !('recv' in debuggedModule.main) ) {

147− moduleInstance.main = Elm.Signal.make(runtime).constant(moduleInstance.main);

147+ debuggedModule.main = Elm.Signal.make(runtime).constant(debuggedModule.main);

148 }

149

150 // The main module stores imported modules onto the runtime.

154 runtime[key] = assignedPropTracker[key];

155 });

156

157− var moduleNodes = flattenNodes(wrappedRuntime.inputs);

157+ var signalGraphNodes = flattenSignalGraph(wrappedRuntime.inputs);

158− var tracePath = tracePathInit(runtime, moduleInstance.main);

158+ var tracePath = tracePathInit(runtime, debuggedModule.main);

159

160 return {

161− moduleInstance: moduleInstance,

161+ debuggedModule: debuggedModule,

162− moduleNodes: moduleNodes,

162+ signalGraphNodes: signalGraphNodes,

163− initialNodeValues: saveNodeValues(moduleNodes),

163+ initialSnapshot: snapshotSignalGraph(signalGraphNodes),

164 initialAsyncCallbacks: asyncCallbacks.slice(),

165 // API functions

166 clearAsyncCallbacks: clearAsyncCallbacks,

178}

179

180function debuggerInit(debugModule, runtime, hotSwapState /* =undefined */) {

181− var eventCounter = 0;

181+ var currentEventIndex = 0;

182

183 function resetProgram() {

184 debugModule.clearAsyncCallbacks();

185− restoreNodeValues(debugModule.moduleNodes, debugModule.initialNodeValues);

185+ restoreSnapshot(debugModule.signalGraphNodes, debugModule.initialSnapshot);

186 redrawGraphics();

187 }

188

197

198 function pauseProgram() {

199 debugModule.setPaused();

200− eventCounter = debugModule.getRecordedEventsLength();

200+ currentEventIndex = debugModule.getRecordedEventsLength();

201 }

202

203 function continueProgram() {

204 if (debugModule.getPaused())

205 {

206− if(eventCounter === 0) {

206+ if(currentEventIndex === 0) {

207 restartProgram();

208 return;

209 }

210 resetProgram();

211− var index = eventCounter;

211+ var continueIndex = currentEventIndex;

212− eventCounter = 0;

212+ currentEventIndex = 0;

213 debugModule.tracePath.clearTraces();

214 debugModule.tracePath.startRecording();

215− stepTo(index);

215+ stepTo(continueIndex);

216− debugModule.setContinue(eventCounter);

216+ debugModule.setContinue(currentEventIndex);

217 }

218 }

219

227 throw "Index out of bounds: " + index;

228 }

229

230− if (index < eventCounter) {

230+ if (index < currentEventIndex) {

231 resetProgram();

232− eventCounter = 0;

232+ currentEventIndex = 0;

233 }

234

235− assert(index >= eventCounter, "index must be bad");

235+ assert(index >= currentEventIndex, "index must be bad");

236− while (eventCounter < index) {

236+ while (currentEventIndex < index) {

237− var nextEvent = debugModule.getRecordedEventAt(eventCounter);

237+ var nextEvent = debugModule.getRecordedEventAt(currentEventIndex);

238 runtime.notify(nextEvent.id, nextEvent.value, nextEvent.timestep);

239

240− eventCounter += 1;

240+ currentEventIndex += 1;

241 }

242− assert(eventCounter == index, "while loop didn't work");

242+ assert(currentEventIndex == index, "while loop didn't work");

243 }

244

245 function getMaxSteps() {

258 }

259

260 function redrawGraphics() {

261− var main = debugModule.moduleInstance.main

261+ var main = debugModule.debuggedModule.main

262 for (var i = main.kids.length ; i-- ; ) {

263 main.kids[i].recv(runtime.timer.now(), true, main.id);

264 }

265 }

266

267 function getHotSwapState() {

268− var counter = eventCounter;

268+ var continueIndex = currentEventIndex;

269 if (!debugModule.getPaused()) {

270− counter = getMaxSteps();

270+ continueIndex = getMaxSteps();

271 }

272 return {

273 recordedEvents: debugModule.copyRecordedEvents(),

274− eventCounter: counter

274+ currentEventIndex: continueIndex

275 };

276 }

277

296 stepTo(getMaxSteps());

297 debugModule.tracePath.stopRecording();

298

299− stepTo(hotSwapState.eventCounter);

299+ stepTo(hotSwapState.currentEventIndex);

300 if (paused) {

301 debugModule.setPaused();

302 } else {

303− debugModule.setContinue(hotSwapState.eventCounter);

303+ debugModule.setContinue(hotSwapState.currentEventIndex);

304 }

305 }

306

315 getPaused: debugModule.getPaused,

316 getHotSwapState: getHotSwapState,

317 dispose: dispose,

318− allNodes: debugModule.moduleNodes,

318+ allNodes: debugModule.signalGraphNodes,

319 watchTracker: debugModule.watchTracker,

320− mainNode: debugModule.moduleInstance.main

320+ signalGraphMain: debugModule.debuggedModule.main

321 };

322

323 return elmDebugger;

336 }

337}

338

339−function tracePathInit(runtime, mainNode) {

339+function tracePathInit(runtime, signalGraphMain) {

340 var List = Elm.List.make(runtime);

341 var Signal = Elm.Signal.make(runtime);

342− var tracePathNode = A2(Signal.lift, graphicsUpdate, mainNode);

342+ var tracePathNode = A2(Signal.lift, graphicsUpdate, signalGraphMain);

343 var tracePathCanvas = createCanvas();

344 var tracePositions = {};

345 var recordingTraces = true;

474 }

475}

476

477−function saveNodeValues(allNodes) {

477+function snapshotSignalGraph(signalGraphNodes) {

478 var nodeValues = [];

479

480− allNodes.forEach(function(node) {

480+ signalGraphNodes.forEach(function(node) {

481 nodeValues.push({ value: node.value, id: node.id });

482 });

483

485};

486

487

488−function restoreNodeValues(allNodes, nodeStates) {

488+function restoreSnapshot(signalGraphNodes, snapshot) {

489− assert(allNodes.length == nodeStates.length, "saved program state has wrong length");

489+ assert(signalGraphNodes.length == snapshot.length, "saved program state has wrong length");

490− for (var i=0; i < allNodes.length; i++) {

490+ for (var i=0; i < signalGraphNodes.length; i++) {

491− var node = allNodes[i];

491+ var node = signalGraphNodes[i];

492− var state = nodeStates[i];

492+ var state = snapshot[i];

493 assert(node.id == state.id, "the nodes moved position");

494

495 node.value = state.value;

496 }

497}

498

499−function flattenNodes(nodes) {

499+function flattenSignalGraph(nodes) {

500 var nodesById = {};

501

502 function addAllToDict(node) {