source: buchla-68k/ram/scinit.c@ 06f6615

Last change on this file since 06f6615 was b28a12e, checked in by Thomas Lopatic <thomas@…>, 7 years ago

Zero redundant declarations.
  • Property mode set to 100644
File size: 11.5 KB
Line 
1/*
2 =============================================================================
3 scinit.c -- score list functions
4 Version 33 -- 1988-07-28 -- D.N. Lynx Crowe
5
6 long
7 scinit()
8
9 Initializes the score data structures.
10 Returns the number of free storage units.
11
12 struct s_entry *
13 e_clr(e1)
14 struct s_entry *e1;
15
16 Clears the event pointed to by 'e1'. Returns 'e1'.
17 Preserves e_size field, all others set to zero.
18
19 struct s_entry *
20 e_ins(e1, e2)
21 struct s_entry *e1, *e2;
22
23 Inserts the event pointed to by 'e1' after the event
24 pointed to by 'e2'. Returns 'e1'.
25
26 struct s_entry *
27 e_rmv(e1)
28 struct s_entry *e1;
29
30 Removes the event pointed to by 'e1' from the list it's in.
31 Returns 'e1'.
32
33 struct s_entry *
34 e_alc(w)
35 int w;
36
37 Allocates a new event entry.
38 Returns the event entry address, or E_NULL
39 if none can be allocated.
40
41 short
42 e_del(e1)
43 struct s_entry *e1;
44
45 Deallocates the event entry pointed to by 'e1'.
46 Returns 0 if successful, 1 if not.
47
48 long
49 evleft()
50
51 Returns total number of longs left for score storage.
52
53
54 eh_ins(ne, et)
55 struct s_entry *ne;
56 short et;
57
58 Inserts event 'ne' of type 'et' into score header list
59 "hplist[curscor][et]" along the "up" chain.
60
61 eh_rmv(ev, et)
62 struct s_entry *ev;
63 short et;
64
65 Removes event 'ev' of type 'et' from score header list
66 "hplist[curscor][et]" along the "up" chain.
67
68 sc_clr(ns)
69 short ns;
70
71 Clears score 'ns'.
72
73 short
74 selscor(ns)
75 short ns;
76
77 Selects score 'ns' for use.
78
79 =============================================================================
80*/
81
82#include "ram.h"
83
84/*
85 =============================================================================
86 evleft() -- returns total number of longs left for score storage.
87 =============================================================================
88*/
89
90int32_t evleft(void)
91{
92 return(spcount + (se1_cnt * E_SIZE1) + (se2_cnt * E_SIZE2) +
93 (se3_cnt * E_SIZE3));
94}
95
96/*
97
98*/
99
100/*
101 =============================================================================
102 scinit() -- initializes the score data structures.
103 Returns the number of free storage units.
104 =============================================================================
105*/
106
107int32_t scinit(void)
108{
109 register int32_t i, *cp;
110
111 se1_cnt = 0L; /* fragments */
112 size1 = E_NULL;
113 se2_cnt = 0L;
114 size2 = E_NULL;
115 se3_cnt = 0L;
116 size3 = E_NULL;
117 se_chg = TRUE;
118 frags = 0L;
119
120 spcount = (int32_t)MAX_SE; /* storage pool */
121 pspool = spool;
122 cp = spool;
123
124 for (i = spcount; i-- > 0; )
125 *cp++ = 0L;
126
127 for (i = 0; i < N_SCORES; i++) /* score names */
128 memcpy(scname[i], "{ empty score }", 16);
129
130 memsetw(scores, 0, 2 * N_SCORES); /* score list */
131 memsetw(hplist, 0, 2 * N_SCORES * N_TYPES); /* header lists */
132 memsetw(seclist, 0, 2 * N_SCORES * N_SECTS); /* section lists */
133 memset(stimes, 0, 12 * N_SCORES * N_SECTS); /* section times */
134
135 t_cur = t_ctr = 0L; /* times */
136 t_bak = t_cur - TO_BAK;
137 t_fwd = t_cur + TO_FWD;
138
139 p_bak = E_NULL; /* pointers */
140 p_cur = E_NULL;
141 p_ctr = E_NULL;
142 p_fwd = E_NULL;
143 scp = E_NULL;
144
145 curscor = 0; /* current score */
146 cursect = 0; /* current section */
147
148 return(evleft());
149}
150
151/*
152
153*/
154
155/*
156 =============================================================================
157 e_clr(e1) -- clear the event pointed to by 'e1'. Returns 'e1'.
158 Preserves e_size field, all others set to zero.
159 =============================================================================
160*/
161
162struct s_entry *e_clr(struct s_entry *e1)
163{
164 switch (e1->e_size) {
165
166 case E_SIZE3:
167
168 e1->e_lft = E_NULL;
169 e1->e_rgt = E_NULL;
170
171 case E_SIZE2:
172
173 e1->e_up = E_NULL;
174 e1->e_dn = E_NULL;
175
176 case E_SIZE1:
177
178 e1->e_fwd = E_NULL;
179 e1->e_bak = E_NULL;
180
181 e1->e_time = 0L;
182 e1->e_type = EV_NULL;
183 e1->e_data1 = 0;
184 e1->e_data2 = 0;
185 }
186
187 return(e1);
188}
189
190/*
191
192*/
193
194/*
195 =============================================================================
196 e_ins(e1, e2) -- inserts the event pointed to by 'e1' after the event
197 pointed to by 'e2'. Returns 'e1'.
198 =============================================================================
199*/
200
201struct s_entry *e_ins(struct s_entry *e1, struct s_entry *e2)
202{
203 register struct s_entry *t1;
204
205 t1 = e2->e_fwd;
206 e1->e_fwd = t1;
207 e1->e_bak = e2;
208 e2->e_fwd = e1;
209 t1->e_bak = e1;
210 return(e1);
211}
212
213/*
214 =============================================================================
215 e_rmv(e1) -- removes the event pointed to by 'e1' from the list it's in.
216 Returns 'e1'.
217 =============================================================================
218*/
219
220struct s_entry *e_rmv(struct s_entry *e1)
221{
222 register struct s_entry *t1, *t2;
223
224 t1 = e1->e_bak;
225 t2 = e1->e_fwd;
226 t1->e_fwd = t2;
227 t2->e_bak = t1;
228 e1->e_fwd = E_NULL;
229 e1->e_bak = E_NULL;
230 return(e1);
231}
232
233/*
234
235*/
236
237/*
238 =============================================================================
239 e_alc() -- allocates a new event entry.
240 Returns the event entry address, or E_NULL if none can be allocated.
241 =============================================================================
242*/
243
244struct s_entry *e_alc(int16_t w)
245{
246 register struct s_entry *ev, *ex;
247
248 se_chg = TRUE;
249
250 switch (w) {
251
252 case E_SIZE1:
253
254 if (spcount LT E_SIZE1) { /* try raw free pool first */
255
256 if (se1_cnt EQ 0) { /* try for a deleted entry */
257
258 if (se3_cnt) { /* try to split a size3 entry */
259
260 ex = size3;
261 size3 = ex->e_fwd;
262 ++frags;
263 --se3_cnt;
264 ex->e_size = E_SIZE1;
265 ex->e_fwd = E_NULL;
266 return(ex);
267
268 } else {
269
270 if (se2_cnt) { /* try a size2 split */
271
272 ex = size2;
273 size2 = size2->e_fwd;
274 ex->e_size = E_SIZE1;
275 ex->e_fwd = E_NULL;
276 ++frags;
277 --se2_cnt;
278 return(ex);
279
280 } else {
281
282 return(E_NULL); /* no space */
283 }
284 }
285/*
286
287*/
288 } else { /* deleted entry available */
289
290 ex = size1;
291 size1 = size1->e_fwd;
292 ex->e_fwd = E_NULL;
293 --se1_cnt;
294 return(ex);
295 }
296
297 } else { /* raw storage available */
298
299 ex = (struct s_entry *)pspool;
300 pspool += E_SIZE1;
301 spcount -= E_SIZE1;
302 ex->e_size = E_SIZE1;
303 return(ex);
304 }
305
306/*
307
308*/
309
310 case E_SIZE2:
311
312 if (spcount LT E_SIZE2) { /* try for raw storage */
313
314 if (se2_cnt EQ 0) { /* try for a deleted entry */
315
316 if (se3_cnt) { /* try to split a size3 entry */
317
318 ex = size3;
319 size3 = size3->e_fwd;
320 ex->e_size = E_SIZE2;
321 ex->e_fwd = E_NULL;
322 --se3_cnt;
323 ++frags;
324 return(ex);
325
326 } else {
327
328 return(E_NULL); /* no space */
329 }
330
331 } else { /* deleted entry available */
332
333 ex = size2;
334 size2 = size2->e_fwd;
335 ex->e_fwd = E_NULL;
336 --se2_cnt;
337 return(ex);
338 }
339
340 } else { /* raw storage available */
341
342 ex = (struct s_entry *)pspool;
343 pspool += E_SIZE2;
344 spcount -= E_SIZE2;
345 ex->e_size = E_SIZE2;
346 return(ex);
347
348 }
349
350/*
351
352*/
353
354 case E_SIZE3:
355
356 if (spcount LT E_SIZE3) { /* try for raw storage */
357
358 if (se3_cnt EQ 0) { /* try for a deleted entry */
359
360 return(E_NULL); /* no space left */
361
362 } else { /* deleted entry available */
363
364 ex = size3;
365 size3 = size3->e_fwd;
366 ex->e_fwd = E_NULL;
367 --se3_cnt;
368 return(ex);
369 }
370
371 } else { /* raw storage available */
372
373 ex = (struct s_entry *)pspool;
374 pspool += E_SIZE3;
375 spcount -= E_SIZE3;
376 ex->e_size = E_SIZE3;
377 return(ex);
378 }
379
380 default:
381
382 return(E_NULL); /* invalid request */
383 }
384
385 return(E_NULL); /* something went 'worng' ... */
386}
387
388/*
389
390*/
391
392/*
393 =============================================================================
394 e_del(e1) -- deallocates the event entry pointed to by 'e1'.
395 Returns 0 if successful, 1 if not.
396 =============================================================================
397*/
398
399int16_t e_del(struct s_entry *e1)
400{
401 e_clr(e1);
402
403 switch (e1->e_size) {
404
405 case E_SIZE1:
406
407 e1->e_fwd = size1;
408 size1 = e1;
409 ++se1_cnt;
410 break;
411
412 case E_SIZE2:
413
414 e1->e_fwd = size2;
415 size2 = e1;
416 ++se2_cnt;
417 break;
418
419 case E_SIZE3:
420
421 e1->e_fwd = size3;
422 size3 = e1;
423 ++se3_cnt;
424 break;
425
426 default:
427 return(1);
428 }
429
430 se_chg = TRUE;
431 return(0);
432}
433
434/*
435
436*/
437
438/*
439 =============================================================================
440 eh_ins(ne, et) -- insert event 'ne' of type 'et' into score header list
441 "hplist[curscor][et]" along the "up" chain.
442 =============================================================================
443*/
444
445void eh_ins(struct s_entry *ne, int16_t et)
446{
447 register struct s_entry *hp, *ep;
448
449 hp = hplist[curscor][et]; /* get list pointer */
450
451 if (hp EQ E_NULL) { /* if list was empty */
452
453 hplist[curscor][et] = ne; /* start the list */
454 ne->e_up = E_NULL;
455 ne->e_dn = E_NULL;
456 return;
457 }
458
459 if (hp->e_time GT ne->e_time) { /* if first entry was later */
460
461 hp->e_dn = ne; /* add to start of list */
462 ne->e_up = hp;
463 ne->e_dn = E_NULL;
464 hplist[curscor][et] = ne;
465 return;
466 }
467
468 while (E_NULL NE (ep = hp->e_up)) { /* search forward */
469
470 if (ep->e_time GT ne->e_time) { /* if we find a later event */
471
472 ne->e_up = ep; /* insert into list */
473 ne->e_dn = hp;
474 hp->e_up = ne;
475 ep->e_dn = ne;
476 return;
477 }
478
479 hp = ep;
480 }
481
482 hp->e_up = ne; /* add to end of list */
483 ne->e_up = E_NULL;
484 ne->e_dn = hp;
485 return;
486}
487
488/*
489
490*/
491
492/*
493 =============================================================================
494 eh_rmv(ev, et) -- remove event 'ev' of type 'et' from score header list
495 "hplist[curscor][et]" along the "up" chain.
496 =============================================================================
497*/
498
499void eh_rmv(struct s_entry *ev, int16_t et)
500{
501 if (hplist[curscor][et] EQ ev) /* update hplist */
502 hplist[curscor][et] = ev->e_up;
503
504 if (ev->e_up NE E_NULL) /* update entry above */
505 (ev->e_up)->e_dn = ev->e_dn;
506
507 if (ev->e_dn NE E_NULL) /* update entry below */
508 (ev->e_dn)->e_up = ev->e_up;
509
510 ev->e_up = ev->e_dn = E_NULL; /* update entry itself */
511}
512
513/*
514
515*/
516
517/*
518 =============================================================================
519 sc_clr(ns) -- clear score 'ns'.
520 =============================================================================
521*/
522
523void sc_clr(int16_t ns)
524{
525 register struct s_entry *dsp, *nsp;
526 register int16_t i;
527
528 if (E_NULL NE (nsp = scores[ns])) {
529
530 while (nsp NE (dsp = nsp->e_fwd)) {
531
532 e_del(e_rmv(nsp)); /* delete this one */
533 nsp = dsp; /* point at the next one */
534
535 }
536
537 e_del(nsp); /* delete final entry */
538 }
539
540 for (i = 0; i < N_TYPES; i++) /* clear header list */
541 hplist[ns][i] = E_NULL;
542
543 for (i = 0; i < N_SECTS; i++) { /* clear section lists */
544
545 seclist[ns][i] = E_NULL;
546 memset(stimes[ns], 0, 12);
547 }
548
549 memcpy(scname[ns], "{ empty score }", 16);
550
551 scores[ns] = E_NULL;
552}
553
554/*
555
556*/
557
558/*
559 =============================================================================
560 selscor(ns) -- select score 'ns' for use
561 =============================================================================
562*/
563
564int16_t selscor(int16_t ns)
565{
566 register int16_t oldscor, grp;
567 register struct s_entry *nsp, *ep;
568
569 clkset(0); /* stop the clock */
570 dsclk();
571 fc_val = 0L; /* reset to start of score */
572 sd = D_FWD;
573 oldscor = curscor; /* setup for new score */
574 curscor = ns;
575
576 if (E_NULL EQ (nsp = scores[ns])) { /* initialize score if needed */
577
578 if (E_NULL EQ (nsp = e_alc(E_SIZE1))) { /* score header */
579
580 curscor = oldscor;
581 return(FAILURE);
582 }
583
584 scores[ns] = nsp;
585 nsp->e_fwd = nsp;
586 nsp->e_bak = nsp;
587 nsp->e_type = EV_SCORE;
588 nsp->e_data1 = ns;
589 nsp->e_time = 0L;
590
591 if (E_NULL EQ (ep = e_alc(E_SIZE1))) { /* score end */
592
593 sc_clr(ns);
594 curscor = oldscor;
595 return(FAILURE);
596 }
597
598 ep->e_type = EV_FINI;
599 ep->e_data1 = ns;
600 e_ins(ep, nsp);
601 ep->e_time = 0x7FFFFFFFL;
602 nsp = scores[ns];
603 memcpy(&scname[ns][0], "%%% Untitled %%%", 16);
604 }
605
606 scp = nsp;
607 p_bak = nsp;
608 p_cur = nsp;
609 p_ctr = nsp;
610 p_fwd = nsp;
611 cursect = 0;
612 sc_goto(0L);
613 return(SUCCESS);
614}
615
Note: See TracBrowser for help on using the repository browser.