source: buchla-68k/ram/scinit.c@ 6262b5c

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

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