mirror of
https://github.com/python/cpython.git
synced 2024-11-24 08:52:25 +01:00
438 lines
8.7 KiB
C
438 lines
8.7 KiB
C
/***********************************************************
|
|
Copyright 1991, 1992, 1993, 1994 by Stichting Mathematisch Centrum,
|
|
Amsterdam, The Netherlands.
|
|
|
|
All Rights Reserved
|
|
|
|
Permission to use, copy, modify, and distribute this software and its
|
|
documentation for any purpose and without fee is hereby granted,
|
|
provided that the above copyright notice appear in all copies and that
|
|
both that copyright notice and this permission notice appear in
|
|
supporting documentation, and that the names of Stichting Mathematisch
|
|
Centrum or CWI not be used in advertising or publicity pertaining to
|
|
distribution of the software without specific, written prior permission.
|
|
|
|
STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO
|
|
THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
|
|
FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE
|
|
FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
|
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
|
|
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
|
|
OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
|
|
|
******************************************************************/
|
|
|
|
/*
|
|
** Written by Jack Jansen, October 1994, initially only to allow him to
|
|
** test the ctb module:-)
|
|
*/
|
|
|
|
#include "allobjects.h"
|
|
#include "modsupport.h" /* For getargs() etc. */
|
|
#include "structmember.h"
|
|
|
|
#include <console.h>
|
|
|
|
static object *ErrorObject;
|
|
|
|
#define OFF(x) offsetof(struct __copt, x)
|
|
|
|
static struct memberlist copt_memberlist[] = {
|
|
{"top", T_SHORT, OFF(top)},
|
|
{"left", T_SHORT, OFF(left)},
|
|
{"title", T_PSTRING, OFF(title)},
|
|
{"procID", T_SHORT, OFF(procID), RO},
|
|
{"txFont", T_SHORT, OFF(txFont)},
|
|
{"txSize", T_SHORT, OFF(txSize)},
|
|
{"txFace", T_SHORT, OFF(txFace)},
|
|
{"nrows", T_SHORT, OFF(nrows)},
|
|
{"ncols", T_SHORT, OFF(ncols)},
|
|
{"pause_atexit", T_SHORT, OFF(pause_atexit)},
|
|
{NULL}
|
|
};
|
|
|
|
static unsigned char mytitle[256];
|
|
typedef struct {
|
|
OB_HEAD
|
|
} coptobject;
|
|
|
|
staticforward typeobject Xxotype;
|
|
|
|
#define is_coptobject(v) ((v)->ob_type == &Xxotype)
|
|
|
|
static coptobject *
|
|
newcoptobject()
|
|
{
|
|
coptobject *self;
|
|
self = NEWOBJ(coptobject, &Xxotype);
|
|
return self;
|
|
}
|
|
|
|
/* Xxo methods */
|
|
|
|
static void
|
|
copt_dealloc(self)
|
|
coptobject *self;
|
|
{
|
|
DEL(self);
|
|
}
|
|
|
|
static object *
|
|
copt_getattr(self, name)
|
|
coptobject *self;
|
|
char *name;
|
|
{
|
|
return getmember((char *)&console_options, copt_memberlist, name);
|
|
}
|
|
|
|
static int
|
|
copt_setattr(self, name, v)
|
|
coptobject *self;
|
|
char *name;
|
|
object *v;
|
|
{
|
|
char *str;
|
|
int len;
|
|
|
|
if ( strcmp(name, "title") == 0 ) {
|
|
if ( !v || !is_stringobject(v)) {
|
|
err_setstr(ErrorObject, "title must be a string");
|
|
return -1;
|
|
}
|
|
str = getstringvalue(v);
|
|
len = strlen(str);
|
|
mytitle[0] = (unsigned char)len;
|
|
strncpy((char *)mytitle+1, str, mytitle[0]);
|
|
console_options.title = mytitle;
|
|
return 0;
|
|
}
|
|
return setmember((char *)&console_options, copt_memberlist, name, v);
|
|
}
|
|
|
|
static typeobject Xxotype = {
|
|
OB_HEAD_INIT(&Typetype)
|
|
0, /*ob_size*/
|
|
"console options", /*tp_name*/
|
|
sizeof(coptobject), /*tp_basicsize*/
|
|
0, /*tp_itemsize*/
|
|
/* methods */
|
|
(destructor)copt_dealloc, /*tp_dealloc*/
|
|
0, /*tp_print*/
|
|
(getattrfunc)copt_getattr, /*tp_getattr*/
|
|
(setattrfunc)copt_setattr, /*tp_setattr*/
|
|
0, /*tp_compare*/
|
|
0, /*tp_repr*/
|
|
0, /*tp_as_number*/
|
|
0, /*tp_as_sequence*/
|
|
0, /*tp_as_mapping*/
|
|
0, /*tp_hash*/
|
|
};
|
|
|
|
/* ------------------------------------------- */
|
|
|
|
typedef struct {
|
|
OB_HEAD
|
|
FILE *fp;
|
|
object *file;
|
|
} cons_object;
|
|
|
|
staticforward typeobject constype;
|
|
|
|
#define is_cons_object(v) ((v)->ob_type == &constype)
|
|
|
|
static cons_object *
|
|
newcons_object(fp, file)
|
|
FILE *fp;
|
|
object *file;
|
|
{
|
|
cons_object *self;
|
|
self = NEWOBJ(cons_object, &constype);
|
|
if (self == NULL)
|
|
return NULL;
|
|
self->fp = fp;
|
|
self->file = file;
|
|
return self;
|
|
}
|
|
|
|
/* cons methods */
|
|
|
|
static void
|
|
cons_dealloc(self)
|
|
cons_object *self;
|
|
{
|
|
DECREF(self->file);
|
|
DEL(self);
|
|
}
|
|
|
|
static object *
|
|
cons_setmode(self, args)
|
|
cons_object *self;
|
|
object *args;
|
|
{
|
|
int mode;
|
|
|
|
if (!getargs(args, "i", &mode))
|
|
return NULL;
|
|
csetmode(mode, self->fp);
|
|
INCREF(None);
|
|
return None;
|
|
}
|
|
|
|
static object *
|
|
cons_cleos(self, args)
|
|
cons_object *self;
|
|
object *args;
|
|
{
|
|
if (!getnoarg(args))
|
|
return NULL;
|
|
ccleos(self->fp);
|
|
INCREF(None);
|
|
return None;
|
|
}
|
|
|
|
static object *
|
|
cons_cleol(self, args)
|
|
cons_object *self;
|
|
object *args;
|
|
{
|
|
if (!getnoarg(args))
|
|
return NULL;
|
|
ccleol(self->fp);
|
|
INCREF(None);
|
|
return None;
|
|
}
|
|
|
|
static object *
|
|
cons_show(self, args)
|
|
cons_object *self;
|
|
object *args;
|
|
{
|
|
if (!getnoarg(args))
|
|
return NULL;
|
|
cshow(self->fp);
|
|
INCREF(None);
|
|
return None;
|
|
}
|
|
|
|
static object *
|
|
cons_hide(self, args)
|
|
cons_object *self;
|
|
object *args;
|
|
{
|
|
if (!getnoarg(args))
|
|
return NULL;
|
|
chide(self->fp);
|
|
INCREF(None);
|
|
return None;
|
|
}
|
|
|
|
static object *
|
|
cons_echo2printer(self, args)
|
|
cons_object *self;
|
|
object *args;
|
|
{
|
|
if (!getnoarg(args))
|
|
return NULL;
|
|
cecho2printer(self->fp);
|
|
INCREF(None);
|
|
return None;
|
|
}
|
|
|
|
static object *
|
|
cons_gotoxy(self, args)
|
|
cons_object *self;
|
|
object *args;
|
|
{
|
|
int x, y;
|
|
|
|
if (!getargs(args, "(ii)", &x, &y))
|
|
return NULL;
|
|
cgotoxy(x, y, self->fp);
|
|
INCREF(None);
|
|
return None;
|
|
}
|
|
|
|
static object *
|
|
cons_getxy(self, args)
|
|
cons_object *self;
|
|
object *args;
|
|
{
|
|
int x, y;
|
|
|
|
if (!getnoarg(args))
|
|
return NULL;
|
|
cgetxy(&x, &y, self->fp);
|
|
return mkvalue("(ii)", x, y);
|
|
}
|
|
|
|
static object *
|
|
cons_settabs(self, args)
|
|
cons_object *self;
|
|
object *args;
|
|
{
|
|
int arg;
|
|
|
|
if (!getargs(args, "i", &arg))
|
|
return NULL;
|
|
csettabs(arg, self->fp);
|
|
INCREF(None);
|
|
return None;
|
|
}
|
|
|
|
static object *
|
|
cons_inverse(self, args)
|
|
cons_object *self;
|
|
object *args;
|
|
{
|
|
int arg;
|
|
|
|
if (!getargs(args, "i", &arg))
|
|
return NULL;
|
|
cinverse(arg, self->fp);
|
|
INCREF(None);
|
|
return None;
|
|
}
|
|
|
|
static struct methodlist cons_methods[] = {
|
|
{"setmode", (method)cons_setmode},
|
|
{"gotoxy", (method)cons_gotoxy},
|
|
{"getxy", (method)cons_getxy},
|
|
{"cleos", (method)cons_cleos},
|
|
{"cleol", (method)cons_cleol},
|
|
{"settabs", (method)cons_settabs},
|
|
{"inverse", (method)cons_inverse},
|
|
{"show", (method)cons_show},
|
|
{"hide", (method)cons_hide},
|
|
{"echo2printer", (method)cons_echo2printer},
|
|
{NULL, NULL} /* sentinel */
|
|
};
|
|
|
|
static object *
|
|
cons_getattr(self, name)
|
|
cons_object *self;
|
|
char *name;
|
|
{
|
|
if ( strcmp(name, "file") == 0 ) {
|
|
INCREF(self->file);
|
|
return self->file;
|
|
}
|
|
return findmethod(cons_methods, (object *)self, name);
|
|
}
|
|
|
|
static typeobject constype = {
|
|
OB_HEAD_INIT(&Typetype)
|
|
0, /*ob_size*/
|
|
"cons", /*tp_name*/
|
|
sizeof(cons_object), /*tp_basicsize*/
|
|
0, /*tp_itemsize*/
|
|
/* methods */
|
|
(destructor)cons_dealloc, /*tp_dealloc*/
|
|
0, /*tp_print*/
|
|
(getattrfunc)cons_getattr, /*tp_getattr*/
|
|
0, /*tp_setattr*/
|
|
0, /*tp_compare*/
|
|
0, /*tp_repr*/
|
|
0, /*tp_as_number*/
|
|
0, /*tp_as_sequence*/
|
|
0, /*tp_as_mapping*/
|
|
0, /*tp_hash*/
|
|
};
|
|
/* --------------------------------------------------------------------- */
|
|
|
|
/* Return a new console */
|
|
|
|
static object *
|
|
maccons_copen(self, args)
|
|
object *self; /* Not used */
|
|
object *args;
|
|
{
|
|
FILE *fp;
|
|
object *file;
|
|
cons_object *rv;
|
|
char *name;
|
|
unsigned char nbuf[256];
|
|
int len;
|
|
|
|
name = NULL;
|
|
if (!getnoarg(args))
|
|
return NULL;
|
|
if ( (fp=fopenc()) == NULL ) {
|
|
err_errno(ErrorObject);
|
|
return NULL;
|
|
}
|
|
if ( (file=newopenfileobject(fp, "<a console>", "r+", fclose)) == NULL)
|
|
return NULL;
|
|
rv = newcons_object(fp, file);
|
|
if ( rv == NULL ) {
|
|
fclose(fp);
|
|
return NULL;
|
|
}
|
|
return (object *)rv;
|
|
}
|
|
|
|
/* Return an open file as a console */
|
|
|
|
static object *
|
|
maccons_fopen(self, args)
|
|
object *self; /* Not used */
|
|
object *args;
|
|
{
|
|
cons_object *rv;
|
|
object *file;
|
|
FILE *fp;
|
|
|
|
if (!newgetargs(args, "O", &file))
|
|
return NULL;
|
|
if ( !is_fileobject(file) ) {
|
|
err_badarg();
|
|
return NULL;
|
|
}
|
|
fp = getfilefile(file);
|
|
if ( !isatty(fileno(fp)) ) {
|
|
err_setstr(ErrorObject, "File is not a console");
|
|
return NULL;
|
|
}
|
|
rv = newcons_object(fp, file);
|
|
if ( rv == NULL ) {
|
|
return NULL;
|
|
}
|
|
INCREF(file);
|
|
return (object *)rv;
|
|
}
|
|
|
|
/* List of functions defined in the module */
|
|
|
|
static struct methodlist maccons_methods[] = {
|
|
{"fopen", (method)maccons_fopen, 1},
|
|
{"copen", (method)maccons_copen, 0},
|
|
{NULL, NULL} /* sentinel */
|
|
};
|
|
|
|
|
|
/* Initialization function for the module (*must* be called initmacconsole) */
|
|
|
|
void
|
|
initmacconsole()
|
|
{
|
|
object *m, *d, *o;
|
|
|
|
/* Create the module and add the functions */
|
|
m = initmodule("macconsole", maccons_methods);
|
|
|
|
/* Add some symbolic constants to the module */
|
|
#define INTATTR(name, value) o = newintobject(value); dictinsert(d, name, o);
|
|
d = getmoduledict(m);
|
|
ErrorObject = newstringobject("macconsole.error");
|
|
dictinsert(d, "error", ErrorObject);
|
|
o = (object *)newcoptobject();
|
|
dictinsert(d, "options", o);
|
|
INTATTR("C_RAW", C_RAW);
|
|
INTATTR("C_CBREAK", C_CBREAK);
|
|
INTATTR("C_ECHO", C_ECHO);
|
|
INTATTR("C_NOECHO", C_NOECHO);
|
|
|
|
/* Check for errors */
|
|
if (err_occurred())
|
|
fatal("can't initialize module macconsole");
|
|
}
|