home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / misc / volume43 / tclmidi / part03 < prev    next >
Internet Message Format  |  1994-07-21  |  62KB
  1. From: durian@boogie.com (Mike Durian)
  2. Newsgroups: comp.sources.misc
  3. Subject: v43i111:  tclmidi - A language for manipulating MIDI files, v2.0, Part03/14
  4. Date: 21 Jul 1994 19:26:14 -0500
  5. Organization: Sterling Software
  6. Sender: kent@sparky.sterling.com
  7. Approved: kent@sparky.sterling.com
  8. Message-ID: <30n3n6$723@sparky.sterling.com>
  9. X-Md4-Signature: 5bd81fb02b7ba888918fdfd2db8e01b7
  10.  
  11. Submitted-by: durian@boogie.com (Mike Durian)
  12. Posting-number: Volume 43, Issue 111
  13. Archive-name: tclmidi/part03
  14. Environment: POSIX, (BSDI, NetBSD, LINUX, SVR4 for optional driver), C++, TCL
  15. Supersedes: tclm: Volume 37, Issue 43-47
  16.  
  17. #! /bin/sh
  18. # This is a shell archive.  Remove anything before this line, then feed it
  19. # into a shell via "sh file" or similar.  To overwrite existing files,
  20. # type "sh file -c".
  21. # Contents:  tclmidi-2.0/drivers/LINUX/Makefile
  22. #   tclmidi-2.0/drivers/SVR4/midi.c tclmidi-2.0/rb/rb.c
  23. # Wrapped by kent@sparky on Thu Jul 21 19:05:13 1994
  24. PATH=/bin:/usr/bin:/usr/ucb:/usr/local/bin:/usr/lbin:$PATH ; export PATH
  25. echo If this archive is complete, you will see the following message:
  26. echo '          "shar: End of archive 3 (of 14)."'
  27. if test -f 'tclmidi-2.0/drivers/LINUX/Makefile' -a "${1}" != "-c" ; then 
  28.   echo shar: Will not clobber existing file \"'tclmidi-2.0/drivers/LINUX/Makefile'\"
  29. else
  30.   echo shar: Extracting \"'tclmidi-2.0/drivers/LINUX/Makefile'\" \(301 characters\)
  31.   sed "s/^X//" >'tclmidi-2.0/drivers/LINUX/Makefile' <<'END_OF_FILE'
  32. XEXTRAFLAGS = -Wall -Wstrict-prototypes -O2 -fomit-frame-pointer -pipe -m486
  33. XCFLAGS = -DLOADABLE -D__KERNEL__ -DLINUX $(EXTRAFLAGS)
  34. X
  35. Xmidimodule.o: release.h midi.o midiconf.o quad.o
  36. X    ld -r -o midimodule.o midi.o midiconf.o quad.o
  37. X
  38. Xrelease.h:
  39. X    @echo char kernel_version[] = \"`uname -r`\"\; > release.h
  40. END_OF_FILE
  41.   if test 301 -ne `wc -c <'tclmidi-2.0/drivers/LINUX/Makefile'`; then
  42.     echo shar: \"'tclmidi-2.0/drivers/LINUX/Makefile'\" unpacked with wrong size!
  43.   fi
  44.   # end of 'tclmidi-2.0/drivers/LINUX/Makefile'
  45. fi
  46. if test -f 'tclmidi-2.0/drivers/SVR4/midi.c' -a "${1}" != "-c" ; then 
  47.   echo shar: Will not clobber existing file \"'tclmidi-2.0/drivers/SVR4/midi.c'\"
  48. else
  49.   echo shar: Extracting \"'tclmidi-2.0/drivers/SVR4/midi.c'\" \(42554 characters\)
  50.   sed "s/^X//" >'tclmidi-2.0/drivers/SVR4/midi.c' <<'END_OF_FILE'
  51. X/*-
  52. X * Copyright (c) 1993, 1994 Michael B. Durian.  All rights reserved.
  53. X *
  54. X * Redistribution and use in source and binary forms, with or without
  55. X * modification, are permitted provided that the following conditions
  56. X * are met:
  57. X * 1. Redistributions of source code must retain the above copyright
  58. X *    notice, this list of conditions and the following disclaimer.
  59. X * 2. Redistributions in binary form must reproduce the above copyright
  60. X *    notice, this list of conditions and the following disclaimer in the
  61. X *    documentation and/or other materials provided with the distribution.
  62. X * 3. All advertising materials mentioning features or use of this software
  63. X *    must display the following acknowledgement:
  64. X *    This product includes software developed by Michael B. Durian.
  65. X * 4. The name of the the Author may be used to endorse or promote 
  66. X *    products derived from this software without specific prior written 
  67. X *    permission.
  68. X *
  69. X * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED 
  70. X * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  71. X * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  
  72. X * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
  73. X * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  74. X * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  75. X * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  76. X * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  77. X * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  78. X * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  79. X * SUCH DAMAGE.
  80. X */
  81. X
  82. X#define INKERNEL 1
  83. X#define _KERNEL 1
  84. X
  85. X#include <sys/sysmacros.h>
  86. X#include <sys/types.h>
  87. X#include <sys/param.h>
  88. X#include <sys/file.h>
  89. X#include <sys/dir.h>
  90. X#include <sys/signal.h>
  91. X#include <sys/user.h>
  92. X#include <sys/systm.h>
  93. X#include <sys/errno.h>
  94. X#include <sys/open.h>
  95. X#include <sys/uio.h>
  96. X#include <sys/cred.h>
  97. X#include <sys/ddi.h>
  98. X#include <sys/poll.h>
  99. X#include <sys/kmem.h>
  100. X#include <sys/filio.h>
  101. X#include <sys/termios.h>
  102. X
  103. X#include "midi.h"
  104. X
  105. Xextern struct midi_softc midi_sc[];
  106. Xextern int midi_addrs[];
  107. Xextern int midi_intrs[];
  108. Xextern int NumMidi;
  109. X
  110. X#if defined(__STDC__) || defined(__cplusplus)
  111. X#define __P(protos)    protos
  112. X#else
  113. X#define __P(protos)    ()
  114. X#endif
  115. X
  116. X/* I've been burned too many times by different byte ordering */
  117. X#define OUTB(x, y) outb((x), (y))
  118. X#define INB(x) inb((x))
  119. X
  120. Xvoid midiinit __P(());
  121. Xint midiopen __P((dev_t *dev, int flag, int otyp, cred_t *cred_p));
  122. Xint midiclose __P((dev_t dev, int flag, int otyp, cred_t *cred_p));
  123. Xint midiread __P((dev_t dev, uio_t *uio_p, cred_t *cred_p));
  124. Xint midiwrite __P((dev_t dev, uio_t *uio_p, cred_t *cred_p));
  125. Xint midiioctl __P((dev_t dev, int cmd, int arg, int mode, cred_t *cred_p,
  126. X    int *rval_p));
  127. Xint midipoll __P((dev_t dev, int /* short */ events, int anyyet,
  128. X    short *reventsp, struct pollhead **phpp));
  129. Xint midiintr __P((int ivec));
  130. X
  131. Xstatic void midi_copy_event __P((struct event *, struct event *));
  132. Xstatic void midi_initq __P((struct event_queue *));
  133. Xstatic int midi_deq __P((struct event_queue *, struct event **));
  134. Xstatic int midi_peekq __P((struct event_queue *, struct event **));
  135. Xstatic int midi_enq __P((struct event_queue *, struct event *));
  136. Xstatic int midi_reset __P((struct midi_softc *));
  137. Xstatic int midi_wait_rdy_rcv __P((struct midi_softc *softc));
  138. Xstatic int midi_send_command __P((struct midi_softc *softc,
  139. X    /* u_char */ int comm));
  140. Xstatic int midi_uart __P((struct midi_softc *));
  141. Xstatic int midi_event2smf __P((struct midi_softc *, struct event *,
  142. X    struct stynamic *));
  143. Xstatic int midi_next_byte __P((struct midi_softc *, struct uio *));
  144. Xstatic int midi_uio2event __P((struct midi_softc *, struct uio *,
  145. X    struct event *));
  146. Xstatic int midi_fix2var __P((u_long, u_char *));
  147. Xstatic int midi_var2fix __P((u_char *, u_long *));
  148. Xstatic u_long midi_smf2kernel_tick __P((struct midi_softc *, long));
  149. Xstatic u_long midi_kernel2smf_tick __P((struct midi_softc *, long, long));
  150. Xstatic void midi_timeout __P((caddr_t arg));
  151. Xstatic void midi_add_complete_event __P((struct midi_softc *));
  152. Xstatic void midi_schedule_timeout __P((struct midi_softc *));
  153. Xstatic void midi_write_event __P((struct midi_softc *, struct event *));
  154. Xstatic void midi_reset_devices __P((struct midi_softc *));
  155. Xstatic void stynamic_add_byte __P((struct stynamic *, int /* u_char */));
  156. Xstatic void stynamic_add_bytes __P((struct stynamic *, u_char *, int));
  157. Xstatic u_char stynamic_get_byte __P((struct stynamic *, int));
  158. Xstatic void stynamic_copy __P((struct stynamic *, void *, int));
  159. Xstatic void stynamic_copy_from __P((struct stynamic *, int, void *, int));
  160. Xstatic void stynamic_append __P((struct stynamic *, struct stynamic *));
  161. Xstatic void stynamic_release __P((struct stynamic *));
  162. Xstatic void stynamic_shift __P((struct stynamic *, int));
  163. Xstatic void stynamic_init __P((struct stynamic *));
  164. Xstatic void stynamic_print __P((struct stynamic *));
  165. Xstatic int midi_killable __P((proc_t *owner, int pid));
  166. X
  167. Xvoid
  168. Xmidiinit()
  169. X{
  170. X    struct midi_softc *softc;
  171. X    int i;
  172. X
  173. X    for (i = 0; i < NumMidi; i++) {
  174. X        softc = &midi_sc[i];
  175. X        softc->addr = midi_addrs[i];
  176. X        softc->intr = midi_intrs[i];
  177. X        softc->status = MIDI_RD_BLOCK;
  178. X        if (!midi_reset(softc))
  179. X            if (!midi_reset(softc)) {
  180. X                printf("Couldn't reset MPU401\n");
  181. X                softc->status |= MIDI_UNAVAILABLE;
  182. X                continue;
  183. X            }
  184. X        if (!midi_uart(softc)) {
  185. X            printf("Couldn't put MPU401 into UART mode!\n");
  186. X            softc->status |= MIDI_UNAVAILABLE;
  187. X            continue;
  188. X        }
  189. X
  190. X        /* allocate memory for event queues */
  191. X        if ((softc->rqueue = kmem_alloc(sizeof(struct event_queue),
  192. X            KM_NOSLEEP)) == NULL) {
  193. X            printf("No memory for rqueue\n");
  194. X            softc->status |= MIDI_UNAVAILABLE;
  195. X            continue;
  196. X        }
  197. X        if ((softc->wqueue = kmem_alloc(sizeof(struct event_queue),
  198. X            KM_NOSLEEP)) == NULL) {
  199. X            printf("No memory for wqueue\n");
  200. X            softc->status |= MIDI_UNAVAILABLE;
  201. X            kmem_free(softc->rqueue, sizeof(struct event_queue));
  202. X        }
  203. X        /* zero read/write queue to clear stynamic structures */
  204. X        bzero(softc->rqueue, sizeof(struct event_queue));
  205. X        bzero(softc->wqueue, sizeof(struct event_queue));
  206. X        stynamic_init(&softc->rpartial);
  207. X        stynamic_init(&softc->wpartial);
  208. X        softc->wpartialpos = 0;
  209. X    }
  210. X}
  211. X
  212. Xint
  213. Xmidiopen(dev, flag, otyp, cred_p)
  214. X    dev_t *dev;
  215. X    int flag, otyp;
  216. X    cred_t *cred_p;
  217. X{
  218. X    register struct midi_softc *softc;
  219. X    register int unit;
  220. X 
  221. X    unit = minor(*dev);
  222. X    if (unit >= NumMidi)
  223. X        return (ENXIO);
  224. X    softc = &midi_sc[unit];
  225. X    if (softc->status & MIDI_UNAVAILABLE)
  226. X        return (EIO);
  227. X    
  228. X    if (softc->status & MIDI_OPEN)
  229. X        return (EBUSY);
  230. X    else
  231. X        softc->status = MIDI_OPEN;
  232. X
  233. X    /*
  234. X     * reads will block until something appears
  235. X     */
  236. X    softc->status |= MIDI_RD_BLOCK;
  237. X
  238. X    /* initialize the queues */
  239. X    midi_initq(softc->rqueue);
  240. X    midi_initq(softc->wqueue);
  241. X
  242. X    softc->partial_event.event.len = 0;
  243. X    softc->partial_event.event.datad = NULL;
  244. X
  245. X    /* make sure we are in UART mode */
  246. X    if (!midi_fullreset(softc)) {
  247. X        printf("Couldn't put MPU401 into UART mode!\n");
  248. X        softc->status |= MIDI_UNAVAILABLE;
  249. X        kmem_free(softc->rqueue, sizeof(struct event_queue));
  250. X        kmem_free(softc->wqueue, sizeof(struct event_queue));
  251. X        return (EIO);
  252. X    }
  253. X
  254. X    softc->pgid = u.u_procp->p_pid;
  255. X    softc->owner = u.u_procp;
  256. X
  257. X    /* are we going to read, write or both? */
  258. X    if (flag & FREAD)
  259. X        softc->status |= MIDI_READING;
  260. X    else
  261. X        softc->status &= ~MIDI_READING;
  262. X    if (flag & FWRITE)
  263. X        softc->status |= MIDI_WRITING;
  264. X    else
  265. X        softc->status &= ~MIDI_WRITING;
  266. X    if (flag & FNONBLOCK)
  267. X        softc->status |= MIDI_NONBLOCK;
  268. X    else
  269. X        softc->status &= ~MIDI_NONBLOCK;
  270. X
  271. X    return (0);
  272. X}
  273. X
  274. Xint
  275. Xmidiclose(dev, flag, otyp, cred_p)
  276. X    dev_t dev;
  277. X    int flag, otyp;
  278. X    cred_t *cred_p;
  279. X{
  280. X    register struct midi_softc *softc;
  281. X    register int error, unit;
  282. X
  283. X    unit = minor(dev);
  284. X    softc = &midi_sc[unit];
  285. X
  286. X    /*
  287. X     * we're not going to finish closing until everything has
  288. X     * been played.
  289. X     */
  290. X    error = 0;
  291. X    if (softc->status & MIDI_WRITING) {
  292. X        /* same as MFLUSHQ ioctl */
  293. X        if (softc->wqueue->count != 0) {
  294. X            softc->status |= MIDI_FLUSH_SLEEP;
  295. X            do {
  296. X                if (error = sleep((caddr_t)&softc->status,
  297. X                    PWAIT | PCATCH))
  298. X                    softc->status &= ~MIDI_FLUSH_SLEEP;
  299. X            } while (softc->status & MIDI_FLUSH_SLEEP);
  300. X        }
  301. X    }
  302. X
  303. X    /* turn off any notes that might be stuck on */
  304. X    midi_reset_devices(softc);
  305. X    midi_fullreset(softc);
  306. X
  307. X    softc->status &= ~MIDI_OPEN;
  308. X    return (error);
  309. X}
  310. X
  311. Xint
  312. Xmidiread(dev, uio, cred_p)
  313. X    dev_t dev;
  314. X    uio_t *uio;
  315. X    cred_t *cred_p;
  316. X{
  317. X    struct event *event;
  318. X    register struct midi_softc *softc;
  319. X    int error, in, num_to_move, unit;
  320. X
  321. X    unit = minor(dev);
  322. X    softc = &midi_sc[unit];
  323. X
  324. X    if (softc->rqueue->count == 0 && softc->rpartial.len == 0) {
  325. X        if (softc->status & MIDI_NONBLOCK)
  326. X            return (EWOULDBLOCK);
  327. X        else {
  328. X            softc->status |= MIDI_RD_SLEEP;
  329. X            do {
  330. X                if (error = sleep((caddr_t)softc->rqueue,
  331. X                    PWAIT | PCATCH))
  332. X                    return (error);
  333. X            } while (softc->status & MIDI_RD_SLEEP);
  334. X            /* XXX maybe check for abort here */
  335. X        }
  336. X    }
  337. X    while (uio->uio_resid) {
  338. X        /*
  339. X         * dequeue an event if partial is empty
  340. X         */
  341. X        if (softc->rpartial.len == 0) {
  342. X            if (!midi_deq(softc->rqueue, &event)) {
  343. X                softc->status |= MIDI_RD_BLOCK;
  344. X                return (0);
  345. X            }
  346. X            midi_event2smf(softc, event, &softc->rpartial);
  347. X            styanmic_release(&event->data);
  348. X        }
  349. X        /* read out as much of rpartial as possible */
  350. X        num_to_move = MIN(softc->rpartial.len, uio->uio_resid);
  351. X        if (softc->rpartial.len <= STYNAMIC_SIZE) {
  352. X            if (uiomove(softc->rpartial.datas, num_to_move,
  353. X                UIO_READ, uio) == -1)
  354. X            return (-1);
  355. X        } else {
  356. X            if (uiomove(softc->rpartial.datad, num_to_move,
  357. X                UIO_READ, uio) == -1)
  358. X            return (-1);
  359. X        }
  360. X        stynamic_shift(&softc->rpartial, num_to_move);
  361. X    }
  362. X    return (0);
  363. X}
  364. X
  365. Xint
  366. Xmidiwrite(dev, uio, cred_p)
  367. X    dev_t dev;
  368. X    uio_t *uio;
  369. X    cred_t *cred_p;
  370. X{
  371. X    register struct midi_softc *softc;
  372. X    struct event event;
  373. X    int convert, error, unit, iovec, empty_queue;
  374. X
  375. X    unit = minor(dev);
  376. X    softc = &midi_sc[unit];
  377. X
  378. X    if (softc->wqueue->count == 0)
  379. X        empty_queue = 1;
  380. X    else
  381. X        empty_queue = 0;
  382. X
  383. X    /* check to see if we'll block */
  384. X    if (softc->status & MIDI_WR_BLOCK) {
  385. X        if (softc->status & MIDI_NONBLOCK)
  386. X            return (EWOULDBLOCK);
  387. X        else {
  388. X            softc->status |= MIDI_WR_SLEEP;
  389. X            do {
  390. X                if (error = sleep((caddr_t)softc->wqueue,
  391. X                    PWAIT | PCATCH))
  392. X                    return (error);
  393. X            } while (softc->status & MIDI_WR_SLEEP);
  394. X        }
  395. X    }
  396. X    /* if returns from sleep and should abort because of DRAIN */
  397. X    if (softc->status & MIDI_WR_ABORT) {
  398. X        softc->status &= ~MIDI_WR_ABORT;
  399. X        return (0);
  400. X    }
  401. X
  402. X    stynamic_init(&event.data);
  403. X    while (uio->uio_resid) {
  404. X        /* block if queue is full */
  405. X        if (softc->wqueue->count == MIDI_Q_SIZE) {
  406. X            softc->status |= MIDI_WR_BLOCK;
  407. X            if (empty_queue) {
  408. X                midi_schedule_timeout(softc);
  409. X                empty_queue = 0;
  410. X            }
  411. X            if (softc->status & MIDI_NONBLOCK)
  412. X                return (0);
  413. X            else {
  414. X                softc->status |= MIDI_WR_SLEEP;
  415. X                do {
  416. X                    if (error = sleep(softc->wqueue,
  417. X                        PWAIT | PCATCH))
  418. X                        return (error);
  419. X                } while (softc->status & MIDI_WR_SLEEP);
  420. X            }
  421. X        }
  422. X
  423. X        /*
  424. X         * 1) get a complete event off queue
  425. X         * 2) convert it from SMF to board format
  426. X         * 3) deal with it
  427. X         */
  428. X        convert = midi_uio2event(softc, uio, &event);
  429. X        switch (convert) {
  430. X        case 0:
  431. X            break;
  432. X        case -1:
  433. X            /* not a complete event - we'll get it next time */
  434. X            if (empty_queue)
  435. X                midi_schedule_timeout(softc);
  436. X            return (0);
  437. X        case -2:
  438. X            /* it was a noop event */
  439. X            break;
  440. X        default:
  441. X            return (convert);
  442. X        }
  443. X        if (convert == -2)
  444. X            continue;
  445. X
  446. X        if (midi_enq(softc->wqueue, &event) == -1)
  447. X            return (EIO);
  448. X        stynamic_release(&event.data);
  449. X        /* set flag so next time we cross LOW water we will SIGIO */
  450. X        if (softc->wqueue->count >= MIDI_LOW_WATER)
  451. X            softc->status |= MIDI_SENDIO;
  452. X    }
  453. X
  454. X    if (empty_queue)
  455. X        midi_schedule_timeout(softc);
  456. X
  457. X    return (0);
  458. X}
  459. X
  460. X/*
  461. X * XXXINTR
  462. X * I don't know what ivec is.  I'm really hoping it is something
  463. X * useful like the unit number.
  464. X * If it is the interrupt number, then we can loop through all the
  465. X * midi_sc comparing ivec against softc->intr until we find the right
  466. X * one.  No biggie, I just don't know which way it works.
  467. X * For for I'll assume by default that it is the interrupt number.
  468. X */
  469. Xint
  470. Xmidiintr(ivec)
  471. X    int ivec;
  472. X{
  473. X    register struct midi_softc *softc;
  474. X    register u_char code;
  475. X    register struct partial_event *pe;
  476. X
  477. X#if 1
  478. X    int i;
  479. X
  480. X    for (i = 0; i < NumMidi && midi_sc[i].intr != ivec; i++);
  481. X    if (i == NumMidi) {
  482. X        printf("midi: ivec(%d) is not a valid MPU401 intr number\n");
  483. X        return;
  484. X    }
  485. X    softc = &midi_sc[i];
  486. X#else
  487. X    softc = &midi_sc[ivec];
  488. X#endif
  489. X
  490. X    code = INB(softc->addr + MIDI_DATA);
  491. X    if (code == 0xfe && (softc->status & MIDI_NEED_ACK)) {
  492. X        softc->status &= ~MIDI_NEED_ACK;
  493. X        return (1);
  494. X    }
  495. X    /* throw away data if no one has the device open */
  496. X    if (!(softc->status & MIDI_READING))
  497. X        return (1);
  498. X
  499. X    /* pass input data to out port if necessary */
  500. X    if (softc->status & MIDI_THRU) {
  501. X        if (!midi_wait_rdy_rcv(softc))
  502. X            printf("Couldn't pass data thru\n");
  503. X        else
  504. X            OUTB(softc->addr + MIDI_DATA, code);
  505. X    }
  506. X    pe = &softc->partial_event;
  507. X
  508. X    /* check for realtime events */
  509. X    if ((code & 0xf8) == 0xf8) {
  510. X        switch (code) {
  511. X        case 0xfa:    /* start */
  512. X            /* reset prev_incoming */
  513. X            softc->prev_incoming = lbolt;
  514. X            break;
  515. X        case 0xff:    /* reset */
  516. X            /*
  517. X             * I don't really want to do a full reset
  518. X             * I'll just clear any event in progress
  519. X             */
  520. X            stynamic_release(&pe->event);
  521. X            pe->state = START;
  522. X            break;
  523. X        case 0xf8:    /* timing clock */
  524. X        case 0xf9:    /* undefined */
  525. X        case 0xfb:    /* continue */
  526. X        case 0xfc:    /* stop */
  527. X        case 0xfd:    /* undefined */
  528. X        case 0xfe:    /* active sensing */
  529. X            break;
  530. X        }
  531. X        return (1);
  532. X    }
  533. XINTR_SWITCH:
  534. X    switch (pe->state) {
  535. X    case START:
  536. X        /* record when the time when the event started */
  537. X        pe->time = lbolt;
  538. X        pe->tempo = softc->rtempo;
  539. X        /* start collecting the input */
  540. X        stynamic_release(&pe->event);
  541. X        /* decide what state is next */
  542. X        if (!(code & 0x80)) {
  543. X            stynamic_add_byte(&pe->event, code);
  544. X            switch (pe->rs) {
  545. X            case 0x80:
  546. X            case 0x90:
  547. X            case 0xa0:
  548. X            case 0xb0:
  549. X            case 0xe0:
  550. X                /*
  551. X                 * code is the first data byte, but
  552. X                 * we still need to get the second
  553. X                 */
  554. X                pe->state = NEEDDATA2;
  555. X                break;
  556. X            case 0xc0:
  557. X            case 0xd0:
  558. X                /* code is the only data byte */
  559. X                pe->state = START;
  560. X                midi_add_complete_event(softc);
  561. X                break;
  562. X            default:
  563. X                break;
  564. X            }
  565. X        } else {
  566. X            switch (code & 0xf0) {
  567. X            case 0x80:
  568. X            case 0x90:
  569. X            case 0xa0:
  570. X            case 0xb0:
  571. X            case 0xe0:
  572. X                pe->rs = code & 0xf0;
  573. X                stynamic_add_byte(&pe->event, code);
  574. X                pe->state = NEEDDATA1;
  575. X                break;
  576. X            case 0xc0:
  577. X            case 0xd0:
  578. X                pe->rs = code & 0xf0;
  579. X                stynamic_add_byte(&pe->event, code);
  580. X                pe->state = NEEDDATA2;
  581. X                break;
  582. X            default:
  583. X                switch (code) {
  584. X                case 0xf0: /* sysex */
  585. X                    stynamic_add_byte(&pe->event, code);
  586. X                    pe->state = SYSEX;
  587. X                    break;
  588. X                case 0xf1: /* undefined */
  589. X                case 0xf4: /* undefined */
  590. X                case 0xf5: /* undefined */
  591. X                case 0xf6: /* tune request */
  592. X                case 0xf7: /* EOX (terminator) */
  593. X                    /* ignore these */
  594. X                    break;
  595. X                case 0xf2: /* song position */
  596. X                    pe->state = SYSTEM2;
  597. X                    break;
  598. X                case 0xf3: /* song select */
  599. X                    pe->state = SYSTEM1;
  600. X                    break;
  601. X                }
  602. X                break;
  603. X            }
  604. X        }
  605. X        break;
  606. X    case NEEDDATA1:
  607. X        stynamic_add_byte(&pe->event, code);
  608. X        pe->state = NEEDDATA2;
  609. X        break;
  610. X    case NEEDDATA2:
  611. X        stynamic_add_byte(&pe->event, code);
  612. X        pe->state = START;
  613. X        midi_add_complete_event(softc);
  614. X        break;
  615. X    case SYSEX:
  616. X        /* any non-data byte ends sysex */
  617. X        if (!(code & 0x80))
  618. X            stynamic_add_byte(&pe->event, code);
  619. X        else {
  620. X            stynamic_add_byte(&pe->event, 0xf7);
  621. X            midi_add_complete_event(softc);
  622. X            pe->state = START;
  623. X            if (code != 0xf7)
  624. X                goto INTR_SWITCH;
  625. X        }
  626. X        break;
  627. X    case SYSTEM1:
  628. X        /* throw away one data byte of a system message */
  629. X        pe->state = START;
  630. X        break;
  631. X    case SYSTEM2:
  632. X        /* throw away two data bytes of a system message */
  633. X        pe->state = SYSTEM1;
  634. X        break;
  635. X    }
  636. X    return (1);
  637. X}
  638. X
  639. Xint
  640. Xmidiioctl(dev, cmd, arg, mode, cred_p, rval_p)
  641. X    dev_t dev;
  642. X    int cmd, arg, mode;
  643. X    cred_t *cred_p;
  644. X    int *rval_p;
  645. X{
  646. X    struct event *event;
  647. X    struct midi_softc *softc;
  648. X    register int error, unit;
  649. X    int i, ret, val;
  650. X
  651. X    unit = minor(dev);
  652. X    softc = &midi_sc[unit];
  653. X
  654. X    switch (cmd) {
  655. X    case FIOASYNC:
  656. X    case MASYNC:
  657. X        /*
  658. X         * Linux doesn't properly process the FIOASYNC
  659. X         * ioctl entry point, thus we have two.  For
  660. X         * compatibility purposes, I'm duplicating it
  661. X         * here too.
  662. X         */
  663. X
  664. X        copyin((caddr_t)arg, (caddr_t)&val, sizeof(int));
  665. X        if (!val)
  666. X            softc->status &= ~MIDI_ASYNC;
  667. X        else {
  668. X            struct proc *p;
  669. X
  670. X            softc->status |= MIDI_ASYNC;
  671. X            if (softc->wqueue->count < MIDI_LOW_WATER
  672. X                && softc->status & MIDI_WRITING) {
  673. X                if (softc->pgid < 0)
  674. X                    signal(-softc->pgid, SIGIO);
  675. X                else if ((p = prfind(softc->pgid)) != 0)
  676. X                    psignal(p, SIGIO);
  677. X            }
  678. X        }
  679. X        break;
  680. X    case TIOCSPGRP:
  681. X        /*
  682. X         * XXXSIGNAL we need to check to be sure we can kill the
  683. X         * the process we are being told to kill
  684. X         */
  685. X        copyin((caddr_t)arg, (caddr_t)&val, sizeof(int));
  686. X        if ((ret = midi_killable(softc->owner, val) != 0)) != 0)
  687. X            return (ret);
  688. X        softc->pgid = val;
  689. X        break;
  690. X    case TIOCGPGRP:
  691. X        copyout((caddr_t)&softc->pgid, (caddr_t)arg, sizeof(int));
  692. X        break;
  693. X    case MRESET:
  694. X        if (!midi_fullreset(softc))
  695. X            return (EIO);
  696. X        break;
  697. X    case MSDIVISION:
  698. X        copyin((caddr_t)arg, (caddr_t)&val, sizeof(int));
  699. X          /* must recalculate play remainder */
  700. X          softc->premainder = softc->premainder * val / softc->division;
  701. X          softc->division = val;
  702. X        break;
  703. X    case MGDIVISION:
  704. X        copyout((caddr_t)&softc->division, (caddr_t)arg, sizeof(int));
  705. X        break;
  706. X    case MDRAIN:
  707. X        /* dequeue all everything */
  708. X        while (midi_deq(softc->rqueue, &event))
  709. X            stynamic_release(&event->data);
  710. X        while (midi_deq(softc->wqueue, &event))
  711. X            stynamic_release(&event->data);
  712. X        /* remove any events already being timed */
  713. X        if (softc->timeout_id != -1)
  714. X            untimeout(softc->timeout_id);
  715. X        softc->status &= ~MIDI_WR_BLOCK;
  716. X        softc->status |= MIDI_RD_BLOCK;
  717. X        if (softc->status & MIDI_WR_SLEEP) {
  718. X            softc->status &= ~MIDI_WR_SLEEP;
  719. X            softc->status |= MIDI_WR_ABORT;
  720. X            wakeup((caddr_t)softc->wqueue);
  721. X        }
  722. X        midi_reset_devices(softc);
  723. X        break;
  724. X    case MFLUSH:
  725. X        if (softc->wqueue->count != 0) {
  726. X            softc->status |= MIDI_FLUSH_SLEEP;
  727. X            do {
  728. X                if (error = sleep((caddr_t)&softc->status,
  729. X                    PWAIT | PCATCH))
  730. X                    return (error);
  731. X            } while (softc->status & MIDI_FLUSH_SLEEP);
  732. X        }
  733. X        break;
  734. X    case MGPLAYQ:
  735. X        copyout((caddr_t)&softc->wqueue->count, (caddr_t)arg,
  736. X            sizeof(int));
  737. X        break;
  738. X    case MGRECQ:
  739. X        copyout((caddr_t)&softc->rqueue->count, (caddr_t)arg,
  740. X            sizeof(int));
  741. X        break;
  742. X    case MGQAVAIL:
  743. X        val = MIDI_Q_SIZE - softc->wqueue->count;
  744. X        copyout((caddr_t)&val, (caddr_t)arg, sizeof(int));
  745. X        break;
  746. X    case MTHRU:
  747. X        copyin((caddr_t)arg, (caddr_t)&val, sizeof(int));
  748. X        if (val)
  749. X            softc->status |= MIDI_THRU;
  750. X        else
  751. X            softc->status &= ~MIDI_THRU;
  752. X        break;
  753. X    case MRECONPLAY:
  754. X        copyin((caddr_t)arg, (caddr_t)&val, sizeof(int));
  755. X        if (val)
  756. X            softc->status |= MIDI_RECONPLAY;
  757. X        else
  758. X            softc->status &= ~MIDI_RECONPLAY;
  759. X        break;
  760. X    default:
  761. X        return (ENOTTY);
  762. X    }
  763. X    return (0);
  764. X}
  765. X
  766. X/*
  767. X * XXXPOLL
  768. X * I don't know how this is supposed to work.  The SVR4/386
  769. X * DDI/DKI reference manual doesn't explain it well enough for me.
  770. X */
  771. Xint
  772. Xmidipoll(dev, events, anyyet, reventsp, phpp)
  773. X    dev_t dev;
  774. X    short events;
  775. X    int anyyet;
  776. X    short *reventsp;
  777. X    struct pollhead **phpp;
  778. X{
  779. X    register struct midi_softc *softc;
  780. X    int unit;
  781. X
  782. X    unit = minor(dev);
  783. X    softc = &midi_sc[unit];
  784. X
  785. X    *reventsp = 0;
  786. X    if (events & POLLIN && !(softc->status & MIDI_RD_BLOCK))
  787. X        *reventsp |= POLLIN;
  788. X    if (events & POLLOUT && !(softc->status & MIDI_WR_BLOCK))
  789. X        *reventsp |= POLLOUT;
  790. X    if (*reventsp == 0)
  791. X        if (!anyyet)
  792. X            *phpp = &softc->pollhead;
  793. X    return (0);
  794. X}
  795. X
  796. Xint
  797. Xmidi_fullreset(softc)
  798. X    struct midi_softc *softc;
  799. X{
  800. X    u_char pitch;
  801. X    struct event *event;
  802. X
  803. X    /* dequeue all everything */
  804. X    while (midi_deq(softc->rqueue, &event))
  805. X        stynamic_release(&event->data);
  806. X    while (midi_deq(softc->wqueue, &event))
  807. X        stynamic_release(&event->data);
  808. X    /* remove any events already being timed */
  809. X    if (softc->timeout_id != -1)
  810. X        untimeout(softc->timeout_id);
  811. X    softc->timeout_id = -1;
  812. X    /* mark start time */
  813. X    softc->prev_incoming = lbolt;
  814. X    /* reset fractional count */
  815. X    softc->premainder = 0;
  816. X    softc->rremainder = 0;
  817. X    /* initialize some variables */
  818. X    /* this is 120 bpm when a quarter note == 1 beat */
  819. X    softc->ptempo = 500000;
  820. X    softc->rtempo = 500000;
  821. X    softc->prev_rtempo = 500000;
  822. X
  823. X    /* clear noteon */
  824. X    for (pitch = 0; pitch <= 0x7f; pitch++)
  825. X        softc->noteon[pitch] = 0;
  826. X    softc->noteonrs = 0;
  827. X
  828. X    /* clear running play state */
  829. X    softc->writers = 0;
  830. X
  831. X    /* reset partial event stuff */
  832. X    stynamic_release(&softc->partial_event.event);
  833. X    softc->partial_event.state = START;
  834. X    stynamic_release(&softc->rpartial);
  835. X    stynamic_release(&softc->wpartial);
  836. X    softc->wpartialpos = 0;
  837. X
  838. X    /* defaults to 120 clocks per beat */
  839. X    softc->division = 120;
  840. X    /* reset and enter uart mode */
  841. X    return (midi_uart(softc));
  842. X}
  843. X
  844. Xint
  845. Xmidi_wait_rdy_rcv(softc)
  846. X    struct midi_softc *softc;
  847. X{
  848. X    int flag;
  849. X    register int i;
  850. X
  851. X    for (i = 0; i < MIDI_TRIES; i++) {
  852. X        flag = INB(softc->addr + MIDI_STATUS) & MIDI_RDY_RCV;
  853. X        if (flag == 0)
  854. X            break;
  855. X    }
  856. X    if (i == MIDI_TRIES)
  857. X        return (0);
  858. X    return(1);
  859. X}
  860. X
  861. Xint
  862. Xmidi_send_command(softc, comm)
  863. X    struct midi_softc *softc;
  864. X    u_char comm;
  865. X{
  866. X    int flag;
  867. X    register int i, s;
  868. X    unsigned char ack;
  869. X
  870. X    /* writing command and setting flag must be atomic */
  871. X    s = spltty();
  872. X    OUTB(softc->addr + MIDI_COMMAND, comm);
  873. X    softc->status |= MIDI_NEED_ACK;
  874. X    splx(s);
  875. X
  876. X    /* time out after MIDI_TRIES times */
  877. X    for (i = 0; i < MIDI_TRIES; i++) {
  878. X        /* did we pick up the ack via midiintr? */
  879. X        if (!(softc->status & MIDI_NEED_ACK))
  880. X            break;
  881. X        /* can we read a data byte? */
  882. X        flag = INB(softc->addr + MIDI_STATUS) & MIDI_DATA_AVL;
  883. X        if (flag == 0)
  884. X            break;
  885. X    }
  886. X    if (i == MIDI_TRIES)
  887. X        return (0);
  888. X
  889. X    if (softc->status & MIDI_NEED_ACK) {
  890. X        ack = INB(softc->addr + MIDI_DATA);
  891. X        if (ack != MIDI_ACK)
  892. X            return (0);
  893. X    }
  894. X    softc->status &= ~MIDI_NEED_ACK;
  895. X    return (1);
  896. X}
  897. X
  898. Xint
  899. Xmidi_reset(softc)
  900. X    struct midi_softc *softc;
  901. X{
  902. X
  903. X    if (!midi_wait_rdy_rcv(softc))
  904. X        return (0);
  905. X
  906. X    if (!midi_send_command(softc, MIDI_RESET))
  907. X        return (0);
  908. X
  909. X    return (1);
  910. X}
  911. X
  912. Xint
  913. Xmidi_uart(softc)
  914. X    struct midi_softc *softc;
  915. X{
  916. X
  917. X    /*
  918. X     * first reset.  We can't issue the UART command when already
  919. X     * in UART mode.
  920. X     */
  921. X    (void)midi_reset(softc);
  922. X
  923. X    if (!midi_wait_rdy_rcv(softc))
  924. X        return (0);
  925. X
  926. X    if (!midi_send_command(softc, MIDI_UART))
  927. X        return (0);
  928. X    return (1);
  929. X}
  930. X
  931. Xint
  932. Xmidi_event2smf(softc, event, smf)
  933. X    struct midi_softc *softc;
  934. X    struct event *event;
  935. X    struct stynamic *smf;
  936. X{
  937. X    long tempo, smf_ticks;
  938. X    int tmp_len;
  939. X    u_char tmp_buf[4];
  940. X
  941. X    /* convert from kernel ticks to SMF ticks */
  942. X    smf_ticks = midi_kernel2smf_tick(softc, event->tempo, event->time);
  943. X    tmp_len = midi_fix2var(smf_ticks, tmp_buf);
  944. X    stynamic_add_bytes(smf, tmp_buf, tmp_len);
  945. X
  946. X    switch (event->type) {
  947. X    case NORMAL:
  948. X        stynamic_append(smf, &event->data);
  949. X        break;
  950. X    case TEMPO:
  951. X        /* this case just won't occur */
  952. X        stynamic_copy(&event->data, (void *)&tempo, sizeof(tempo));
  953. X        stynamic_add_byte(smf, 0xff);
  954. X        stynamic_add_byte(smf, 0x51);
  955. X        stynamic_add_byte(smf, 0x03);
  956. X        stynamic_add_byte(smf, (tempo & 0xff0000) >> 16);
  957. X        stynamic_add_byte(smf, (tempo & 0xff00) >> 8);
  958. X        stynamic_add_byte(smf, tempo & 0xff00);
  959. X        break;
  960. X    case SYSX:
  961. X        stynamic_add_byte(smf, 0xf0);
  962. X        /* skip over the leading 0xf0 */
  963. X        stynamic_shift(&event->data, 1);
  964. X        tmp_len = midi_fix2var(event->data.len, tmp_buf);
  965. X        stynamic_add_bytes(smf, tmp_buf, tmp_len);
  966. X        styanmic_append(smf, &event->data);
  967. X        break;
  968. X    }
  969. X    return (1);
  970. X}
  971. X
  972. Xint
  973. Xmidi_next_byte(softc, uio)
  974. X    struct midi_softc *softc;
  975. X    struct uio *uio;
  976. X{
  977. X    int byte;
  978. X
  979. X    /* if we're not at the end of a partial event, read from it */
  980. X    if (softc->wpartialpos < softc->wpartial.len) {
  981. X        byte = stynamic_get_byte(&softc->wpartial,
  982. X            softc->wpartialpos++);
  983. X        return (byte);
  984. X    } else {
  985. X        /* read from uio and copy uio onto partial event */
  986. X        if ((byte = uwritec(uio)) == -1) {
  987. X            /*
  988. X             * reset partialpos so next time through
  989. X             * we'll read from the partial event if
  990. X             * it is non-zero in length
  991. X             */
  992. X            softc->wpartialpos = 0;
  993. X            return (-1);
  994. X        }
  995. X        stynamic_add_byte(&softc->wpartial, byte);
  996. X        softc->wpartialpos = softc->wpartial.len;
  997. X        return (byte);
  998. X    }
  999. X}
  1000. X
  1001. Xint
  1002. Xmidi_uio2event(softc, uio, event)
  1003. X    struct midi_softc *softc;
  1004. X    struct uio *uio;
  1005. X    struct event *event;
  1006. X{
  1007. X    u_long smf_ticks, ulen;
  1008. X    long tempo;
  1009. X    int byte, error, extra_byte, i, len, num_data_bytes;
  1010. X    int rs_change;
  1011. X    u_char meta_type, tmp_buf[256];
  1012. X
  1013. X    /* copy in timing portion */
  1014. X    len = 0;
  1015. X    do {
  1016. X        if ((byte = midi_next_byte(softc, uio)) == -1) {
  1017. X            stynamic_release(&event->data);
  1018. X            return (-1);
  1019. X        }
  1020. X        tmp_buf[len++] = byte;
  1021. X    } while (byte & 0x80);
  1022. X
  1023. X    /* compute time in smf ticks */
  1024. X    midi_var2fix(tmp_buf, &smf_ticks);
  1025. X    smf_ticks += softc->write_noop_time;
  1026. X    softc->write_noop_time = 0;
  1027. X
  1028. X    /* now convert from smf to kernel */
  1029. X    event->time = midi_smf2kernel_tick(softc, smf_ticks);
  1030. X
  1031. X    /* get first byte of event data */
  1032. X    if ((byte = midi_next_byte(softc, uio)) == -1) {
  1033. X        stynamic_release(&event->data);
  1034. X        return (-1);
  1035. X    }
  1036. X    switch (byte) {
  1037. X    case 0xf0:
  1038. X        /* basic sysex type */
  1039. X        event->type = SYSX;
  1040. X        len = 0;
  1041. X        do {
  1042. X            if ((byte = midi_next_byte(softc, uio)) == -1) {
  1043. X                stynamic_release(&event->data);
  1044. X                return (-1);
  1045. X            }
  1046. X            tmp_buf[len++] = byte;
  1047. X        } while (byte & 0x80);
  1048. X        midi_var2fix(tmp_buf, &ulen);
  1049. X        stynamic_add_byte(&event->data, 0xf0);
  1050. X        for (; ulen > 0; ulen--) {
  1051. X            if ((byte = midi_next_byte(softc, uio)) == -1) {
  1052. X                stynamic_release(&event->data);
  1053. X                return (-1);
  1054. X            }
  1055. X            stynamic_add_byte(&event->data, byte);
  1056. X        }
  1057. X        break;
  1058. X    case 0xf7:
  1059. X        /* continued sysex type */
  1060. X        event->type = SYSX;
  1061. X        len = 0;
  1062. X        do {
  1063. X            if ((byte = midi_next_byte(softc, uio)) == -1) {
  1064. X                stynamic_release(&event->data);
  1065. X                return (-1);
  1066. X            }
  1067. X            tmp_buf[len++] = byte;
  1068. X        } while (byte & 0x80);
  1069. X        midi_var2fix(smf, &ulen);
  1070. X        for (; ulen > 0; ulen--) {
  1071. X            if ((byte = midi_next_byte(softc, uio)) == -1) {
  1072. X                stynamic_release(&event->data);
  1073. X                return (-1);
  1074. X            }
  1075. X            stynamic_add_byte(&event->data, byte);
  1076. X        }
  1077. X        if (error = uiomove(event->data, event->length, UIO_WRITE,
  1078. X            uio))
  1079. X            return (error);
  1080. X        break;
  1081. X    case 0xff:
  1082. X        /* meta events */
  1083. X        if ((byte = midi_next_byte(softc, uio)) == -1) {
  1084. X            stynamic_release(&event->data);
  1085. X            return (-1);
  1086. X        }
  1087. X        meta_type = byte;
  1088. X        /* get length of meta data */
  1089. X        len = 0;
  1090. X        do {
  1091. X            if ((byte = midi_next_byte(softc, uio)) == -1) {
  1092. X                stynamic_release(&event->data);
  1093. X                return (-1);
  1094. X            }
  1095. X            tmp_buf[len++] = byte;
  1096. X        } while (byte & 0x80);
  1097. X        midi_var2fix(tmp_buf, &ulen);
  1098. X        /* read it in  - meta events are not over 256 in size */
  1099. X        for (i = 0; i < ulen; i++) {
  1100. X            if ((byte = midi_next_byte(softc, uio)) == -1) {
  1101. X                stynamic_release(&event->data);
  1102. X                return (-1);
  1103. X            }
  1104. X        }
  1105. X        switch (meta_type) {
  1106. X        default:
  1107. X            /*
  1108. X             * we'll skip these events, but we need to
  1109. X             * save the timing info
  1110. X             */
  1111. X            softc->write_noop_time = smf_ticks;
  1112. X            stynamic_release(&softc->wpartial);
  1113. X            softc->wpartialpos = 0;
  1114. X            return (-2);
  1115. X        case 0x51:
  1116. X            /* tempo event */
  1117. X            event->type = TEMPO;
  1118. X            tempo = 0;
  1119. X            for (i = 0; i < 3; i++) {
  1120. X                tempo = tempo << 8;
  1121. X                tempo |= tmp_buf[i];
  1122. X            }
  1123. X            stynamic_add_bytes(&event->data, (u_char *)&tempo,
  1124. X                sizeof(tempo));
  1125. X            /*
  1126. X             * change ptempo now, rtempo will change when
  1127. X             * the event's time comes up
  1128. X             */
  1129. X            softc->ptempo = tempo;
  1130. X            break;
  1131. X        }
  1132. X        break;
  1133. X    default:
  1134. X        if ((byte & 0xf0) == 0x80) {
  1135. X            u_char rs_chan, rs_type;
  1136. X
  1137. X            /* check note off events separately */
  1138. X            tmp_buf[0] = byte;
  1139. X            if ((byte = midi_next_byte(softc, uio)) == -1) {
  1140. X                stynamic_release(&event->data);
  1141. X                return (-1);
  1142. X            }
  1143. X            tmp_buf[1] = byte;
  1144. X            if ((byte = midi_next_byte(softc, uio)) == -1) {
  1145. X                stynamic_release(&event->data);
  1146. X                return (-1);
  1147. X            }
  1148. X            tmp_buf[2] = byte;
  1149. X            len = 3;
  1150. X            /*
  1151. X             * check to see if we can collapse and use
  1152. X             * running state
  1153. X             */
  1154. X            rs_type = softc->writers & 0xf0;
  1155. X            rs_chan = softc->writers & 0x0f;
  1156. X            /*
  1157. X             * collapse to running state if time is 0
  1158. X             * and the running state is the same
  1159. X             * or the running state is note on for the
  1160. X             * same channel and the note off velocity is
  1161. X             * zero.
  1162. X             */
  1163. X            if (event->time == 0 && (softc->writers == tmp_buf[0]
  1164. X                || (tmp_buf[2] == 0 && rs_type == 0x90
  1165. X                && rs_chan == (tmp_buf[0] & 0x0f)))) {
  1166. X                tmp_buf[0] = tmp_buf[1];
  1167. X                tmp_buf[1] = tmp_buf[2];
  1168. X                len = 2;
  1169. X            } else {
  1170. X                softc->writers = tmp_buf[0];
  1171. X            }
  1172. X        } else {
  1173. X            extra_byte = 0;
  1174. X            rs_change = 0;
  1175. X            if ((byte & 0x80) && (byte != softc->writers)) {
  1176. X                softc->writers = byte;
  1177. X                rs_change = 1;
  1178. X            }
  1179. X            len = 0;
  1180. X            if (event->time != 0 || rs_change) {
  1181. X                /*
  1182. X                 * stick in a mode byte if time is non-zero
  1183. X                 * This is so we don't confuse hardware that
  1184. X                 * is turned on while we're playing
  1185. X                 * also add it if the running state changes
  1186. X                 */
  1187. X                tmp_buf[0] = softc->writers;
  1188. X                len = 1;
  1189. X            }
  1190. X            if (byte & 0x80)
  1191. X                extra_byte = 1;
  1192. X            else {
  1193. X                tmp_buf[len] = byte;
  1194. X                len++;
  1195. X            }
  1196. X
  1197. X            switch (softc->writers & 0xf0) {
  1198. X            case 0x80:
  1199. X            case 0x90:
  1200. X            case 0xa0:
  1201. X            case 0xb0:
  1202. X            case 0xe0:
  1203. X                num_data_bytes = 1;
  1204. X                break;
  1205. X            default:
  1206. X                num_data_bytes = 0;
  1207. X            }
  1208. X            for (i = 0; i < num_data_bytes + extra_byte; i++) {
  1209. X                if ((byte = midi_next_byte(softc, uio)) == -1) {
  1210. X                    stynamic_release(&event->data);
  1211. X                    return (-1);
  1212. X                }
  1213. X                tmp_buf[len++] = byte;
  1214. X            }
  1215. X        }
  1216. X        event->type = NORMAL;
  1217. X        stynamic_add_bytes(&event->data, tmp_buf, len);
  1218. X    }
  1219. X    stynamic_release(&softc->wpartial);
  1220. X    softc->wpartialpos = 0;
  1221. X    return (0);
  1222. X}
  1223. X
  1224. Xint
  1225. Xmidi_fix2var(fix, var)
  1226. X    u_long fix;
  1227. X    u_char *var;
  1228. X{
  1229. X    int i;
  1230. X    unsigned char buf[4], *bptr;
  1231. X
  1232. X    buf[0] = buf[1] = buf[2] = buf[3] = 0;
  1233. X    bptr = buf;
  1234. X    *bptr++ = fix & 0x7f;
  1235. X    while ((fix >>= 7) > 0) {
  1236. X        *bptr |= 0x80;
  1237. X        *bptr++ += (fix & 0x7f);
  1238. X        }
  1239. X
  1240. X    i = 0;
  1241. X    do {
  1242. X        *var++ = *--bptr;
  1243. X        i++;
  1244. X    } while (bptr != buf);
  1245. X
  1246. X    return (i);
  1247. X}
  1248. X
  1249. Xint
  1250. Xmidi_var2fix(var, fix)
  1251. X    u_char *var;
  1252. X    u_long *fix;
  1253. X{
  1254. X    int delta;
  1255. X
  1256. X    *fix = 0;
  1257. X    delta = 0;
  1258. X    do {
  1259. X        *fix = (*fix << 7) + (*var & 0x7f);
  1260. X        delta++;
  1261. X    } while (*var++ & 0x80);
  1262. X
  1263. X    return (delta);
  1264. X}
  1265. X
  1266. Xu_long
  1267. Xmidi_smf2kernel_tick(softc, smf)
  1268. X    struct midi_softc *softc;
  1269. X    long smf;
  1270. X{
  1271. X      long long denominator, numerator;
  1272. X      u_long kernel;
  1273. X   
  1274. X     numerator = (long long)softc->ptempo * Hz * smf + softc->premainder;
  1275. X      denominator = 1000000 * (long long)softc->division;
  1276. X      kernel = numerator / denominator;
  1277. X      softc->premainder = numerator % denominator;
  1278. X       return (kernel);
  1279. X}
  1280. X
  1281. Xu_long
  1282. Xmidi_kernel2smf_tick(softc, tempo, kernel)
  1283. X    struct midi_softc *softc;
  1284. X    long tempo, kernel;
  1285. X{
  1286. X      long long numerator, denominator;
  1287. X      u_long smf;
  1288. X   
  1289. X      if (softc->prev_rtempo != tempo) {
  1290. X          /*
  1291. X           * also update the rremainder to reflect tempo
  1292. X           * change
  1293. X           */
  1294. X          softc->rremainder = softc->rremainder * tempo
  1295. X              / softc->prev_rtempo;
  1296. X          softc->prev_rtempo = tempo;
  1297. X      }
  1298. X     numerator = (long long)softc->division * 1000000 * kernel
  1299. X         + softc->rremainder;
  1300. X      denominator = (long long)tempo * Hz;
  1301. X      smf = numerator / denominator;
  1302. X      softc->rremainder = numerator % denominator;
  1303. X       return (smf);
  1304. X}
  1305. X
  1306. Xvoid
  1307. Xmidi_add_complete_event(softc)
  1308. X    struct midi_softc *softc;
  1309. X{
  1310. X    struct timeval t;
  1311. X    struct timeval curr;
  1312. X    struct event event;
  1313. X    struct partial_event *pe;
  1314. X    long ticks;
  1315. X
  1316. X    stynamic_init(&event.data);
  1317. X    pe = &softc->partial_event;
  1318. X    /* calculate delta time */
  1319. X    ticks = softc->prev_incoming - pe->time;
  1320. X    if (ticks < 0) {
  1321. X        ticks = 0;
  1322. X        pe->time = softc->prev_incoming;
  1323. X    }
  1324. X    event.time = ticks;
  1325. X    event.tempo = pe->tempo;
  1326. X    switch (stynamic_get_byte(&pe->event, 0)) {
  1327. X    case 0xf0:
  1328. X        /* sysex */
  1329. X        event.type = SYSX;
  1330. X        break;
  1331. X    default:
  1332. X        event.type = NORMAL;
  1333. X        break;
  1334. X    }
  1335. X    stynamic_append(&event.data, &softc->partial_event.event);
  1336. X    /* enqueue new event */
  1337. X    midi_enq(softc->rqueue, &event);
  1338. X    stynamic_release(&event.data);
  1339. X    /* readjust previous event time */
  1340. X    softc->prev_incoming = pe->time;
  1341. X
  1342. X    softc->status &= ~MIDI_RD_BLOCK;
  1343. X    if (softc->status & MIDI_RD_SLEEP) {
  1344. X        softc->status &= ~MIDI_RD_SLEEP;
  1345. X        wakeup((caddr_t)softc->rqueue);
  1346. X    }
  1347. X    if (softc->status & MIDI_ASYNC) {
  1348. X        struct proc *p;
  1349. X
  1350. X        if (softc->pgid < 0)
  1351. X            signal(-softc->pgid, SIGIO);
  1352. X        else if ((p = prfind(softc->pgid)) != 0)
  1353. X            psignal(p, SIGIO);
  1354. X    }
  1355. X
  1356. X    /* notify poll that there is data to be read */
  1357. X    /*
  1358. X     * XXXPOLL - do I only want to do this is a poll is in
  1359. X     * progress and anyyet is 0?  Then I'll need to set
  1360. X     * a status flag, and how do I know when to unset it after
  1361. X     * the poll times out (ala select).
  1362. X     */
  1363. X    pollwakeup(&softc->pollhead, POLLIN);
  1364. X
  1365. X    return;
  1366. X}
  1367. X
  1368. Xvoid
  1369. Xmidi_schedule_timeout(softc)
  1370. X    struct midi_softc *softc;
  1371. X{
  1372. X    struct event *event;
  1373. X
  1374. X    if (!midi_peekq(softc->wqueue, &event))
  1375. X        return;
  1376. X    softc->timeout_id = timeout(midi_timeout, (caddr_t)softc,
  1377. X        event->time);
  1378. X
  1379. X    /* clear record timer? */
  1380. X    if (softc->status & MIDI_RECONPLAY) {
  1381. X        softc->prev_incoming = lbolt;
  1382. X        /* clear flag */
  1383. X        softc->status &= ~MIDI_RECONPLAY;
  1384. X    }
  1385. X}
  1386. X
  1387. Xvoid
  1388. Xmidi_timeout(arg)
  1389. X    caddr_t arg;
  1390. X{
  1391. X    struct event *event;
  1392. X    struct midi_softc *softc = (struct midi_softc *)arg;
  1393. X    int i;
  1394. X
  1395. X    /* send first event since we know it is ready */
  1396. X    midi_deq(softc->wqueue, &event);
  1397. X    midi_write_event(softc, event);
  1398. X    stynamic_release(&event->data);
  1399. X
  1400. X    /* process all events that also occur at this time (event->time == 0) */
  1401. X    for(;;) {
  1402. X        if (!midi_peekq(softc->wqueue, &event))
  1403. X            return;
  1404. X        if (event->time != 0)
  1405. X            break;    
  1406. X        midi_deq(softc->wqueue, NULL);
  1407. X        midi_write_event(softc, event);
  1408. X        stynamic_release(&event->data);
  1409. X    }
  1410. X
  1411. X    /* setup timeout for next event */
  1412. X    midi_schedule_timeout(softc);
  1413. X}
  1414. X
  1415. Xvoid
  1416. Xmidi_write_event(softc, event)
  1417. X    struct midi_softc *softc;
  1418. X    struct event *event;
  1419. X{
  1420. X    int i, j;
  1421. X    u_char bytes[4], channel, command, *dataptr;
  1422. X
  1423. X    switch (event->type) {
  1424. X    case TEMPO:
  1425. X        stynamic_copy(&event->data, &softc->rtempo,
  1426. X            sizeof(softc->rtempo));
  1427. X        break;
  1428. X    case NORMAL:
  1429. X        /*
  1430. X         * fourth byte might not be valid, but who cares,
  1431. X         * we're only reading and in the kernel.  We'll
  1432. X         * ignore it if it isn't.
  1433. X         */
  1434. X        stynamic_copy(&event->data, &bytes, 4);
  1435. X        if (!(bytes[0] & 0x80))
  1436. X            dataptr = &bytes[0];
  1437. X        else {
  1438. X            softc->noteonrs = bytes[0];
  1439. X            dataptr = &bytes[1];
  1440. X        }
  1441. X        command = softc->noteonrs & 0xf0;
  1442. X        channel = softc->noteonrs & 0x0f;
  1443. X        if (command == 0x90) {
  1444. X            /*
  1445. X             * set of clear appropriate bit in noteon
  1446. X             * array depending on velocity value
  1447. X             */
  1448. X            if (dataptr[1] != 0)
  1449. X                softc->noteon[dataptr[0]] |= 1 << channel;
  1450. X            else
  1451. X                softc->noteon[dataptr[0]] &= ~(1 << channel);
  1452. X        }
  1453. X        if (command == 0x80)
  1454. X            /* clear bit */
  1455. X            softc->noteon[dataptr[0]] &= ~(1 << channel);
  1456. X        /* FALLTHRU */
  1457. X    default:
  1458. X        for (i = 0; i < event->data.len; i++) {
  1459. X            if (!midi_wait_rdy_rcv(softc))
  1460. X                break;
  1461. X            OUTB(softc->addr + MIDI_DATA,
  1462. X                stynamic_get_byte(&event->data, i));
  1463. X        }
  1464. X        break;
  1465. X    }
  1466. X    if (softc->wqueue->count < MIDI_LOW_WATER) {
  1467. X        softc->status &= ~MIDI_WR_BLOCK;
  1468. X        if (softc->status & MIDI_WR_SLEEP) {
  1469. X            softc->status &= ~MIDI_WR_SLEEP;
  1470. X            wakeup((caddr_t)softc->wqueue);
  1471. X        }
  1472. X        if (softc->status & MIDI_ASYNC &&
  1473. X            (softc->status & MIDI_SENDIO || softc->wqueue->count
  1474. X            == 0)) {
  1475. X            struct proc *p;
  1476. X
  1477. X            if (softc->pgid < 0)
  1478. X                signal(-softc->pgid, SIGIO);
  1479. X            else if ((p = prfind(softc->pgid)) != 0)
  1480. X                psignal(p, SIGIO);
  1481. X        }
  1482. X        softc->status &= ~MIDI_SENDIO;
  1483. X        /* notify poll that writes will succeed */
  1484. X        /*
  1485. X         * XXXPOLL - do I only want to do this is a poll is in
  1486. X         * progress and anyyet is 0?  Then I'll need to set
  1487. X         * a status flag, and how do I know when to unset it after
  1488. X         * the poll times out (ala select).
  1489. X         */
  1490. X        pollwakeup(&softc->pollhead, POLLOUT);
  1491. X    }
  1492. X    if (softc->status & MIDI_FLUSH_SLEEP && softc->wqueue->count == 0) {
  1493. X        softc->status &= ~MIDI_FLUSH_SLEEP;
  1494. X        wakeup((caddr_t)&softc->status);
  1495. X    }
  1496. X}
  1497. X
  1498. X
  1499. X/*
  1500. X * try to reset the midi devices as best we can
  1501. X */
  1502. Xvoid
  1503. Xmidi_reset_devices(softc)
  1504. X    struct midi_softc *softc;
  1505. X{
  1506. X    int i;
  1507. X    u_char channel, pitch;
  1508. X
  1509. X    /* manual note off calls - turn off any note that is on */
  1510. X    for (pitch = 0; pitch <= 0x7f; pitch++) {
  1511. X        for (channel = 0; channel <= 0x0f; channel++) {
  1512. X            if ((softc->noteon[pitch] >> (int)channel) & 0x01) {
  1513. X                if (!midi_wait_rdy_rcv(softc))
  1514. X                    break;
  1515. X                OUTB(softc->addr + MIDI_DATA, channel | 0x90);
  1516. X
  1517. X                if (!midi_wait_rdy_rcv(softc))
  1518. X                    break;
  1519. X                OUTB(softc->addr + MIDI_DATA, pitch);
  1520. X
  1521. X                if (!midi_wait_rdy_rcv(softc))
  1522. X                    break;
  1523. X                OUTB(softc->addr + MIDI_DATA, 0);
  1524. X            }
  1525. X        }
  1526. X        softc->noteon[pitch] = 0;
  1527. X    }
  1528. X    for (channel = 0; channel <= 0x0f; channel++) {
  1529. X        /*
  1530. X         * send paramter event for all notes off for redundancy
  1531. X         * some older synths don't support this
  1532. X         */
  1533. X        if (!midi_wait_rdy_rcv(softc))
  1534. X            break;
  1535. X        OUTB(softc->addr + MIDI_DATA, channel | 0xb0);
  1536. X        if (!midi_wait_rdy_rcv(softc))
  1537. X            break;
  1538. X        OUTB(softc->addr + MIDI_DATA, 0x7b);
  1539. X        if (!midi_wait_rdy_rcv(softc))
  1540. X            break;
  1541. X        OUTB(softc->addr + MIDI_DATA, 0);
  1542. X
  1543. X        /* modulation controller to zero */
  1544. X        if (!midi_wait_rdy_rcv(softc))
  1545. X            break;
  1546. X        OUTB(softc->addr + MIDI_DATA, 0x01);
  1547. X        if (!midi_wait_rdy_rcv(softc))
  1548. X            break;
  1549. X        OUTB(softc->addr + MIDI_DATA, 0);
  1550. X
  1551. X        /* reset all controllers */
  1552. X        if (!midi_wait_rdy_rcv(softc))
  1553. X            break;
  1554. X        OUTB(softc->addr + MIDI_DATA, 0x79);
  1555. X        if (!midi_wait_rdy_rcv(softc))
  1556. X            break;
  1557. X        OUTB(softc->addr + MIDI_DATA, 0);
  1558. X
  1559. X        /* lift sustain pedal */
  1560. X        if (!midi_wait_rdy_rcv(softc))
  1561. X            break;
  1562. X        OUTB(softc->addr + MIDI_DATA, 0x40);
  1563. X        if (!midi_wait_rdy_rcv(softc))
  1564. X            break;
  1565. X        OUTB(softc->addr + MIDI_DATA, 0);
  1566. X
  1567. X        /* center pitch wheel */
  1568. X        if (!midi_wait_rdy_rcv(softc))
  1569. X            break;
  1570. X        OUTB(softc->addr + MIDI_DATA, 0xe0 | channel);
  1571. X        if (!midi_wait_rdy_rcv(softc))
  1572. X            break;
  1573. X        OUTB(softc->addr + MIDI_DATA, 0);
  1574. X        if (!midi_wait_rdy_rcv(softc))
  1575. X            break;
  1576. X        OUTB(softc->addr + MIDI_DATA, 0x40);
  1577. X    }
  1578. X    softc->noteonrs = 0;
  1579. X}
  1580. X
  1581. Xvoid
  1582. Xmidi_initq(eq)
  1583. X    struct event_queue *eq;
  1584. X{
  1585. X
  1586. X    eq->count = 0;
  1587. X    eq->end = &eq->events[MIDI_Q_SIZE - 1];
  1588. X    eq->head = eq->events;
  1589. X    eq->tail = eq->events;
  1590. X    /* zero events to clear stynamic stuctures */
  1591. X    bzero(eq->events, MIDI_Q_SIZE * sizeof(struct event));
  1592. X}
  1593. X
  1594. Xvoid
  1595. Xmidi_copy_event(e1, e2)
  1596. X    struct event *e1, *e2;
  1597. X{
  1598. X    short i;
  1599. X
  1600. X    e1->time = e2->time;
  1601. X    e1->type = e2->type;
  1602. X    e1->tempo = e2->tempo;
  1603. X    stynamic_release(&e1->data);
  1604. X    stynamic_append(&e1->data, &e2->data);
  1605. X}
  1606. X
  1607. Xint
  1608. Xmidi_deq(eq, event)
  1609. X    struct event_queue *eq;
  1610. X    struct event **event;
  1611. X{
  1612. X    int s;
  1613. X
  1614. X    s = spltty();
  1615. X    if (eq->count == 0) {
  1616. X        splx(s);
  1617. X        return (0);
  1618. X    }
  1619. X    if (event == NULL)
  1620. X        eq->head++;
  1621. X    else
  1622. X        *event = eq->head++;
  1623. X    if (eq->head > eq->end)
  1624. X        eq->head = eq->events;
  1625. X    eq->count--;
  1626. X    splx(s);
  1627. X    return (1);
  1628. X}
  1629. X
  1630. Xint
  1631. Xmidi_peekq(eq, event)
  1632. X    struct event_queue *eq;
  1633. X    struct event **event;
  1634. X{
  1635. X    int s;
  1636. X
  1637. X    s = spltty();
  1638. X    if (eq->count == 0) {
  1639. X        splx(s);
  1640. X        return (0);
  1641. X    }
  1642. X    *event = eq->head;
  1643. X    splx(s);
  1644. X    return (1);
  1645. X}
  1646. X
  1647. Xint
  1648. Xmidi_enq(eq, event)
  1649. X    struct event_queue *eq;
  1650. X    struct event *event;
  1651. X{
  1652. X    int s;
  1653. X
  1654. X    s = spltty();
  1655. X    if (eq->count == MIDI_Q_SIZE) {
  1656. X        splx(s);
  1657. X        return (0);
  1658. X    }
  1659. X    midi_copy_event(eq->tail++, event);
  1660. X    if (eq->tail > eq->end)
  1661. X        eq->tail = eq->events;
  1662. X    eq->count++;
  1663. X    splx(s);
  1664. X    return (1);
  1665. X}
  1666. X
  1667. Xvoid
  1668. Xstynamic_add_byte(sty, byte)
  1669. X    struct stynamic *sty;
  1670. X    u_char byte;
  1671. X{
  1672. X    int s;
  1673. X    u_char *new_ptr;
  1674. X
  1675. X    s = spltty();
  1676. X    if (sty->len < STYNAMIC_SIZE)
  1677. X        sty->datas[sty->len++] = byte;
  1678. X    else {
  1679. X        if (sty->len < sty->allocated) {
  1680. X            sty->datad[sty->len++] = byte;
  1681. X        } else {
  1682. X            new_ptr = kmem_alloc(sty->allocated + STYNAMIC_ALLOC,
  1683. X                KM_NOSLEEP);
  1684. X            if (new_ptr == NULL) {
  1685. X                printf("midi: out of memory\n");
  1686. X                return;
  1687. X            }
  1688. X            if (sty->allocated == 0)
  1689. X                bcopy(sty->datas, new_ptr, sty->len);
  1690. X            else {
  1691. X                bcopy(sty->datad, new_ptr, sty->len);
  1692. X                kmem_free(sty->datad, sty->allocated);
  1693. X            }
  1694. X            sty->datad = new_ptr;
  1695. X            sty->datad[sty->len++] = byte;
  1696. X            sty->allocated += STYNAMIC_ALLOC;
  1697. X        }
  1698. X    }
  1699. X    splx(s);
  1700. X}
  1701. X
  1702. Xvoid
  1703. Xstynamic_add_bytes(sty, bytes, num)
  1704. X    struct stynamic *sty;
  1705. X    u_char *bytes;
  1706. X    int num;
  1707. X{
  1708. X    int s, size_inc;
  1709. X    u_char *new_ptr;
  1710. X
  1711. X    s = spltty();
  1712. X    if (sty->len + num <= STYNAMIC_SIZE) {
  1713. X        bcopy(bytes, &sty->datas[sty->len], num);
  1714. X        sty->len += num;
  1715. X    } else {
  1716. X        if (sty->len + num <= sty->allocated) {
  1717. X            bcopy(bytes, &sty->datad[sty->len], num);
  1718. X            sty->len += num;
  1719. X        } else {
  1720. X            size_inc = (num / STYNAMIC_ALLOC + 1) * STYNAMIC_ALLOC;
  1721. X            new_ptr = kmem_alloc(sty->allocated + size_inc,
  1722. X                KM_NOSLEEP);
  1723. X            if (sty->allocated == 0)
  1724. X                bcopy(sty->datas, new_ptr, sty->len);
  1725. X            else {
  1726. X                bcopy(sty->datad, new_ptr, sty->len);
  1727. X                kmem_free(sty->datad, sty->allocated);
  1728. X            }
  1729. X            sty->datad = new_ptr;
  1730. X            bcopy(bytes, &sty->datad[sty->len], num);
  1731. X            sty->allocated += size_inc;
  1732. X            sty->len += num;
  1733. X        }
  1734. X    }
  1735. X    splx(s);
  1736. X}
  1737. X
  1738. Xu_char
  1739. Xstynamic_get_byte(sty, index)
  1740. X    struct stynamic *sty;
  1741. X    int index;
  1742. X{
  1743. X    int s;
  1744. X
  1745. X    s = spltty();
  1746. X    if (sty->len <= 4)
  1747. X        return (sty->datas[index]);
  1748. X    else
  1749. X        return (sty->datad[index]);
  1750. X    splx(s);
  1751. X}
  1752. X
  1753. Xvoid
  1754. Xstynamic_copy(sty, dest, len)
  1755. X    struct stynamic *sty;
  1756. X    void *dest;
  1757. X    int len;
  1758. X{
  1759. X    int s;
  1760. X
  1761. X    s = spltty();
  1762. X    if (sty->len <= 4)
  1763. X        bcopy(sty->datas, dest, len);
  1764. X    else
  1765. X        bcopy(sty->datad, dest, len);
  1766. X    splx(s);
  1767. X}
  1768. X
  1769. Xvoid
  1770. Xstynamic_append(dest, src)
  1771. X    struct stynamic *dest;
  1772. X    struct stynamic *src;
  1773. X{
  1774. X
  1775. X    if (src->len <= 4)
  1776. X        stynamic_add_bytes(dest, src->datas, src->len);
  1777. X    else
  1778. X        stynamic_add_bytes(dest, src->datad, src->len);
  1779. X}
  1780. X
  1781. Xvoid
  1782. Xstynamic_copy_from(sty, index, dest, len)
  1783. X    struct stynamic *sty;
  1784. X    int index, len;
  1785. X    void *dest;
  1786. X{
  1787. X    int s;
  1788. X
  1789. X    s = spltty();
  1790. X    if (sty->len <= 4)
  1791. X        bcopy(&sty->datas[index], dest, len);
  1792. X    else
  1793. X        bcopy(&sty->datad[index], dest, len);
  1794. X    splx(s);
  1795. X}
  1796. X
  1797. X
  1798. Xvoid
  1799. Xstynamic_release(sty)
  1800. X    struct stynamic *sty;
  1801. X{
  1802. X    int s;
  1803. X
  1804. X    s = spltty();
  1805. X    if (sty->len > STYNAMIC_SIZE)
  1806. X        kmem_free(sty->datad, sty->allocated);
  1807. X    sty->len = 0;
  1808. X    sty->allocated = 0;
  1809. X    sty->datad = NULL;
  1810. X    bzero(sty->datas, STYNAMIC_SIZE);
  1811. X    splx(s);
  1812. X}
  1813. X
  1814. Xvoid
  1815. Xstynamic_shift(sty, num)
  1816. X    struct stynamic *sty;
  1817. X    int num;
  1818. X{
  1819. X    int rem, s;
  1820. X    u_char *ptr;
  1821. X
  1822. X    if (sty->len <= num) {
  1823. X        stynamic_release(sty);
  1824. X        return;
  1825. X    }
  1826. X    s = spltty();
  1827. X    if (sty->len > STYNAMIC_SIZE)
  1828. X        ptr = &sty->datad[num];
  1829. X    else
  1830. X        ptr = &sty->datas[num];
  1831. X    rem = sty->len - num;
  1832. X    if (rem > STYNAMIC_SIZE)
  1833. X        bcopy(ptr, sty->datad, rem);
  1834. X    else {
  1835. X        bcopy(ptr, sty->datas, rem);
  1836. X        if (sty->datad != NULL) {
  1837. X            kmem_free(sty->datad, sty->allocated);
  1838. X            sty->datad = NULL;
  1839. X            sty->allocated = 0;
  1840. X        }
  1841. X    }
  1842. X    splx(s);
  1843. X    sty->len = rem;
  1844. X}
  1845. X
  1846. Xvoid
  1847. Xstynamic_init(sty)
  1848. X    struct stynamic *sty;
  1849. X{
  1850. X    int s;
  1851. X
  1852. X    s = spltty();
  1853. X    sty->len = 0;
  1854. X    sty->allocated = 0;
  1855. X    sty->datad = NULL;
  1856. X    bzero(sty->datas, STYNAMIC_SIZE);
  1857. X    splx(s);
  1858. X}
  1859. X
  1860. Xvoid
  1861. Xstynamic_print(sty)
  1862. X    struct stynamic *sty;
  1863. X{
  1864. X
  1865. X    printf("\t\tlen = %d\n", sty->len);
  1866. X    printf("\t\tallocated = %d\n", sty->allocated);
  1867. X    printf("\t\tdatad = 0x%x\n", sty->datad);
  1868. X}
  1869. X
  1870. X/*
  1871. X * XXXSIGNAL
  1872. X * I have no idea how to verify that a process is killable under
  1873. X * SVR4.  We need to check both individual processes and process
  1874. X * groups.  My drivers don't even cope with broadcast kills, so
  1875. X * don't worry about that one.
  1876. X * See the BSD and LINUX versions for ideas on how to verify this.
  1877. X */
  1878. Xint
  1879. Xmidi_killable(owner, pid)
  1880. X    proc_t *owner;
  1881. X    int pid;
  1882. X{
  1883. X
  1884. X    if (pid == 0)
  1885. X        return (0);
  1886. X    if (pid == -1)
  1887. X        return (EPERM);
  1888. X    return (0);
  1889. X}
  1890. END_OF_FILE
  1891.   if test 42554 -ne `wc -c <'tclmidi-2.0/drivers/SVR4/midi.c'`; then
  1892.     echo shar: \"'tclmidi-2.0/drivers/SVR4/midi.c'\" unpacked with wrong size!
  1893.   fi
  1894.   # end of 'tclmidi-2.0/drivers/SVR4/midi.c'
  1895. fi
  1896. if test -f 'tclmidi-2.0/rb/rb.c' -a "${1}" != "-c" ; then 
  1897.   echo shar: Will not clobber existing file \"'tclmidi-2.0/rb/rb.c'\"
  1898. else
  1899.   echo shar: Extracting \"'tclmidi-2.0/rb/rb.c'\" \(13684 characters\)
  1900.   sed "s/^X//" >'tclmidi-2.0/rb/rb.c' <<'END_OF_FILE'
  1901. X#include <stdio.h>
  1902. X#include <stdlib.h>
  1903. X#include <string.h>
  1904. X#include "rb.h"
  1905. X#include "list.h"
  1906. X
  1907. X#define isred(n) (n->s.red)
  1908. X#define isblack(n) (!isred(n))
  1909. X#define isleft(n) (n->s.left)
  1910. X#define isright(n) (!isleft(n))
  1911. X#define isint(n) (n->s.internal)
  1912. X#define isext(n) (!isint(n))
  1913. X#define ishead(n) (n->s.head)
  1914. X#define isroot(n) (n->s.root)
  1915. X#define setred(n) n->s.red = 1
  1916. X#define setblack(n) n->s.red = 0
  1917. X#define setleft(n) n->s.left = 1
  1918. X#define setright(n) n->s.left = 0
  1919. X#define sethead(n) n->s.head = 1
  1920. X#define setroot(n) n->s.root = 1
  1921. X#define setint(n) n->s.internal = 1
  1922. X#define setext(n) n->s.internal = 0
  1923. X#define setnormal(n) { n->s.root = 0; n ->s.head = 0; }
  1924. X#define sibling(n) ((isleft(n)) ? n->p.parent->c.child.right \
  1925. X                                : n->p.parent->c.child.left)
  1926. X
  1927. X#define mk_new_ext(new, kkkey, vvval) {\
  1928. X    new = (Rb_node) malloc(sizeof(struct rb_node));\
  1929. X    new->v.val = vvval;\
  1930. X    new->k.key = kkkey;\
  1931. X    setext(new);\
  1932. X    setblack(new);\
  1933. X    setnormal(new);\
  1934. X}
  1935. X
  1936. Xvoid
  1937. Xmk_new_int(l, r, p, il)
  1938. X    Rb_node l, r, p;
  1939. X    int il;
  1940. X{
  1941. X    Rb_node new;
  1942. X
  1943. X    new = (Rb_node) malloc(sizeof(struct rb_node));
  1944. X    setint(new);
  1945. X    setred(new);
  1946. X    setnormal(new);
  1947. X    new->c.child.left = l;
  1948. X    new->c.child.right = r;
  1949. X    new->p.parent = p;
  1950. X    new->k.lext = l;
  1951. X    new->v.rext = r;
  1952. X    l->p.parent = new;
  1953. X    r->p.parent = new;
  1954. X    setleft(l);
  1955. X    setright(r);
  1956. X    if (ishead(p)) {
  1957. X        p->p.root = new;
  1958. X        setroot(new);
  1959. X    } else if (il) {
  1960. X        setleft(new);
  1961. X        p->c.child.left = new;
  1962. X    } else {
  1963. X        setright(new);
  1964. X        p->c.child.right = new;
  1965. X    }
  1966. X    recolor(new);
  1967. X}
  1968. X
  1969. X
  1970. XRb_node 
  1971. Xlprev(n)
  1972. X    Rb_node n;
  1973. X{
  1974. X    if (ishead(n))
  1975. X        return (n);
  1976. X    while (!isroot(n)) {
  1977. X        if (isright(n))
  1978. X            return (n->p.parent);
  1979. X        n = n->p.parent;
  1980. X    }
  1981. X    return (n->p.parent);
  1982. X}
  1983. X
  1984. XRb_node 
  1985. Xrprev(n)
  1986. X    Rb_node n;
  1987. X{
  1988. X    if (ishead(n))
  1989. X        return (n);
  1990. X    while (!isroot(n)) {
  1991. X        if (isleft(n))
  1992. X            return (n->p.parent);
  1993. X        n = n->p.parent;
  1994. X    }
  1995. X    return (n->p.parent);
  1996. X}
  1997. X
  1998. XRb_node 
  1999. Xmake_rb()
  2000. X{
  2001. X    Rb_node head;
  2002. X
  2003. X    if ((head = (Rb_node)malloc(sizeof(struct rb_node))) == NULL)
  2004. X        return (NULL);
  2005. X    head->c.list.flink = head;
  2006. X    head->c.list.blink = head;
  2007. X    head->p.root = head;
  2008. X    head->k.key = "";
  2009. X    head->v.val = NULL;
  2010. X    sethead(head);
  2011. X    return (head);
  2012. X}
  2013. X
  2014. XRb_node 
  2015. Xrb_find_key_n(n, key, fnd)
  2016. X    Rb_node n;
  2017. X    char *key;
  2018. X    int *fnd;
  2019. X{
  2020. X    int cmp;
  2021. X
  2022. X    *fnd = 0;
  2023. X    if (!ishead(n)) {
  2024. X        fprintf(stderr, "rb_find_key_n called on non-head 0x%x\n",
  2025. X            (int)n);
  2026. X        exit(1);
  2027. X    }
  2028. X    if (n->p.root == n)
  2029. X        return (n);
  2030. X    cmp = strcmp(key, n->c.list.blink->k.key);
  2031. X    if (cmp == 0) {
  2032. X        *fnd = 1;
  2033. X        return (n->c.list.blink);
  2034. X    }
  2035. X    if (cmp > 0)
  2036. X        return (n);
  2037. X    else
  2038. X        n = n->p.root;
  2039. X    while (1) {
  2040. X        if (isext(n))
  2041. X            return (n);
  2042. X        cmp = strcmp(key, n->k.lext->k.key);
  2043. X        if (cmp == 0) {
  2044. X            *fnd = 1;
  2045. X            return (n->k.lext);
  2046. X        }
  2047. X        if (cmp < 0)
  2048. X            n = n->c.child.left;
  2049. X        else
  2050. X            n = n->c.child.right;
  2051. X    }
  2052. X}
  2053. X
  2054. XRb_node 
  2055. Xrb_find_key(n, key)
  2056. X    Rb_node n;
  2057. X    char *key;
  2058. X{
  2059. X    int fnd;
  2060. X
  2061. X    return (rb_find_key_n(n, key, &fnd));
  2062. X}
  2063. X
  2064. XRb_node 
  2065. Xrb_find_ikey_n(n, ikey, fnd)
  2066. X    Rb_node n;
  2067. X    int ikey;
  2068. X    int *fnd;
  2069. X{
  2070. X    *fnd = 0;
  2071. X    if (!ishead(n)) {
  2072. X        fprintf(stderr, "rb_find_ikey_n called on non-head 0x%x\n",
  2073. X            (int)n);
  2074. X        exit(1);
  2075. X    }
  2076. X    if (n->p.root == n)
  2077. X        return (n);
  2078. X    if (ikey == n->c.list.blink->k.ikey) {
  2079. X        *fnd = 1;
  2080. X        return (n->c.list.blink);
  2081. X    }
  2082. X    if (ikey > n->c.list.blink->k.ikey)
  2083. X        return (n);
  2084. X    else
  2085. X        n = n->p.root;
  2086. X    while (1) {
  2087. X        if (isext(n))
  2088. X            return (n);
  2089. X        if (ikey == n->k.lext->k.ikey) {
  2090. X            *fnd = 1;
  2091. X            return (n->k.lext);
  2092. X        }
  2093. X        n = (ikey < n->k.lext->k.ikey) ? n->c.child.left :
  2094. X            n->c.child.right;
  2095. X    }
  2096. X}
  2097. X
  2098. XRb_node 
  2099. Xrb_find_ukey_n(n, ukey, fnd)
  2100. X    register Rb_node n;
  2101. X    unsigned long ukey;
  2102. X    int *fnd;
  2103. X{
  2104. X
  2105. X    *fnd = 0;
  2106. X    if (!ishead(n)) {
  2107. X        fprintf(stderr, "rb_find_ukey_n called on non-head 0x%x\n",
  2108. X            (int)n);
  2109. X        exit(1);
  2110. X    }
  2111. X    if (n->p.root == n)
  2112. X        return (n);
  2113. X    if (ukey == n->c.list.blink->k.ukey) {
  2114. X        *fnd = 1;
  2115. X        return (n->c.list.blink);
  2116. X    }
  2117. X    if (ukey > n->c.list.blink->k.ukey)
  2118. X        return (n);
  2119. X    else
  2120. X        n = n->p.root;
  2121. X    while (1) {
  2122. X        if (isext(n))
  2123. X            return (n);
  2124. X        if (ukey == n->k.lext->k.ukey) {
  2125. X            *fnd = 1;
  2126. X            return (n->k.lext);
  2127. X        }
  2128. X        n = (ukey < n->k.lext->k.ukey) ? n->c.child.left :
  2129. X            n->c.child.right;
  2130. X    }
  2131. X}
  2132. X
  2133. XRb_node 
  2134. Xrb_find_ikey(n, ikey)
  2135. X    Rb_node n;
  2136. X    int ikey;
  2137. X{
  2138. X    int fnd;
  2139. X
  2140. X    return (rb_find_ikey_n(n, ikey, &fnd));
  2141. X}
  2142. X
  2143. XRb_node 
  2144. Xrb_find_ukey(n, ukey)
  2145. X    Rb_node n;
  2146. X    unsigned long ukey;
  2147. X{
  2148. X    int fnd;
  2149. X
  2150. X    return (rb_find_ukey_n(n, ukey, &fnd));
  2151. X}
  2152. X
  2153. XRb_node 
  2154. Xrb_find_gkey_n(n, key, fxn, fnd)
  2155. X    Rb_node n;
  2156. X    char *key;
  2157. X    int (*fxn)();
  2158. X    int *fnd;
  2159. X{
  2160. X    int cmp;
  2161. X
  2162. X    *fnd = 0;
  2163. X    if (!ishead(n)) {
  2164. X        fprintf(stderr, "rb_find_key_n called on non-head 0x%x\n",
  2165. X            (int)n);
  2166. X        exit(1);
  2167. X    }
  2168. X    if (n->p.root == n)
  2169. X        return (n);
  2170. X    cmp = (*fxn)(key, n->c.list.blink->k.key);
  2171. X    if (cmp == 0) {
  2172. X        *fnd = 1;
  2173. X        return (n->c.list.blink);
  2174. X    }
  2175. X    if (cmp > 0)
  2176. X        return (n);
  2177. X    else
  2178. X        n = n->p.root;
  2179. X    while (1) {
  2180. X        if (isext(n))
  2181. X            return (n);
  2182. X        cmp = (*fxn)(key, n->k.lext->k.key);
  2183. X        if (cmp == 0) {
  2184. X            *fnd = 1;
  2185. X            return (n->k.lext);
  2186. X        }
  2187. X        if (cmp < 0)
  2188. X            n = n->c.child.left;
  2189. X        else
  2190. X            n = n->c.child.right;
  2191. X    }
  2192. X}
  2193. X
  2194. XRb_node 
  2195. Xrb_find_gkey(n, key, fxn)
  2196. X    Rb_node n;
  2197. X    char *key;
  2198. X    int (*fxn)();
  2199. X{
  2200. X    int fnd;
  2201. X
  2202. X    return (rb_find_gkey_n(n, key, fxn, &fnd));
  2203. X}
  2204. XRb_node 
  2205. Xrb_insert_b(n, key, val)
  2206. X    Rb_node n;
  2207. X    char *key;
  2208. X    char *val;
  2209. X{
  2210. X    Rb_node newleft, newright, newnode, p;
  2211. X
  2212. X    if (ishead(n)) {
  2213. X        if (n->p.root == n) {
  2214. X            /* Tree is empty */
  2215. X            mk_new_ext(newnode, key, val);
  2216. X            insert((List)newnode, (List)n);
  2217. X            n->p.root = newnode;
  2218. X            newnode->p.parent = n;
  2219. X            setroot(newnode);
  2220. X            return (newnode);
  2221. X        } else {
  2222. X            mk_new_ext(newright, key, val);
  2223. X            insert((List)newright, (List)n);
  2224. X            newleft = newright->c.list.blink;
  2225. X            setnormal(newleft);
  2226. X            mk_new_int(newleft, newright, newleft->p.parent, isleft(newleft));
  2227. X            p = rprev(newright);
  2228. X            if (!ishead(p))
  2229. X                p->k.lext = newright;
  2230. X            return (newright);
  2231. X        }
  2232. X    } else {
  2233. X        mk_new_ext(newleft, key, val);
  2234. X        insert((List)newleft, (List)n);
  2235. X        setnormal(n);
  2236. X        mk_new_int(newleft, n, n->p.parent, isleft(n));
  2237. X        p = lprev(newleft);
  2238. X        if (!ishead(p))
  2239. X            p->v.rext = newleft;
  2240. X        return (newleft);
  2241. X    }
  2242. X}
  2243. X
  2244. Xvoid
  2245. Xrecolor(n)
  2246. X    Rb_node n;
  2247. X{
  2248. X    Rb_node p, gp, s;
  2249. X    int done = 0;
  2250. X
  2251. X    while (!done) {
  2252. X        if (isroot(n)) {
  2253. X            setblack(n);
  2254. X            return;
  2255. X        }
  2256. X        p = n->p.parent;
  2257. X
  2258. X        if (isblack(p))
  2259. X            return;
  2260. X
  2261. X        if (isroot(p)) {
  2262. X            setblack(p);
  2263. X            return;
  2264. X        }
  2265. X        gp = p->p.parent;
  2266. X        s = sibling(p);
  2267. X        if (isred(s)) {
  2268. X            setblack(p);
  2269. X            setred(gp);
  2270. X            setblack(s);
  2271. X            n = gp;
  2272. X        } else {
  2273. X            done = 1;
  2274. X        }
  2275. X    }
  2276. X    /* p's sibling is black, p is red, gp is black */
  2277. X
  2278. X    if ((isleft(n) == 0) == (isleft(p) == 0)) {
  2279. X        single_rotate(gp, isleft(n));
  2280. X        setblack(p);
  2281. X        setred(gp);
  2282. X    } else {
  2283. X        single_rotate(p, isleft(n));
  2284. X        single_rotate(gp, isleft(n));
  2285. X        setblack(n);
  2286. X        setred(gp);
  2287. X    }
  2288. X}
  2289. X
  2290. Xvoid
  2291. Xsingle_rotate(y, l)
  2292. X    Rb_node y;
  2293. X    int l;
  2294. X{
  2295. X    int rl, ir;
  2296. X    Rb_node x, yp;
  2297. X
  2298. X    /* quiet warning */
  2299. X    rl = 0;
  2300. X    ir = isroot(y);
  2301. X    yp = y->p.parent;
  2302. X    if (!ir) {
  2303. X        rl = isleft(y);
  2304. X    }
  2305. X    if (l) {
  2306. X        x = y->c.child.left;
  2307. X        y->c.child.left = x->c.child.right;
  2308. X        setleft(y->c.child.left);
  2309. X        y->c.child.left->p.parent = y;
  2310. X        x->c.child.right = y;
  2311. X        setright(y);
  2312. X    } else {
  2313. X        x = y->c.child.right;
  2314. X        y->c.child.right = x->c.child.left;
  2315. X        setright(y->c.child.right);
  2316. X        y->c.child.right->p.parent = y;
  2317. X        x->c.child.left = y;
  2318. X        setleft(y);
  2319. X    }
  2320. X
  2321. X    x->p.parent = yp;
  2322. X    y->p.parent = x;
  2323. X    if (ir) {
  2324. X        yp->p.root = x;
  2325. X        setnormal(y);
  2326. X        setroot(x);
  2327. X    } else {
  2328. X        if (rl) {
  2329. X            yp->c.child.left = x;
  2330. X            setleft(x);
  2331. X        } else {
  2332. X            yp->c.child.right = x;
  2333. X            setright(x);
  2334. X        }
  2335. X    }
  2336. X}
  2337. X
  2338. Xvoid
  2339. Xrb_delete_node(n)
  2340. X    Rb_node n;
  2341. X{
  2342. X    Rb_node s, p, gp;
  2343. X    char ir;
  2344. X
  2345. X    if (isint(n)) {
  2346. X        fprintf(stderr, "Cannot delete an internal node: 0x%x\n",
  2347. X            (int)n);
  2348. X        exit(1);
  2349. X    }
  2350. X    if (ishead(n)) {
  2351. X        fprintf(stderr, "Cannot delete the head of an rb_tree: 0x%x\n",
  2352. X            (int)n);
  2353. X        exit(1);
  2354. X    }
  2355. X    delete_item((List)n);    /* Delete it from the list */
  2356. X    p = n->p.parent;    /* The only node */
  2357. X    if (isroot(n)) {
  2358. X        p->p.root = p;
  2359. X        free(n);
  2360. X        return;
  2361. X    }
  2362. X    s = sibling(n);        /* The only node after deletion */
  2363. X    if (isroot(p)) {
  2364. X        s->p.parent = p->p.parent;
  2365. X        s->p.parent->p.root = s;
  2366. X        setroot(s);
  2367. X        free(p);
  2368. X        free(n);
  2369. X        return;
  2370. X    }
  2371. X    gp = p->p.parent;    /* Set parent to sibling */
  2372. X    s->p.parent = gp;
  2373. X    if (isleft(p)) {
  2374. X        gp->c.child.left = s;
  2375. X        setleft(s);
  2376. X    } else {
  2377. X        gp->c.child.right = s;
  2378. X        setright(s);
  2379. X    }
  2380. X    ir = isred(p);
  2381. X    free(p);
  2382. X    free(n);
  2383. X
  2384. X    if (isext(s)) {        /* Update proper rext and lext values */
  2385. X        p = lprev(s);
  2386. X        if (!ishead(p))
  2387. X            p->v.rext = s;
  2388. X        p = rprev(s);
  2389. X        if (!ishead(p))
  2390. X            p->k.lext = s;
  2391. X    } else if (isblack(s)) {
  2392. X        fprintf(stderr, "DELETION PROB -- sib is black, internal\n");
  2393. X        exit(1);
  2394. X    } else {
  2395. X        p = lprev(s);
  2396. X        if (!ishead(p))
  2397. X            p->v.rext = s->c.child.left;
  2398. X        p = rprev(s);
  2399. X        if (!ishead(p))
  2400. X            p->k.lext = s->c.child.right;
  2401. X        setblack(s);
  2402. X        return;
  2403. X    }
  2404. X
  2405. X    if (ir)
  2406. X        return;
  2407. X
  2408. X    /* Recolor */
  2409. X
  2410. X    n = s;
  2411. X    p = n->p.parent;
  2412. X    s = sibling(n);
  2413. X    while (isblack(p) && isblack(s) && isint(s) &&
  2414. X           isblack(s->c.child.left) && isblack(s->c.child.right)) {
  2415. X        setred(s);
  2416. X        n = p;
  2417. X        if (isroot(n))
  2418. X            return;
  2419. X        p = n->p.parent;
  2420. X        s = sibling(n);
  2421. X    }
  2422. X
  2423. X    if (isblack(p) && isred(s)) {    /* Rotation 2.3b */
  2424. X        single_rotate(p, isright(n));
  2425. X        setred(p);
  2426. X        setblack(s);
  2427. X        s = sibling(n);
  2428. X    }
  2429. X    {
  2430. X        Rb_node x, z;
  2431. X        char il;
  2432. X
  2433. X        if (isext(s)) {
  2434. X            fprintf(stderr,
  2435. X                "DELETION ERROR: sibling not internal\n");
  2436. X            exit(1);
  2437. X        }
  2438. X        il = isleft(n);
  2439. X        x = il ? s->c.child.left : s->c.child.right;
  2440. X        z = sibling(x);
  2441. X
  2442. X        if (isred(z)) {    /* Rotation 2.3f */
  2443. X            single_rotate(p, !il);
  2444. X            setblack(z);
  2445. X            if (isred(p))
  2446. X                setred(s);
  2447. X            else
  2448. X                setblack(s);
  2449. X            setblack(p);
  2450. X        } else if (isblack(x)) {
  2451. X            /* Recoloring only (2.3c) */
  2452. X            if (isred(s) || isblack(p)) {
  2453. X                fprintf(stderr,
  2454. X                    "DELETION ERROR: 2.3c not quite right\n");
  2455. X                exit(1);
  2456. X            }
  2457. X            setblack(p);
  2458. X            setred(s);
  2459. X            return;
  2460. X        } else if (isred(p)) {
  2461. X            /* 2.3d */
  2462. X            single_rotate(s, il);
  2463. X            single_rotate(p, !il);
  2464. X            setblack(x);
  2465. X            setred(s);
  2466. X            return;
  2467. X        } else {
  2468. X            /* 2.3e */
  2469. X            single_rotate(s, il);
  2470. X            single_rotate(p, !il);
  2471. X            setblack(x);
  2472. X            return;
  2473. X        }
  2474. X    }
  2475. X}
  2476. X
  2477. Xvoid
  2478. Xrb_print_tree(t, level)
  2479. X    Rb_node t;
  2480. X    int level;
  2481. X{
  2482. X    int i;
  2483. X
  2484. X    if (ishead(t) && t->p.parent == t) {
  2485. X        printf("tree 0x%x is empty\n",
  2486. X            (int)t);
  2487. X    } else if (ishead(t)) {
  2488. X        printf("Head: 0x%x.  Root = 0x%x\n", (int)t, (int)t->p.root);
  2489. X        rb_print_tree(t->p.root, 0);
  2490. X    } else {
  2491. X        if (isext(t)) {
  2492. X            for (i = 0; i < level; i++)
  2493. X                putchar(' ');
  2494. X            printf("Ext node 0x%x: %c,%c: p=0x%x, k=%s\n", (int)t,
  2495. X                isred(t) ? 'R' : 'B', isleft(t) ? 'l' : 'r',
  2496. X                (int)t->p.parent, t->k.key);
  2497. X        } else {
  2498. X            rb_print_tree(t->c.child.left, level + 2);
  2499. X            rb_print_tree(t->c.child.right, level + 2);
  2500. X            for (i = 0; i < level; i++)
  2501. X                putchar(' ');
  2502. X            printf("Int node 0x%x: %c,%c: l=0x%x, r=0x%x, p=0x%x, lr=(%s,%s)\n",
  2503. X                (int)t, isred(t) ? 'R' : 'B', isleft(t) ? 'l' : 'r',
  2504. X                (int)t->c.child.left, (int)t->c.child.right,
  2505. X                (int)t->p.parent, t->k.lext->k.key,
  2506. X                t->v.rext->k.key);
  2507. X        }
  2508. X    }
  2509. X}
  2510. X
  2511. Xvoid
  2512. Xrb_iprint_tree(t, level)
  2513. X    Rb_node t;
  2514. X    int level;
  2515. X{
  2516. X    int i;
  2517. X
  2518. X    if (ishead(t) && t->p.parent == t) {
  2519. X        printf("tree 0x%x is empty\n", (int)t);
  2520. X    } else if (ishead(t)) {
  2521. X        printf("Head: 0x%x.  Root = 0x%x, < = 0x%x, > = 0x%x\n",
  2522. X            (int)t, (int)t->p.root, (int)t->c.list.blink,
  2523. X            (int)t->c.list.flink);
  2524. X        rb_iprint_tree(t->p.root, 0);
  2525. X    } else {
  2526. X        if (isext(t)) {
  2527. X            for (i = 0; i < level; i++)
  2528. X                putchar(' ');
  2529. X            printf("Ext node 0x%x: %c,%c: p=0x%x, <=0x%x, >=0x%x k=%d\n",
  2530. X                (int)t, isred(t) ? 'R' : 'B', isleft(t) ? 'l' : 'r',
  2531. X                (int)t->p.parent, (int)t->c.list.blink,
  2532. X                (int)t->c.list.flink, t->k.ikey);
  2533. X        } else {
  2534. X            rb_iprint_tree(t->c.child.left, level + 2);
  2535. X            rb_iprint_tree(t->c.child.right, level + 2);
  2536. X            for (i = 0; i < level; i++)
  2537. X                putchar(' ');
  2538. X            printf("Int node 0x%x: %c,%c: l=0x%x, r=0x%x, p=0x%x, lr=(%d,%d)\n",
  2539. X                (int)t, isred(t) ? 'R' : 'B', isleft(t) ? 'l' : 'r',
  2540. X                (int)t->c.child.left, (int)t->c.child.right,
  2541. X                (int)t->p.parent, t->k.lext->k.ikey,
  2542. X                t->v.rext->k.ikey);
  2543. X        }
  2544. X    }
  2545. X}
  2546. X
  2547. Xvoid
  2548. Xrb_uprint_tree(t, level)
  2549. X    Rb_node         t;
  2550. X    int             level;
  2551. X{
  2552. X    int             i;
  2553. X    if (ishead(t) && t->p.parent == t) {
  2554. X        printf("tree 0x%x is empty\n", (int)t);
  2555. X    } else if (ishead(t)) {
  2556. X        printf("Head: 0x%x.  Root = 0x%x, < = 0x%x, > = 0x%x\n",
  2557. X            (int)t, (int)t->p.root, (int)t->c.list.blink,
  2558. X            (int)t->c.list.flink);
  2559. X        rb_uprint_tree(t->p.root, 0);
  2560. X    } else {
  2561. X        if (isext(t)) {
  2562. X            for (i = 0; i < level; i++)
  2563. X                putchar(' ');
  2564. X            printf("Ext node 0x%x: %c,%c: p=0x%x, <=0x%x, >=0x%x k=%lu\n",
  2565. X                (int)t, isred(t) ? 'R' : 'B', isleft(t) ? 'l' : 'r',
  2566. X                (int)t->p.parent, (int)t->c.list.blink,
  2567. X                (int)t->c.list.flink, t->k.ukey);
  2568. X        } else {
  2569. X            rb_uprint_tree(t->c.child.left, level + 2);
  2570. X            rb_uprint_tree(t->c.child.right, level + 2);
  2571. X            for (i = 0; i < level; i++)
  2572. X                putchar(' ');
  2573. X            printf("Int node 0x%x: %c,%c: l=0x%x, r=0x%x, p=0x%x, lr=(%lu,%lu)\n",
  2574. X                (int)t, isred(t) ? 'R' : 'B', isleft(t) ? 'l' : 'r',
  2575. X                (int)t->c.child.left, (int)t->c.child.right,
  2576. X                (int)t->p.parent, t->k.lext->k.ukey,
  2577. X                t->v.rext->k.ukey);
  2578. X        }
  2579. X    }
  2580. X}
  2581. X
  2582. Xint
  2583. Xrb_nblack(n)
  2584. X    Rb_node(n);
  2585. X{
  2586. X    int nb;
  2587. X
  2588. X    if (ishead(n) || isint(n)) {
  2589. X        fprintf(stderr,
  2590. X            "ERROR: rb_nblack called on a non-external node 0x%x\n",
  2591. X            (int)n);
  2592. X        exit(1);
  2593. X    }
  2594. X    nb = 0;
  2595. X    while (!ishead(n)) {
  2596. X        if (isblack(n))
  2597. X            nb++;
  2598. X        n = n->p.parent;
  2599. X    }
  2600. X    return (nb);
  2601. X}
  2602. X
  2603. Xint
  2604. Xrb_plength(n)
  2605. X    Rb_node(n);
  2606. X{
  2607. X    int pl;
  2608. X
  2609. X    if (ishead(n) || isint(n)) {
  2610. X        fprintf(stderr,
  2611. X            "ERROR: rb_plength called on a non-external node 0x%x\n",
  2612. X            (int)n);
  2613. X        exit(1);
  2614. X    }
  2615. X    pl = 0;
  2616. X    while (!ishead(n)) {
  2617. X        pl++;
  2618. X        n = n->p.parent;
  2619. X    }
  2620. X    return (pl);
  2621. X}
  2622. X
  2623. Xvoid
  2624. Xrb_free_tree(n)
  2625. X    Rb_node(n);
  2626. X{
  2627. X
  2628. X    if (!ishead(n)) {
  2629. X        fprintf(stderr,
  2630. X            "ERROR: Rb_free_tree called on a non-head node\n");
  2631. X        exit(1);
  2632. X    }
  2633. X    while (rb_first(n) != nil(n)) {
  2634. X        rb_delete_node(rb_first(n));
  2635. X    }
  2636. X    free(n);
  2637. X}
  2638. X
  2639. Xchar *
  2640. Xrb_val(n)
  2641. X    Rb_node(n);
  2642. X{
  2643. X    return (n->v.val);
  2644. X}
  2645. END_OF_FILE
  2646.   if test 13684 -ne `wc -c <'tclmidi-2.0/rb/rb.c'`; then
  2647.     echo shar: \"'tclmidi-2.0/rb/rb.c'\" unpacked with wrong size!
  2648.   fi
  2649.   # end of 'tclmidi-2.0/rb/rb.c'
  2650. fi
  2651. echo shar: End of archive 3 \(of 14\).
  2652. cp /dev/null ark3isdone
  2653. MISSING=""
  2654. for I in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 ; do
  2655.     if test ! -f ark${I}isdone ; then
  2656.     MISSING="${MISSING} ${I}"
  2657.     fi
  2658. done
  2659. if test "${MISSING}" = "" ; then
  2660.     echo You have unpacked all 14 archives.
  2661.     rm -f ark[1-9]isdone ark[1-9][0-9]isdone
  2662. else
  2663.     echo You still must unpack the following archives:
  2664.     echo "        " ${MISSING}
  2665. fi
  2666. exit 0
  2667. exit 0 # Just in case...
  2668.