This repository was archived by the owner on Dec 24, 2020. It is now read-only.
-
Notifications
You must be signed in to change notification settings - Fork 91
/
Copy pathcomputer.js
1958 lines (1820 loc) · 84.7 KB
/
computer.js
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
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
342
343
344
345
346
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
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
/**
* @fileoverview Implements the PCx86 Computer component
* @author <a href="mailto:[email protected]">Jeff Parsons</a>
* @copyright © 2012-2020 Jeff Parsons
*
* This file is part of PCjs, a computer emulation software project at <https://www.pcjs.org>.
*
* PCjs is free software: you can redistribute it and/or modify it under the terms of the
* GNU General Public License as published by the Free Software Foundation, either version 3
* of the License, or (at your option) any later version.
*
* PCjs is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without
* even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along with PCjs. If not,
* see <http://www.gnu.org/licenses/gpl.html>.
*
* You are required to include the above copyright notice in every modified copy of this work
* and to display that copyright notice when the software starts running; see COPYRIGHT in
* <https://www.pcjs.org/modules/shared/lib/defines.js>.
*
* Some PCjs files also attempt to load external resource files, such as character-image files,
* ROM files, and disk image files. Those external resource files are not considered part of PCjs
* for purposes of the GNU General Public License, and the author does not claim any copyright
* as to their contents.
*/
/*
* BUILD INSTRUCTIONS
*
* To build PCx86 (pcx86.js), run Google's Closure Compiler, replacing "*.js" with the input file sequence defined
* by the "PCx86Files" property in package.json:
*
* java -jar compiler.jar
* --compilation_level ADVANCED_OPTIMIZATIONS
* --define='DEBUG=false'
* --warning_level=VERBOSE
* --js *.js
* --js_output_file pc.js
*
* Google's Closure Compiler (compiler.jar) is documented at https://developers.google.com/closure/compiler/
* and is available for download here:
*
* http://closure-compiler.googlecode.com/files/compiler-latest.zip
*
* The PCx86 JavaScript files do have some initialization-order dependencies. If you load the files individually,
* it's recommended that you load them in the same order that they're compiled.
*
* Generally speaking, component.js should be first, computer.js should be last (of the files based on component.js),
* and panel.js should be listed early so that the Control Panel is ready as soon as possible.
*
* Another recent ordering requirement is that rom.js must be loaded before ram.js; this was true before, but now
* it's required, because I'm starting to add ROM BIOS Data Area definitions to rom.js, and since the data area
* is in RAM, ram.js may want access to some of those definitions.
*/
"use strict";
if (typeof module !== "undefined") {
var Str = require("../../shared/lib/strlib");
var Usr = require("../../shared/lib/usrlib");
var Web = require("../../shared/lib/weblib");
var UserAPI = require("../../shared/lib/userapi");
// var ReportAPI = require("../../shared/lib/reportapi");
var Component = require("../../shared/lib/component");
var State = require("../../shared/lib/state");
var PCx86 = require("./defines");
var Messages = require("./messages");
var BusX86 = require("./bus").BusX86;
var FPUx86 = require("./fpux86");
}
/**
* class Computer
* @unrestricted (allows the class to define properties, both dot and named, outside of the constructor)
*/
class Computer extends Component {
/**
* Computer(parmsComputer, parmsMachine, fSuspended)
*
* The Computer component has no required (parmsComputer) properties, but it does
* support the following:
*
* autoPower: true to automatically power the computer (default), false to wait;
* false is honored only if a "power" button binding exists.
*
* busWidth: number of memory address lines (address bits) on the computer's "bus";
* 20 is the minimum (and the default), which implies 8086/8088 real-mode addressing,
* while 24 is required for 80286 protected-mode addressing. This value is passed
* directly through to the Bus component; see that component for more details.
*
* resume: one of the Computer.RESUME constants, which are as follows:
* '0' if resume disabled (default)
* '1' if enabled without prompting
* '2' if enabled with prompting
* '3' if enabled with prompting and auto-delete
* or a string containing the path of a predefined JSON-encoded state
*
* state: the path to JSON-encoded state file (see details regarding 'state' below)
*
* The parmsMachine object, if provided, may contain any of:
*
* autoMount: if set, this should override any 'autoMount' property in the FDC's
* parmsFDC object.
*
* autoPower: if set, this should override any 'autoPower' property in the Computer's
* parmsComputer object.
*
* messages: if set, this should override any 'messages' property in the Debugger's
* parmsDbg object.
*
* state: if set, this should override any 'state' property in the Computer's
* parmsComputer object.
*
* url: the location of the machine XML file
*
* diagnostics: 0 for none, 1 for normal diagnostics, and 2 for diagnostics with prompting
*
* If a predefined state is supplied AND it's successfully loaded, then resume behavior
* defaults to '1' (ie, resume enabled without prompting).
*
* This component insures that all components are ready before "powering" them.
*
* Different components become ready at different times, and initialization order (ie,
* the order the scripts are combined on the page) only partially determines readiness.
* This is because components like ROM and Video must finish loading their resource files
* before they are ready. Other components become ready after we call their initBus()
* function, because they have a Bus or CPU dependency, such as access to memory management
* functions. And other components, like CPU and Panel, are ready as soon as their
* constructor finishes.
*
* Once a component has indicated it's ready, we call its powerUp() notification
* function (if it has one--it's optional). We call the CPU's powerUp() function last,
* so that the CPU is assured that all other components are ready and "powered".
*
* @this {Computer}
* @param {Object} parmsComputer
* @param {Object} [parmsMachine]
* @param {boolean} [fSuspended]
*/
constructor(parmsComputer, parmsMachine, fSuspended)
{
super("Computer", parmsComputer, Messages.COMPUTER);
let cmp = this;
this.setMachineParms(parmsMachine);
this.fAutoPower = this.getMachineParm('autoPower', parmsComputer);
this.nDiagnostics = +this.getMachineParm('diagnostics', parmsComputer);
if (!(this.nDiagnostics >= 0 && this.nDiagnostics <= 2)) this.nDiagnostics = 1;
/*
* nPowerChange is 0 while the power state is stable, 1 while power is transitioning
* to "on", and -1 while power is transitioning to "off".
*/
this.nPowerChange = 0;
/*
* TODO: Deprecate 'buswidth' (it should have always used camelCase)
*/
this.nBusWidth = parmsComputer['busWidth'] || parmsComputer['buswidth'];
this.resume = Computer.RESUME_NONE;
this.sStateData = null;
this.fStateData = false; // remembers if sStateData was loaded
this.fServerState = false;
this.url = this.getMachineParm('url') || "";
/*
* Generate a random number x (where 0 <= x < 1), add 0.1 so that it's guaranteed to be
* non-zero, convert to base 36, and chop off the leading digit and "decimal" point.
*/
this.sMachineID = (Math.random() + 0.1).toString(36).substr(2,12);
this.sUserID = this.queryUserID();
/*
* Find the appropriate CPU (and Debugger and Control Panel, if any)
*
* CLOSURE COMPILER TIP: To override the type of a right-hand expression (as we need to do here,
* where we know getComponentByType() will only return an CPUx86 object or null), wrap the expression
* in parentheses. I never knew this until I stumbled across it in "Closure: The Definitive Guide".
*/
this.cpu = /** @type {CPUx86} */ (Component.getComponentByType("CPU", this.id));
if (!this.cpu) {
Component.error("Unable to find CPU component");
return;
}
/*
* We now record whether or not the machine was originally configured with an FPU (this.fpu),
* but even when not, we still initialize an FPU, so that the machine can be dynamically reconfigured.
*/
this.fpu = /** @type {FPUx86} */ (Component.getComponentByType("FPU", this.id));
if (!this.fpu) new FPUx86({'id': this.idMachine + ".fpu"});
this.dbg = /** @type {DebuggerX86} */ (Component.getComponentByType("Debugger", this.id));
/*
* Enumerate all the Video components for diagnostic displays, focus changes, and updateStatus() calls.
*/
this.aVideo = [];
for (let video = null; (video = this.getMachineComponent("Video", video));) {
this.aVideo.push(video);
}
/*
* Initialize the Bus component
*/
this.bus = new BusX86({'id': this.idMachine + '.bus', 'busWidth': this.nBusWidth}, this.cpu, this.dbg);
/*
* Iterate through all the components and override their notice() and println() methods
* so that their output can be rerouted to a Diagnostic Display or Control Panel, if any.
*/
let iComponent, component;
let aComponents = Component.getComponents(this.id);
this.panel = /** @type {Panel} */ (Component.getComponentByType("Panel", this.id));
this.controlPanel = this.panel && this.panel.bindings['print'];
this.noticeComputer = this.notice;
this.printComputer = this.print;
this.printlnComputer = this.println;
if (this.controlPanel) {
this.noticeComputer = this.panel.notice;
this.printComputer = this.panel.print;
this.printlnComputer = this.panel.println;
}
for (iComponent = 0; iComponent < aComponents.length; iComponent++) {
component = aComponents[iComponent];
component.notice = function noticeComputer(s, fPrintOnly, id) {
cmp.outputDiagnostics(s);
return cmp.noticeComputer.call(this, s, fPrintOnly, id);
}.bind(component);
component.print = function printComputer(s) {
return cmp.printComputer.call(this, s);
}.bind(component);
component.println = function printlnComputer(s, type, id) {
cmp.outputDiagnostics(s, type);
return cmp.printlnComputer.call(this, s, type, id);
}.bind(component);
}
this.cDiagnosticScreens = 0;
if (!this.controlPanel && this.nDiagnostics) {
this.enableDiagnostics();
}
this.println(PCx86.APPNAME + " v" + (XMLVERSION || PCx86.APPVERSION) + "\n" + COPYRIGHT + "\n" + LICENSE);
if (DEBUG) this.printf("PREFETCH: %b, TYPEDARRAYS: %b\n", PREFETCH, TYPEDARRAYS);
/*
* Iterate through all the components again and call their initBus() handler, if any
*/
for (iComponent = 0; iComponent < aComponents.length; iComponent++) {
component = aComponents[iComponent];
if (component.initBus) component.initBus(this, this.bus, this.cpu, this.dbg);
}
/*
* This timer replaces the CPU's old dedicated STATUS_UPDATES_PER_SECOND logic; periodic updateStatus()
* calls are now our own responsibility.
*/
this.cpu.addTimer(this.id, function updateStatusTimer() {
cmp.updateStatus();
}, 1000 / Computer.UPDATES_PER_SECOND);
let sStatePath = null;
let sResume = this.getMachineParm('resume');
if (sResume !== undefined) {
/*
* Decide whether the 'resume' property is a number or the path of a state file to resume.
*/
if (sResume.length > 1) {
sStatePath = this.sResumePath = sResume;
} else {
this.resume = parseInt(sResume, 10);
}
}
/*
* The Computer 'state' property allows a state file to be specified independent of the 'resume' feature;
* previously, you could only use 'resume' to load a state file -- which we still support, but loading a state
* file that way prevents the machine's state from being saved, since we always resume from the 'resume' file.
*
* The other wrinkle is on the restore side: we need to IGNORE the 'state' property if a saved state now exists.
* So we have to peek at localStorage, and unfortunately, the only way to "peek" is to actually load the data,
* but we're not ready to use it yet, so powerUp() has been changed to use any existing stateComputer that we've
* already loaded.
*
* However, there's now a wrinkle to the wrinkle: if a 'state' parameter has been passed via the URL, then that
* OVERRIDES everything; it overrides any 'state' Computer parameter AND it disables resume of any saved state in
* localStorage (in other words, it prevents fAllowResume from being true, and forcing resume off).
*/
let fAllowResume = false;
let sState = Web.getURLParm('state');
if (!sState) {
fAllowResume = true;
sState = this.getMachineParm('state', parmsComputer);
}
if (sState) {
sStatePath = this.sStatePath = sState;
if (!fAllowResume) {
this.fServerState = true;
this.resume = Computer.RESUME_NONE;
}
if (this.resume) {
this.stateComputer = new State(this, PCx86.APPVERSION);
if (this.stateComputer.load()) {
sStatePath = null;
} else {
delete this.stateComputer;
}
}
}
/*
* If sStatePath is set, we must use it. But if there's no sStatePath AND resume is set,
* then we have the option of resuming from a server-side state, assuming a valid USERID.
*/
if (!sStatePath && this.resume) {
sStatePath = this.getServerStatePath();
if (sStatePath) this.fServerState = true;
}
this.sStateURL = sStatePath;
if (!this.sStateURL) {
this.setReady();
} else {
let sProgress = "Loading " + this.sStateURL + "...";
Web.getResource(this.sStateURL, null, true, function(sURL, sResource, nErrorCode) {
cmp.doneLoad(sURL, sResource, nErrorCode);
}, function(nState) {
cmp.println(sProgress, Component.PRINT.PROGRESS);
});
}
if (!this.bindings["power"]) this.fAutoPower = true;
/*
* Power on the computer, giving every component the opportunity to reset or restore itself.
*/
if (!fSuspended && this.fAutoPower) this.wait(this.powerOn);
}
/**
* clearPanel()
*
* @this {Computer}
*/
clearPanel()
{
if (this.controlPanel) {
this.controlPanel.value = "";
}
}
/**
* enableDiagnostics()
*
* @this {Computer}
*/
enableDiagnostics()
{
if (!this.cDiagnosticScreens) {
for (let i = 0; i < this.aVideo.length; i++) {
let video = this.aVideo[i];
if (video) {
let control = video.getTextArea();
if (control) {
/*
* By default, the Video textarea overlay has opacity and lineHeight styles set to "0"
* to make the overall textarea and its blinking caret invisible (respectively), so in order
* to use it as a diagnostic display, we must temporarily set both those styles to "1".
*/
control.style.opacity = "1";
control.style.lineHeight = "1";
// control.style.fontSize = "1.5vw"; // this is a nice idea, but it doesn't work well with side-by-side machines
this.cDiagnosticScreens++;
}
}
}
}
}
/**
* disableDiagnostics()
*
* @this {Computer}
* @return {boolean} (true if diagnostics were, or already are, disabled; false if they remain enabled)
*/
disableDiagnostics()
{
if (this.cDiagnosticScreens) {
if (this.nDiagnostics == 2) {
this.nDiagnostics++;
this.println("Press any key to continue...");
return false;
}
for (let i = 0; i < this.aVideo.length; i++) {
let video = this.aVideo[i];
if (video) {
let control = video.getTextArea();
if (control) {
/*
* Return the Video textarea overlay's opacity and lineHeight styles to their original values.
*/
control.style.opacity = "0";
control.style.lineHeight = "0";
/*
* Setting lineHeight in IE isn't sufficient to hide the caret; we must also set fontSize to "0",
* and we make the change IE-specific because it can have weird side-effects in other browsers (eg,
* it makes Safari on iOS over-zoom whenever the textarea receives focus).
*/
if (Web.isUserAgent("MSIE")) control.style.fontSize = "0";
/*
* We no longer clear the text, to give the user/system a chance to copy it to the clipboard.
*
* control.value = "";
*/
}
}
}
this.cDiagnosticScreens = 0;
}
this.nDiagnostics = 0;
return true;
}
/**
* outputDiagnostics(sMessage, sType)
*
* @this {Computer}
* @param {string} sMessage
* @param {string} [sType]
*/
outputDiagnostics(sMessage, sType)
{
if (this.cDiagnosticScreens) {
for (let i = 0; i < this.aVideo.length; i++) {
let video = this.aVideo[i];
if (video) {
let control = video.getTextArea();
if (control) {
if (sType != Component.PRINT.PROGRESS || sMessage.slice(-3) != "...") {
Component.appendControl(control, sMessage + '\n');
} else {
Component.replaceControl(control, sMessage, sMessage + '.');
}
}
}
}
}
}
/**
* notifyKbdEvent(event, fDown)
*
* This is called by the Keyboard component for all key presses, and it is effectively a no-op except
* in the one special case where disableDiagnostics() has delayed powerOn until a key is pressed.
*
* @this {Computer}
* @param {Object} [event]
* @param {boolean} [fDown] is true for a keyDown event, false for a keyUp event
* @return {boolean} (true if diagnostics disabled, false if enabled -- at the time of the call)
*/
notifyKbdEvent(event, fDown)
{
let nDiagnostics = this.nDiagnostics;
if (this.nDiagnostics == 3) {
this.nDiagnostics++;
this.setReady(); // this may trigger a call to disableDiagnostics(), which is why we snapshot nDiagnostics
}
return !nDiagnostics;
}
/**
* getMachineID()
*
* @this {Computer}
* @return {string}
*/
getMachineID()
{
return this.sMachineID;
}
/**
* setMachineParms(parmsMachine)
*
* If no explicit machine parms were provided, then we check for 'parms' in the bundled resources (if any).
*
* @this {Computer}
* @param {Object} [parmsMachine]
*/
setMachineParms(parmsMachine)
{
if (!parmsMachine) {
let sParms;
if (typeof resources == 'object' && (sParms = resources['parms'])) {
try {
parmsMachine = /** @type {Object} */ (eval("(" + sParms + ")")); // jshint ignore:line
} catch(err) {
Component.error(err.message + " (" + sParms + ")");
}
}
}
this.parmsMachine = parmsMachine;
}
/**
* getMachineBoolean(sParm, fDefault)
*
* Boolean-specific version of getMachineParm().
*
* @this {Computer}
* @param {string} sParm
* @param {boolean} fDefault
* @return {boolean}
*/
getMachineBoolean(sParm, fDefault)
{
let f = fDefault;
let s = this.getMachineParm(sParm);
if (s != undefined) {
f = (s == "true"? true : (s == "false"? false : !!s));
}
return f;
}
/**
* getMachineParm(sParm, parmsComponent)
*
* If the machine parameter doesn't exist, we check for a matching component parameter (if parmsComponent
* is provided), and failing that, we check the bundled resources (if any).
*
* At the moment, the only bundled resource request we expect to encounter is 'state'; if it exists, then
* we return 'state' back to the caller (ie, the name of the resource), so that the caller will then attempt
* to load the 'state' resource to obtain the actual state.
*
* TODO: This function could (and perhaps should) be modified to accept an optional type parameter (ie,
* one of the values in Component.TYPE), so that parms like autoMount could be eval'ed here rather than by
* the caller (eg, FDC.parseConfig()). The downside is that this function would have to return multiple types,
* so every call would have to be cast to the expected type.
*
* @this {Computer}
* @param {string} sParm
* @param {Object} [parmsComponent] (eg, this.parms)
* @return {string|undefined}
*/
getMachineParm(sParm, parmsComponent)
{
let value = Web.getURLParm(sParm);
if (value) {
try {
/*
* Ideally, we could simply use strings as-is, but unfortunately, we need to convert all
* supported escape sequences to their underlying characters, and using eval() is the simplest
* way to deal with them; eg:
*
* \', \", \r, \n, \t, and \xNN
*
* When a string containing the above sequences is passed as a machine or component parameter
* (ie, as an embedPC() machine parameter or as XML component attribute), that conversion happens
* automatically, either by virtue of implicit script evaluation, or by explicit eval() in
* getComponentParms(). But when they're passed as a URL parameter, any backslashes are passed
* through as-is.
*
* The complete list of backslash sequences supported by JavaScript:
*
* \0 \' \" \\ \n \r \v \t \b \f \uXXXX \xXX
* ^J ^M ^K ^I ^H ^L
*
* and of course, eval() will convert them all, but there's no expectation of any but those I've
* listed above, in part because of Jekyll limitations in some of our templates; eg:
*
* https://github.com/jeffpar/pcjs/blob/jekyll/_includes/machine-engines.html
*
* which could be overcome, but there's really no need to support more, since \xNN can be used to
* represent anything else.
*
* Finally, while the user should escape any quotation characters, just to be safe, we will try to
* choose the safest quoting character for the overall string.
*/
let ch = value.indexOf("'") >= 0? '"' : "'";
value = /** @type {string} */ (eval(ch + value + ch)); // jshint ignore:line
} catch(err) {
Component.error(err.message + " (" + value + ")");
value = undefined;
}
}
if (value === undefined && this.parmsMachine) {
value = this.parmsMachine[sParm];
}
if (value === undefined && parmsComponent) {
value = parmsComponent[sParm];
}
if (!value && typeof resources == 'object') {
if (resources[sParm]) {
value = sParm;
}
else {
try {
let parms = JSON.parse(resources['parms']);
value = parms[sParm];
}
catch(err) {
Component.error(err.message + " (" + resources['parms'] + ")");
}
}
}
return value;
}
/**
* saveMachineParms()
*
* @this {Computer}
* @return {string|null}
*/
saveMachineParms()
{
return this.parmsMachine? JSON.stringify(this.parmsMachine) : null;
}
/**
* getUserID()
*
* @this {Computer}
* @return {string}
*/
getUserID()
{
return this.sUserID || "";
}
/**
* doneLoad(sURL, sStateData, nErrorCode)
*
* @this {Computer}
* @param {string} sURL
* @param {string} sStateData
* @param {number} nErrorCode
*/
doneLoad(sURL, sStateData, nErrorCode)
{
if (!nErrorCode) {
Component.addMachineResource(this.idMachine, sURL, sStateData);
this.sStateData = sStateData;
this.fStateData = true;
if (DEBUG) this.printf("loaded state file %s\n", sURL.replace(this.sUserID || "xxx", "xxx"));
} else {
this.sResumePath = null;
this.fServerState = false;
this.notice('Unable to load machine state from server (error ' + nErrorCode + (sStateData? ': ' + Str.trim(sStateData) : '') + ')');
}
this.setReady();
}
/**
* wait(fn, parms)
*
* wait() waits until every component is ready (including ourselves, the last component we check), then calls the
* specified Computer method.
*
* TODO: The Closure Compiler makes it difficult for us to define a function type for "fn" that works in all cases;
* sometimes we want to pass a function that takes only a "number", and other times we want to pass a function that
* takes only an "Array" (the type will mirror that of the "parms" parameter). However, the Closure Compiler insists
* that both functions must be declared as accepting both types of parameters. So once again, we must use an untyped
* function declaration, instead of something stricter like:
*
* param {function(this:Computer, (number|Array|undefined)): undefined} fn
*
* @this {Computer}
* @param {function(...)} fn
* @param {number|Array} [parms] optional parameters
*/
wait(fn, parms)
{
let computer = this;
let aComponents = Component.getComponents(this.id);
for (let iComponent = 0; iComponent <= aComponents.length; iComponent++) {
let component = (iComponent < aComponents.length? aComponents[iComponent] : this);
if (!component.isReady()) {
component.isReady(function onComponentReady() {
computer.wait(fn, parms);
});
return;
}
}
if (DEBUG) this.printf("Computer.wait(ready)\n");
fn.call(this, parms);
}
/**
* validateState(stateComputer)
*
* NOTE: We clear() stateValidate only when there's no stateComputer.
*
* @this {Computer}
* @param {State|null} [stateComputer]
* @return {boolean} true if state passes validation, false if not
*/
validateState(stateComputer)
{
let fValid = true;
let stateValidate = new State(this, PCx86.APPVERSION, Computer.STATE_VALIDATE);
if (stateValidate.load() && stateValidate.parse()) {
let sTimestampValidate = stateValidate.get(Computer.STATE_TIMESTAMP);
let sTimestampComputer = stateComputer ? stateComputer.get(Computer.STATE_TIMESTAMP) : "unknown";
if (sTimestampValidate != sTimestampComputer) {
this.notice("Machine state may be out-of-date\n(" + sTimestampValidate + " vs. " + sTimestampComputer + ")\nCheck your browser's local storage limits");
fValid = false;
if (!stateComputer) stateValidate.clear();
} else {
if (DEBUG) this.printf("Last state: %s (validate: %s)\n", sTimestampComputer, sTimestampValidate);
}
}
return fValid;
}
/**
* powerOn(resume)
*
* Power every component "up", applying any previously available state information.
*
* @this {Computer}
* @param {number} [resume] is a valid RESUME value; default is this.resume
*/
powerOn(resume)
{
if (resume === undefined) {
resume = this.resume || (this.sStateData? Computer.RESUME_AUTO : Computer.RESUME_NONE);
}
if (DEBUG) this.printf("Computer.powerOn(%s)\n", (resume == Computer.RESUME_REPOWER ? "repower" : (resume ? "resume" : "")));
if (this.nPowerChange) {
return;
}
this.nPowerChange++;
let fRepower = false;
let fRestore = false;
this.fRestoreError = false;
let stateComputer = this.stateComputer || new State(this, PCx86.APPVERSION);
if (resume == Computer.RESUME_REPOWER) {
fRepower = true;
}
else if (resume > Computer.RESUME_NONE) {
if (stateComputer.load(this.sStateData)) {
/*
* Since we're resuming something (either a predefined state or a state from localStorage), let's
* create a "failsafe" checkpoint in localStorage, and destroy it at the end of a successful powerOn().
* Which means, of course, that if a previous "failsafe" checkpoint already exists, something bad
* may have happened the last time around.
*/
this.stateFailSafe = new State(this, PCx86.APPVERSION, Computer.STATE_FAILSAFE);
if (this.stateFailSafe.load()) {
if (resume != Computer.RESUME_AUTO && this.powerReport(stateComputer)) {
/*
* Prompt the user; if they decline to restore, the state will be removed.
*/
resume = Computer.RESUME_PROMPT;
}
/*
* To ensure that the set() below succeeds, we need to call unload(), otherwise it may fail
* with a "read only" error (eg, "TypeError: Cannot assign to read only property 'timestamp'").
*/
this.stateFailSafe.unload();
}
this.stateFailSafe.set(Computer.STATE_TIMESTAMP, Usr.getTimestamp());
this.stateFailSafe.store();
let fValidate = this.resume && !this.fServerState;
if (resume == Computer.RESUME_AUTO || Component.confirmUser("Click OK to restore the previous " + PCx86.APPNAME + " machine state.")) {
fRestore = stateComputer.parse();
if (fRestore) {
let sCode = stateComputer.get(UserAPI.RES.CODE);
let sData = stateComputer.get(UserAPI.RES.DATA);
if (sCode) {
if (sCode == UserAPI.CODE.OK) {
stateComputer.load(/** @type {string} */ (sData));
} else {
/*
* A missing (or not yet created) state file is no cause for alarm, but other errors might be
*/
if (sCode == UserAPI.CODE.FAIL && sData != UserAPI.FAIL.NOSTATE) {
this.notice("Error: " + sData);
if (sData == UserAPI.FAIL.VERIFY) this.resetUserID();
} else {
this.println(sCode + ": " + sData);
}
/*
* Try falling back to the state that we should have saved in localStorage, as a backup to the
* server-side state.
*/
stateComputer.unload(); // discard the invalid server-side state first
if (stateComputer.load()) {
fRestore = stateComputer.parse();
fValidate = true;
} else {
fRestore = false; // hmmm, there was nothing in localStorage either
}
}
}
}
/*
* If the load/parse was successful, and it was from localStorage (not sStateData),
* then we should to try verify that localStorage snapshot is current. One reason it may
* NOT be current is if localStorage was full and we got a quota error during the last
* powerOff().
*/
if (fValidate) this.validateState(fRestore? stateComputer : null);
} else {
/*
* RESUME_PROMPT indicates we should delete the state if they clicked Cancel to confirm() above.
*/
if (resume == Computer.RESUME_PROMPT) stateComputer.clear();
}
} else {
/*
* If there's no state, then there should also be no validation timestamp; if there is, then once again,
* we're probably dealing with a quota error.
*/
this.validateState();
}
delete this.sStateData;
delete this.stateComputer;
}
/*
* Start powering all components, including any data they may need to restore their state;
* we restore power to the CPU last.
*/
let aComponents = Component.getComponents(this.id);
for (let iComponent = 0; iComponent < aComponents.length; iComponent++) {
let component = aComponents[iComponent];
if (component !== this && component != this.cpu) {
try {
fRestore = this.powerRestore(component, stateComputer, fRepower, fRestore);
} catch(err) {
Component.error(component.type + " restore failure: " + err.message);
}
}
}
/*
* Assuming this is not a repower, we must perform another wait, because some components may
* have marked themselves as "not ready" again (eg, the FDC component, if the restore forced it
* to mount one or more additional disk images).
*/
let aParms = [stateComputer, resume, fRestore];
if (resume != Computer.RESUME_REPOWER) {
this.wait(this.donePowerOn, aParms);
return;
}
this.donePowerOn(aParms);
}
/**
* powerRestore(component, stateComputer, fRepower, fRestore)
*
* @this {Computer}
* @param {Component} component
* @param {State} stateComputer
* @param {boolean} fRepower
* @param {boolean} fRestore
* @return {boolean} true if restore should continue, false if not
*/
powerRestore(component, stateComputer, fRepower, fRestore)
{
if (!component.flags.powered) {
component.flags.powered = true;
if (component.powerUp) {
let data = null;
if (fRestore) {
data = stateComputer.get(component.id);
if (!data) {
/*
* This is a hack that makes it possible for a machine whose ID has been
* supplemented with a hyphenated numeric suffix to find object IDs in states
* created from a machine without such a suffix.
*
* For example, if a state file was created from a machine with ID "ibm5160"
* but the current machine is "ibm5160-1", this attempts a second lookup with
* "ibm5160", enabling us to find objects that match the original machine ID
* (eg, "ibm5160.romEGA").
*
* See /devices/pcx86/machine/5160/ega/640kb/array for examples of this.
*/
data = stateComputer.get(component.id.replace(/-[0-9]+\./i, '.'));
}
}
/*
* State.get() will return whatever was originally passed to State.set() (eg, an
* Object or a string), but components are supposed to store only Objects, so if a
* string comes back, something went wrong. By explicitly eliminating "string" data,
* the Closure Compiler stops complaining that we might be passing strings to our
* powerUp() functions (even though we know we're not). We could also add @type
* overrides to the data assignments, but this seems like a useful runtime check.
*/
if (typeof data === "string") data = null;
/*
* If computer is null, this is simply a repower notification, which most components
* don't do anything with. Exceptions include: CPU (since it may be halted) and Video
* (since its screen may be "turned off").
*/
if (!component.powerUp(data, fRepower) && data) {
if (component.notice("Unable to restore hardware state")) {
/*
* If this is a resume error for a machine that also has a predefined state
* AND we're not restoring from that state, then throw away the current state,
* prevent any new state from being created, and then force a reload, which will
* hopefully restore us to the functioning predefined state.
*
* TODO: Considering doing this in ALL cases, not just in situations where a
* 'state' exists but we're not actually resuming from it.
*/
if (this.sStatePath && !this.fStateData) {
stateComputer.clear();
this.resume = Computer.RESUME_NONE;
Web.reloadPage();
} else {
/*
* In all other cases, we set fRestoreError, which should trigger a call to
* powerReport() and then delete the offending state.
*/
this.fRestoreError = true;
}
}
/*
* Any failure triggers an automatic to call powerUp() again, without any state,
* in the hopes that the component can recover by performing a reset.
*/
component.powerUp(null);
/*
* We also disable the rest of the restore operation, because it's not clear
* the remaining state information can be trusted; the machine is already in an
* inconsistent state, so we're not likely to make things worse, and the only
* alternative (starting over and performing a state-less reset) isn't likely to make
* the user any happier. But, we'll see... we need some experience with the code.
*/
fRestore = false;
}
}
component.flags.initDone = true;
if (!fRepower && component.comment) {
let asComments = component.comment.split("|");
for (let i = 0; i < asComments.length; i++) {
component.status(asComments[i]);
}
}
}
return fRestore;
}
/**
* donePowerOn(aParms)
*
* This is nothing more than a continuation of powerOn(), giving us the option of calling wait() one more time.
*
* @this {Computer}
* @param {Array} aParms containing [stateComputer, resume, fRestore]
*/
donePowerOn(aParms)
{
if (!this.flags.initDone) {
if (!this.disableDiagnostics()) {
this.setReady(false);
this.wait(this.donePowerOn, aParms);
return;
}
this.flags.initDone = true;
}
if (DEBUG && this.flags.powered) this.printf("Computer.donePowerOn(): redundant\n");
let stateComputer = aParms[0];
let fRepower = (aParms[1] < 0);
let fRestore = aParms[2];