github.com/Interlisp.maiko
1
0
Fork 0
mirror of https://github.com/Interlisp/maiko.git synced 2026-01-27 12:22:24 +00:00
Code Issues Projects Releases Wiki Activity

Remove cdrom&cdaudio support code. (#339)

Browse Source 
This is not used in Medley (the MISCN-TABLE-LIST doesn't include
the required constants), nor does anything use or reference this
code. It also won't compile as it needs some routines that are
missing from our code.
This commit is contained in:
Bruce Mitchener
2021-02-10 11:38:08 +07:00
committed by GitHub
parent 78943073c3
commit b21aeecf4c
6 changed files with 0 additions and 678 deletions
Download Patch File Download Diff File Expand all files Collapse all files

306
src/cdaudio.c
View File

@@ -1,306 +0,0 @@
/* $Id: cdaudio.c,v 1.3 1999/05/31 23:35:25 sybalsky Exp $ (C) Copyright Venue, All Rights Reserved
*/
/************************************************************************/
/* */
/* (C) Copyright 1989-95 Venue. All Rights Reserved. */
/* Manufactured in the United States of America. */
/* */
/************************************************************************/
#include "version.h"
/***********************************
file: cdaudio.c
***********************************/
#include <stdio.h>
#include <strings.h>
#include "lispemul.h"
#include "address.h"
#include "adr68k.h"
#include "lsptypes.h"
#include "lispmap.h"
#include "emlglob.h"
#include "lspglob.h"
#include "arith.h"
#include "cdrom.h"
int cdaudio(LispPTR *args) {
int request;
int res;
N_GETNUMBER(args[0], request, BAD_ARG);
#ifdef DEBUG
printf("CD-ROM function called. function = %d\n", request);
#endif
switch (request) {
case CD_OPEN: res = cd_open(args); break;
case CD_CLOSE: res = cd_close(args); break;
case CD_READ: res = cd_read(args); break;
case CD_DISK_INFO: res = cd_disk_info(args); break;
case CD_TRACK_INFO: res = cd_track_info(args); break;
case CD_START: res = cd_start(args); break;
case CD_STOP: res = cd_stop(args); break;
case CD_PLAY: res = cd_play(args); break;
case CD_Q_READ: res = cd_q_read(args); break;
case CD_PAUSE: res = cd_pause(args); break;
case CD_RESUME: res = cd_resume(args); break;
case CD_VOLUME: res = cd_volume(args); break;
case CD_EJECT: res = cd_eject(args); break;
default: return (NIL); break;
}
#ifdef DEBUG
printf("Result = %d\n", res);
#endif
if (res == 0) {
return (ATOM_T);
} else {
return (GetSmallp(res));
}
BAD_ARG:
return (NIL);
}
int cd_open(LispPTR *args)
/*
args[0] function number
args[1] CD-ROM drive path name string
*/
{
char drive[80];
LispStringToCString(args[1], drive, 80);
#ifdef DEBUG
printf("cd_open called. drive = %s\n", drive);
#endif
return (CDopen(drive));
}
int cd_close(LispPTR *args)
/*
args[0] function number
*/
{
#ifdef DEBUG
printf("cd_close is called\n");
#endif
return (CDclose());
}
int cd_read(LispPTR *args)
/*
args[0] function number
args[1] Logical block number
args[2] number of blocks to read
args[3] data buffer
*/
{
DWORD blk;
int num;
BYTE *buf;
LispPTR *naddress;
char *base;
int offset;
switch (GetTypeNumber(args[1])) {
case TYPE_SMALLP: N_GETNUMBER(args[1], blk, BAD_ARG); break;
case TYPE_FIXP: blk = *(DWORD *)(Addr68k_from_LADDR(args[1])); break;
default: return (1); break;
}
switch (GetTypeNumber(args[2])) {
case TYPE_SMALLP: N_GETNUMBER(args[2], num, BAD_ARG); break;
case TYPE_FIXP: num = *(DWORD *)(Addr68k_from_LADDR(args[2])); break;
default: return (1); break;
}
if (GetTypeNumber(args[3]) == TYPE_ONED_ARRAY) {
naddress = (LispPTR *)(Addr68k_from_LADDR(args[3]));
base = (char *)(Addr68k_from_LADDR(((OneDArray *)naddress)->base));
offset = (int)(((OneDArray *)naddress)->offset);
buf = base + offset;
} else
return (1);
#ifdef DEBUG
printf("call CDread()\n");
printf("blk = %d, num = %d buff = %d\n", blk, num, buf);
#endif
return (CDread(blk, num, buf));
BAD_ARG:
return (1);
}
int cd_disk_info(LispPTR *args)
/*
args[0] function number
args[1] min tune number
args[2] max tune number
*/
{
BYTE min_no, max_no;
int res;
res = CDdisk_info(&min_no, &max_no);
#ifdef DEBUG
printf("min = %d, max = %d", min_no, max_no);
#endif
*(int *)(Addr68k_from_LADDR(args[1])) = (int)min_no;
*(int *)(Addr68k_from_LADDR(args[2])) = (int)max_no;
return (res);
}
int cd_track_info(LispPTR *args)
/*
args[0] function number (in: smallp)
args[1] tune number (in: fixp)
args[2] start address(LBN) (out: fixp)
args[3] control data (out: fixp)
*/
{
int tno;
DWORD blk;
BYTE cntl;
int res;
switch (GetTypeNumber(args[1])) {
case TYPE_SMALLP: N_GETNUMBER(args[1], tno, BAD_ARG); break;
case TYPE_FIXP: tno = *(DWORD *)(Addr68k_from_LADDR(args[1])); break;
}
res = CDtrack_info(tno, &blk, &cntl);
*(int *)(Addr68k_from_LADDR(args[2])) = (int)blk;
*(int *)(Addr68k_from_LADDR(args[3])) = (int)cntl;
return (res);
BAD_ARG:
return (-1);
}
int cd_start(LispPTR *args)
/*
args[0] function number
*/
{
return (CDstart());
}
int cd_stop(LispPTR *args)
/*
args[0] function number
*/
{
return (CDstop());
}
int cd_play(LispPTR *args)
/*
args[0] function number
args[1] play start address(LBN)
args[2] play end address(LBN)
*/
{
DWORD sblk, eblk;
switch (GetTypeNumber(args[1])) {
case TYPE_SMALLP: N_GETNUMBER(args[1], sblk, BAD_ARG); break;
case TYPE_FIXP: sblk = *(DWORD *)(Addr68k_from_LADDR(args[1])); break;
}
switch (GetTypeNumber(args[2])) {
case TYPE_SMALLP: N_GETNUMBER(args[2], eblk, BAD_ARG); break;
case TYPE_FIXP: eblk = *(DWORD *)(Addr68k_from_LADDR(args[2])); break;
}
return (CDplay(sblk, eblk));
BAD_ARG:
return (1);
}
int cd_q_read(LispPTR *args)
/*
args[0] function number
args[1] audio status
args[2] tune number
args[3] current position min
args[4] current position sec
args[5] current position frame
*/
{
BYTE ast, tno, mm, ss, ff;
int res;
res = CDqread(&ast, &tno, &mm, &ss, &ff);
if (!res) {
*(int *)(Addr68k_from_LADDR(args[1])) = (int)ast;
*(int *)(Addr68k_from_LADDR(args[2])) = (int)tno;
*(int *)(Addr68k_from_LADDR(args[3])) = (int)mm;
*(int *)(Addr68k_from_LADDR(args[4])) = (int)ss;
*(int *)(Addr68k_from_LADDR(args[5])) = (int)ff;
}
return (res);
}
int cd_pause(LispPTR *args)
/*
args[0] function number
*/
{
return (CDpause());
}
int cd_resume(LispPTR *args)
/*
args[0] function number
*/
{
return (CDresume());
}
int cd_volume(LispPTR *args)
/*
args[0] function number
args[1] right volume
args[2] left volume
*/
{
int right, left;
switch (GetTypeNumber(args[1])) {
case TYPE_SMALLP: N_GETNUMBER(args[1], right, BAD_ARG); break;
case TYPE_FIXP: right = *(DWORD *)(Addr68k_from_LADDR(args[1])); break;
}
switch (GetTypeNumber(args[2])) {
case TYPE_SMALLP: N_GETNUMBER(args[2], left, BAD_ARG); break;
case TYPE_FIXP: left = *(DWORD *)(Addr68k_from_LADDR(args[2])); break;
}
return (CDvolume(right, left));
BAD_ARG:
return (1);
}
int cd_eject(LispPTR *args)
/*
args[0] function number
*/
{
#ifdef DEBUG
printf("cd_eject called.\n");
#endif
return (CDeject());
}

216
src/cdrom.c
View File

@@ -1,216 +0,0 @@
/* $Id: cdrom.c,v 1.3 1999/05/31 23:35:26 sybalsky Exp $ (C) Copyright Venue, All Rights Reserved */
/************************************************************************/
/* */
/* (C) Copyright 1989-95 Venue. All Rights Reserved. */
/* Manufactured in the United States of America. */
/* */
/************************************************************************/
#include "version.h"
/***********************************
file: cdrom.c
***********************************/
#include <stdio.h>
#include <strings.h>
#include "lispemul.h"
#include "address.h"
#include "adr68k.h"
#include "lsptypes.h"
#include "lispmap.h"
#include "emlglob.h"
#include "lspglob.h"
#include "arith.h"
#include "cdrom.h"
int cdrom(LispPTR *args) {
int request;
int res;
N_GETNUMBER(args[0], request, BAD_ARG);
#ifdef DEBUG
printf("CD-ROM function called. function = %d\n", request);
#endif
switch (request) {
case CDROM_INIT_DRV: res = cdrom_init_drv(args); break;
case CDROM_KEN_INT: res = cdrom_ken_int(args); break;
case CDROM_CHOSAKU: res = cdrom_chosaku(args); break;
case CDROM_MIKANA: res = cdrom_mikana(args); break;
case CDROM_MIKANAT: res = cdrom_mikanat(args); break;
case CDROM_SYURYO: res = cdrom_syuryo(args); break;
default: return (NIL); break;
}
#ifdef DEBUG
printf("Result = %d\n", res);
#endif
if (res == 0) {
return (ATOM_T);
} else {
return (GetSmallp(res));
}
BAD_ARG:
return (NIL);
}
static int cdrom_init_drv(LispPTR *args)
/*
args[0] function number
args[1] pointer to buffer
args[2] device name
*/
{
int res;
char *buff;
char drive[80];
LispPTR *naddress;
char *base;
int offset;
if (GetTypeNumber(args[1]) == TYPE_ONED_ARRAY) {
naddress = (LispPTR *)(Addr68k_from_LADDR(args[1]));
base = (char *)(Addr68k_from_LADDR(((OneDArray *)naddress)->base));
offset = (int)(((OneDArray *)naddress)->offset);
buff = &base[offset];
} else
return (1);
LispStringToCString(args[2], drive, 80);
return (init_drv(buff, drive));
}
static int cdrom_ken_int(LispPTR *args)
/*
args[0] function number
args[1] shoseki number
args[2] flag for index and sort
*/
{
int bunno;
int flg;
N_GETNUMBER(args[1], bunno, BAD_ARG);
N_GETNUMBER(args[2], flg, BAD_ARG);
#ifdef DEBUG
printf("bunno = %x\n", bunno);
printf("flg = %d\n", flg);
#endif
return (ken_int(bunno, flg));
BAD_ARG:
return (1);
}
static int cdrom_chosaku(LispPTR *args)
/*
args[0] function number
args[1] buffer for copy right data
args[2] real data size
*/
{
char *buff;
int size;
int *data_size;
LispPTR *naddress;
char *base;
int offset;
if (GetTypeNumber(args[1]) == TYPE_ONED_ARRAY) {
naddress = (LispPTR *)(Addr68k_from_LADDR(args[1]));
base = (char *)(Addr68k_from_LADDR(((OneDArray *)naddress)->base));
offset = (int)(((OneDArray *)naddress)->offset);
buff = &base[offset];
} else
return (1);
size = (int)(((OneDArray *)naddress)->totalsize);
#ifdef DEBUG
printf("size = %d\n", size);
#endif
data_size = (int *)(Addr68k_from_LADDR(args[2]));
return (chosaku(buff, size, data_size));
}
static int cdrom_mikana(LispPTR *args)
/*
args[0] function number
args[1] relative id number
args[2] pointer to retrieve data
args[3] size of retrieve data
*/
{
int hyono;
char *buff;
int buff_size;
int *data_size;
LispPTR *naddress;
char *base;
int offset;
N_GETNUMBER(args[1], hyono, BAD_ARG);
if (GetTypeNumber(args[2]) == TYPE_ONED_ARRAY) {
naddress = (LispPTR *)(Addr68k_from_LADDR(args[2]));
base = (char *)(Addr68k_from_LADDR(((OneDArray *)naddress)->base));
offset = (int)(((OneDArray *)naddress)->offset);
buff = &base[offset];
} else
return (1);
buff_size = (int)(((OneDArray *)naddress)->totalsize);
data_size = (int *)(Addr68k_from_LADDR(args[3]));
return (mikana(hyono, buff, buff_size, data_size));
BAD_ARG:
return (1);
}
static int cdrom_mikanat(LispPTR *args)
/*
args[0] function number
args[1] pointer to a search key
args[2] pointer to buffer
args[3] size of searched data
args[4] number of items matched to the search key
*/
{
char key[65];
char *buff;
int buff_size;
int *data_size;
int *hitn;
LispPTR *naddress;
char *base;
int offset;
LispStringToCString2(args[1], key, 65);
if (GetTypeNumber(args[2]) == TYPE_ONED_ARRAY) {
naddress = (LispPTR *)(Addr68k_from_LADDR(args[2]));
base = (char *)(Addr68k_from_LADDR(((OneDArray *)naddress)->base));
offset = (int)(((OneDArray *)naddress)->offset);
buff = &base[offset];
} else
return (1);
buff_size = (((OneDArray *)naddress)->totalsize);
data_size = (int *)(Addr68k_from_LADDR(args[3]));
hitn = (int *)(Addr68k_from_LADDR(args[4]));
return (mikanat(key, buff, buff_size, data_size, hitn));
}
static int cdrom_syuryo(LispPTR *args)
/*
args[0] function number
*/
{
return (syuryo());
}

5
src/miscn.c
View File

@@ -155,11 +155,6 @@ int OP_miscn(int misc_index, int arg_count) {
break;
#endif /* JLISP */
#ifdef CDROM
case miscn_CDAUDIO: result = cdaudio(args); break;
case miscn_CDROM: result = cdrom(args); break;
#endif /* CDROM */
case /* miscn_CALL_C*/ 014:
/* result = call_c_fn(args); */
result = 0;