source: buchla-68k/ram/scinit.c@ 60288f5

Last change on this file since 60288f5 was 0580615, checked in by Thomas Lopatic <thomas@…>, 7 years ago

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