![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to portdat.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Plan 9 NeXT] / lucent / sys / src / 9 / port|
Return to portdat.h CVS log | Up to [Plan 9 NeXT] / lucent / sys / src / 9 / port |
1.1 root 1: typedef struct Alarms Alarms;
2: typedef struct Block Block;
3: typedef struct Blist Blist;
4: typedef struct Chan Chan;
5: typedef struct Dev Dev;
6: typedef struct Dirtab Dirtab;
7: typedef struct Egrp Egrp;
8: typedef struct Evalue Evalue;
9: typedef struct Etherpkt Etherpkt;
10: typedef struct Fgrp Fgrp;
11: typedef struct Image Image;
12: typedef struct IOQ IOQ;
13: typedef struct KIOQ KIOQ;
14: typedef struct List List;
15: typedef struct Mount Mount;
16: typedef struct Mnt Mnt;
17: typedef struct Mhead Mhead;
18: typedef struct Netinf Netinf;
19: typedef struct Netprot Netprot;
20: typedef struct Network Network;
21: typedef struct Note Note;
22: typedef struct Page Page;
23: typedef struct Palloc Palloc;
24: typedef struct Parallax Parallax;
25: typedef struct Pgrps Pgrps;
26: typedef struct Pgrp Pgrp;
27: typedef struct Physseg Physseg;
28: typedef struct Proc Proc;
29: typedef struct Pte Pte;
30: typedef struct Qinfo Qinfo;
31: typedef struct QLock QLock;
32: typedef struct Queue Queue;
33: typedef struct Ref Ref;
34: typedef struct Rendez Rendez;
35: typedef struct RWlock RWlock;
36: typedef struct Sargs Sargs;
37: typedef struct Session Session;
38: typedef struct Scsi Scsi;
39: typedef struct Scsibuf Scsibuf;
40: typedef struct Scsidata Scsidata;
41: typedef struct Segment Segment;
42: typedef struct Stream Stream;
43: typedef struct Talarm Talarm;
44: typedef struct Waitq Waitq;
45: typedef int Devgen(Chan*, Dirtab*, int, int, Dir*);
46: typedef void Streamput(Queue*, Block*);
47: typedef void Streamopen(Queue*, Stream*);
48: typedef void Streamclose(Queue*);
49: typedef void Streamreset(void);
50:
51: #include <auth.h>
52: #include <fcall.h>
53:
54: struct Ref
55: {
56: Lock;
57: long ref;
58: };
59:
60: struct Rendez
61: {
62: Lock;
63: Proc *p;
64: };
65:
66: struct QLock
67: {
68: Lock use; /* to access Qlock structure */
69: Proc *head; /* next process waiting for object */
70: Proc *tail; /* last process waiting for object */
71: int locked; /* flag */
72: };
73:
74: struct RWlock
75: {
76: Lock; /* Lock modify lock */
77: QLock x; /* Mutual exclusion lock */
78: QLock k; /* Lock for waiting writers held for readers */
79: int readers; /* Count of readers in lock */
80: };
81:
82: struct Talarm
83: {
84: Lock;
85: Proc *list;
86: };
87:
88: struct Alarms
89: {
90: QLock;
91: Proc *head;
92: };
93:
94: #define MAXSYSARG 5 /* for mount(fd, mpt, flag, arg, srv) */
95: struct Sargs
96: {
97: ulong args[MAXSYSARG];
98: };
99:
100: /* Block.flags */
101: #define S_DELIM 0x80
102: #define S_CLASS 0x07
103:
104: /* Block.type */
105: #define M_DATA 0
106: #define M_CTL 1
107: #define M_HANGUP 2
108:
109: struct Block
110: {
111: Block *next;
112: Block *list; /* chain of block lists */
113: uchar *rptr; /* first unconsumed byte */
114: uchar *wptr; /* first empty byte */
115: uchar *lim; /* 1 past the end of the buffer */
116: uchar *base; /* start of the buffer */
117: uchar flags;
118: uchar type;
119: ulong pc; /* pc of caller */
120: };
121:
122: struct Blist
123: {
124: Lock;
125: Block *first; /* first data block */
126: Block *last; /* last data block */
127: long len; /* length of list in bytes */
128: int nb; /* number of blocks in list */
129: };
130:
131: /*
132: * Access types in namec
133: */
134: enum
135: {
136: Aaccess, /* as in access, stat */
137: Atodir, /* as in chdir */
138: Aopen, /* for i/o */
139: Amount, /* to be mounted upon */
140: Acreate, /* file is to be created */
141: };
142:
143: /*
144: * Chan.flags
145: */
146: #define COPEN 1 /* for i/o */
147: #define CMSG 2 /* is the message channel for a mount */
148: #define CCREATE 4 /* permits creation if c->mnt */
149: #define CCEXEC 8 /* close on exec */
150: #define CFREE 16 /* not in use */
151: #define CRCLOSE 32 /* remove on close */
152:
153: struct Chan
154: {
155: Ref;
156: union{
157: Chan *next; /* allocation */
158: ulong offset; /* in file */
159: };
160: ushort type;
161: ulong dev;
162: ushort mode; /* read/write */
163: ushort flag;
164: Qid qid;
165: Mount *mnt; /* mount point that derived Chan */
166: ulong mountid;
167: int fid; /* for devmnt */
168: Stream *stream; /* for stream channels */
169: union {
170: void *aux;
171: Qid pgrpid; /* for #p/notepg */
172: Mnt *mntptr; /* for devmnt */
173: };
174: Chan *mchan; /* channel to mounted server */
175: Qid mqid; /* qid of root of mount point */
176: Session *session;
177: };
178:
179: struct Dev
180: {
181: void (*reset)(void);
182: void (*init)(void);
183: Chan* (*attach)(char*);
184: Chan* (*clone)(Chan*, Chan*);
185: int (*walk)(Chan*, char*);
186: void (*stat)(Chan*, char*);
187: Chan* (*open)(Chan*, int);
188: void (*create)(Chan*, char*, int, ulong);
189: void (*close)(Chan*);
190: long (*read)(Chan*, void*, long, ulong);
191: long (*write)(Chan*, void*, long, ulong);
192: void (*remove)(Chan*);
193: void (*wstat)(Chan*, char*);
194: };
195:
196: struct Dirtab
197: {
198: char name[NAMELEN];
199: Qid qid;
200: long length;
201: long perm;
202: };
203:
204: /*
205: * Ethernet packet buffers.
206: */
207: struct Etherpkt
208: {
209: uchar d[6];
210: uchar s[6];
211: uchar type[2];
212: uchar data[1500];
213: uchar crc[4];
214: };
215:
216: enum
217: {
218: ETHERMINTU = 64, /* minimum transmit size */
219: ETHERMAXTU = 1514, /* maximum transmit size */
220: ETHERHDRSIZE = 14, /* size of an ethernet header */
221: };
222:
223: /* SCSI devices. */
224: enum
225: {
226: ScsiTestunit = 0x00,
227: ScsiExtsens = 0x03,
228: ScsiInquiry = 0x12,
229: ScsiModesense = 0x1a,
230: ScsiStartunit = 0x1B,
231: ScsiStopunit = 0x1B,
232: ScsiGetcap = 0x25,
233: ScsiRead = 0x08,
234: ScsiWrite = 0x0a,
235: ScsiExtread = 0x28,
236: ScsiExtwrite = 0x2a,
237:
238: /* data direction */
239: ScsiIn = 1,
240: ScsiOut = 0,
241: };
242:
243: struct Scsibuf
244: {
245: void* virt;
246: void* phys;
247: Scsibuf* next;
248: };
249:
250: struct Scsidata
251: {
252: uchar* base;
253: uchar* lim;
254: uchar* ptr;
255: };
256:
257: struct Scsi
258: {
259: QLock;
260: int bus;
261: ulong pid;
262: ushort target;
263: ushort lun;
264: ushort rflag;
265: ushort status;
266: Scsidata cmd;
267: Scsidata data;
268: Scsibuf* b;
269: uchar* save;
270: uchar cmdblk[16];
271: };
272:
273: /* character based IO (mouse, keyboard, console screen) */
274: #define NQ 4096
275: struct IOQ
276: {
277: Lock;
278: uchar buf[NQ];
279: uchar *in;
280: uchar *out;
281: int state;
282: Rendez r;
283: union{
284: void (*puts)(IOQ*, void*, int); /* output */
285: int (*putc)(IOQ*, int); /* input */
286: };
287: union{
288: int (*gets)(IOQ*, void*, int); /* input */
289: int (*getc)(IOQ*); /* output */
290: };
291: void *ptr;
292: };
293:
294: struct KIOQ
295: {
296: QLock;
297: IOQ;
298: int repeat;
299: int c;
300: int count;
301: };
302:
303: struct Mount
304: {
305: ulong mountid;
306: Mount *next;
307: Mhead *head;
308: Chan *to; /* channel replacing underlying channel */
309: };
310:
311: struct Mhead
312: {
313: Chan *from; /* channel mounted upon */
314: Mount *mount; /* what's mounted upon it */
315: Mhead *hash; /* Hash chain */
316: };
317:
318: enum
319: {
320: NUser, /* note provided externally */
321: NExit, /* deliver note quietly */
322: NDebug, /* print debug message */
323: };
324:
325: struct Note
326: {
327: char msg[ERRLEN];
328: int flag; /* whether system posted it */
329: };
330:
331: enum
332: {
333: PG_NOFLUSH = 0, /* Fields for cache control of pages */
334: PG_TXTFLUSH = 1,
335: PG_DATFLUSH = 2,
336: PG_MOD = 0x01, /* Simulated modified and referenced bits */
337: PG_REF = 0x02,
338: };
339:
340: struct Page
341: {
342: Lock;
343: ulong pa; /* Physical address in memory */
344: ulong va; /* Virtual address for user */
345: ulong daddr; /* Disc address on swap */
346: ushort ref; /* Reference count */
347: char modref; /* Simulated modify/reference bits */
348: char cachectl[MAXMACH]; /* Cache flushing control for putmmu */
349: Image *image; /* Associated text or swap image */
350: Page *next; /* Lru free list */
351: Page *prev;
352: Page *hash; /* Image hash chains */
353: };
354:
355: struct Swapalloc
356: {
357: Lock; /* Free map lock */
358: int free; /* Number of currently free swap pages */
359: uchar *swmap; /* Base of swap map in memory */
360: uchar *alloc; /* Round robin allocator */
361: uchar *last; /* Speed swap allocation */
362: uchar *top; /* Top of swap map */
363: Rendez r; /* Pager kproc idle sleep */
364: ulong highwater; /* Threshold beyond which we must page */
365: ulong headroom; /* Space pager keeps free under highwater */
366: }swapalloc;
367:
368: struct Image
369: {
370: Ref;
371: Chan *c; /* Channel associated with running image */
372: Qid qid; /* Qid for page cache coherence checks */
373: Qid mqid;
374: Chan *mchan;
375: ushort type; /* Device type of owning channel */
376: Segment *s; /* TEXT segment for image if running */
377: Image *hash; /* Qid hash chains */
378: Image *next; /* Free list */
379: };
380:
381: struct Pte
382: {
383: Page *pages[PTEPERTAB]; /* Page map for this chunk of pte */
384: Page **first; /* First used entry */
385: Page **last; /* Last used entry */
386: Pte *next; /* Free list */
387: };
388:
389: /* Segment types */
390: enum
391: {
392: SG_TYPE = 07, /* Mask type of segment */
393: SG_TEXT = 00,
394: SG_DATA = 01,
395: SG_BSS = 02,
396: SG_STACK = 03,
397: SG_SHARED = 04,
398: SG_PHYSICAL = 05,
399: SG_SHDATA = 06,
400:
401: SG_RONLY = 040, /* Segment is read only */
402: SG_CEXEC = 0100, /* Detach at exec */
403: };
404:
405: #define PG_ONSWAP 1
406: #define onswap(s) (((ulong)s)&PG_ONSWAP)
407: #define pagedout(s) (((ulong)s)==0 || onswap(s))
408: #define swapaddr(s) (((ulong)s)&~PG_ONSWAP)
409:
410: #define SEGMAXSIZE (SEGMAPSIZE*PTEMAPMEM)
411:
412: struct Physseg
413: {
414: ulong attr; /* Segment attributes */
415: char *name; /* Attach name */
416: ulong pa; /* Physical address */
417: ulong size; /* Maximum segment size in pages */
418: Page *(*pgalloc)(Segment*, ulong); /* Allocation if we need it */
419: void (*pgfree)(Page*);
420: };
421:
422: struct Segment
423: {
424: Ref;
425: QLock lk;
426: ushort steal; /* Page stealer lock */
427: Segment *next; /* free list pointers */
428: ushort type; /* segment type */
429: ulong base; /* virtual base */
430: ulong top; /* virtual top */
431: ulong size; /* size in pages */
432: ulong fstart; /* start address in file for demand load */
433: ulong flen; /* length of segment in file */
434: int flushme; /* maintain consistent icache for this segment */
435: Image *image; /* text in file attached to this segment */
436: Physseg *pseg;
437: Pte *map[SEGMAPSIZE]; /* segment pte map */
438: };
439:
440: enum
441: {
442: RENDHASH = 32, /* Hash to lookup rendezvous tags */
443: MNTHASH = 32, /* Hash to walk mount table */
444: NFD = 100, /* Number of per process file descriptors */
445: PGHLOG = 9,
446: PGHSIZE = 1<<PGHLOG, /* Page hash for image lookup */
447: };
448: #define REND(p,s) ((p)->rendhash[(s)%RENDHASH])
449: #define MOUNTH(p,s) ((p)->mnthash[(s)->qid.path%MNTHASH])
450:
451: struct Pgrp
452: {
453: Ref; /* also used as a lock when mounting */
454: Pgrp *next; /* free list */
455: ulong pgrpid;
456: QLock debug; /* single access via devproc.c */
457: RWlock ns; /* Namespace many read/one write lock */
458: Mhead *mnthash[MNTHASH];
459: Proc *rendhash[RENDHASH]; /* Rendezvous tag hash */
460: };
461:
462: struct Egrp
463: {
464: Ref;
465: QLock;
466: Evalue *entries;
467: ulong path;
468: };
469:
470: struct Evalue
471: {
472: char *name;
473: char *value;
474: int len;
475: ulong path;
476: Evalue *link;
477: };
478:
479: struct Fgrp
480: {
481: Ref;
482: Chan *fd[NFD];
483: int maxfd; /* highest fd in use */
484: };
485:
486: struct Palloc
487: {
488: Lock;
489: ulong p0, p1; /* base of pages in bank 0/1 */
490: ulong np0, np1; /* number of pages in bank 0/1 */
491: Page *head; /* most recently used */
492: Page *tail; /* least recently used */
493: ulong freecount; /* how many pages on free list now */
494: ulong user; /* how many user pages */
495: Page *hash[PGHSIZE];
496: Lock hashlock;
497: Rendez r; /* Sleep for free mem */
498: QLock pwait; /* Queue of procs waiting for memory */
499: int wanted; /* Do the wakeup at free */
500: ulong cmembase; /* Key memory protected from read by devproc */
501: ulong cmemtop;
502: };
503:
504: struct Waitq
505: {
506: Waitmsg w;
507: Waitq *next;
508: };
509:
510: enum
511: {
512: RFNAMEG = (1<<0),
513: RFENVG = (1<<1),
514: RFFDG = (1<<2),
515: RFNOTEG = (1<<3),
516: RFPROC = (1<<4),
517: RFMEM = (1<<5),
518: RFNOWAIT = (1<<6),
519: RFCNAMEG = (1<<10),
520: RFCENVG = (1<<11),
521: RFCFDG = (1<<12)
522: };
523:
524: /*
525: * process memory segments - NSEG always last !
526: */
527: enum
528: {
529: SSEG, TSEG, DSEG, BSEG, ESEG, LSEG, SEG1, SEG2, NSEG
530: };
531:
532: enum
533: {
534: Dead = 0, /* Process states */
535: Moribund,
536: Ready,
537: Scheding,
538: Running,
539: Queueing,
540: Wakeme,
541: Broken,
542: Stopped,
543: Rendezvous,
544:
545: Proc_stopme = 1, /* devproc requests */
546: Proc_exitme,
547: Proc_traceme,
548:
549: TUser = 0, /* Proc.time */
550: TSys,
551: TReal,
552: TCUser,
553: TCSys,
554: TCReal,
555:
556: Nrq = 20, /* number of scheduler priority levels */
557: PriNormal = 10, /* base priority for normal processes */
558: PriKproc = 13, /* base priority for kernel processes */
559: PriRoot = 13, /* base priority for root processes */
560: };
561:
562: struct Proc
563: {
564: Label sched;
565: Mach *mach; /* machine running this proc */
566: char text[NAMELEN];
567: char user[NAMELEN];
568: Proc *rnext; /* next process in run queue */
569: Proc *qnext; /* next process on queue for a QLock */
570: QLock *qlock; /* address of qlock being queued for DEBUG */
571: ulong qlockpc; /* pc of last call to qlock */
572: int state;
573: char *psstate; /* What /proc/#/status reports */
574: Page *upage; /* page from palloc */
575: Segment *seg[NSEG];
576: ulong pid;
577: ulong noteid; /* Equivalent of note group */
578:
579: Lock exl; /* Lock count and waitq */
580: Waitq *waitq; /* Exited processes wait children */
581: int nchild; /* Number of living children */
582: int nwait; /* Number of uncollected wait records */
583: QLock qwaitr;
584: Rendez waitr; /* Place to hang out in wait */
585: Proc *parent;
586:
587: Pgrp *pgrp; /* Process group for notes and namespace */
588: Egrp *egrp; /* Environment group */
589: Fgrp *fgrp; /* File descriptor group */
590:
591: ulong parentpid;
592: ulong time[6]; /* User, Sys, Real; child U, S, R */
593: short insyscall;
594: int fpstate;
595:
596: QLock debug; /* to access debugging elements of User */
597: Proc *pdbg; /* the debugging process */
598: ulong procmode; /* proc device file mode */
599: int hang; /* hang at next exec for debug */
600: int procctl; /* Control for /proc debugging */
601: ulong pc; /* DEBUG only */
602:
603: Rendez *r; /* rendezvous point slept on */
604: Rendez sleep; /* place for syssleep/debug */
605: int notepending; /* note issued but not acted on */
606: int kp; /* true if a kernel process */
607: Proc *palarm; /* Next alarm time */
608: ulong alarm; /* Time of call */
609: int hasspin; /* I hold a spin lock */
610: int newtlb; /* Pager has touched my tables so I must flush */
611:
612: ulong rendtag; /* Tag for rendezvous */
613: ulong rendval; /* Value for rendezvous */
614: Proc *rendhash; /* Hash list for tag values */
615:
616: ulong twhen;
617: Rendez *trend;
618: Proc *tlink;
619: int (*tfn)(void*);
620:
621: Mach *mp; /* machine this process last ran on */
622: ulong priority; /* priority level */
623: ulong basepri; /* base priority level */
624: ulong rt; /* # ticks used since last blocked */
625: ulong art; /* avg # ticks used since last blocked */
626: ulong movetime; /* last time process switched processors */
627: ulong readytime; /* time process went ready */
628:
629: /*
630: * machine specific MMU
631: */
632: PMMU;
633: };
634:
635: /*
636: * operations available to a queue
637: */
638: struct Qinfo
639: {
640: Streamput *iput; /* input routine */
641: Streamput *oput; /* output routine */
642: Streamopen *open;
643: Streamclose *close;
644: char *name;
645: Streamreset *reset; /* initialization */
646: char nodelim; /* True if stream does not preserve delimiters */
647: Qinfo *next;
648: };
649:
650: /* Queue.flag */
651: enum
652: {
653: QHUNGUP = 0x1, /* stream has been hung up */
654: QINUSE = 0x2, /* allocation check */
655: QHIWAT = 0x4, /* queue has gone past the high water mark */
656: QDEBUG = 0x8,
657: };
658:
659: struct Queue
660: {
661: Blist;
662: int flag;
663: Qinfo *info; /* line discipline definition */
664: Queue *other; /* opposite direction, same line discipline */
665: Queue *next; /* next queue in the stream */
666: void (*put)(Queue*, Block*);
667: QLock rlock; /* mutex for processes sleeping at r */
668: Rendez r; /* standard place to wait for flow control */
669: Rendez *rp; /* where flow control wakeups go to */
670: void *ptr; /* private info for the queue */
671: };
672:
673: struct Stream
674: {
675: QLock; /* structure lock */
676: Stream *next;
677: short inuse; /* number of processes in stream */
678: short opens; /* number of processes with stream open */
679: ushort hread; /* number of reads after hangup */
680: ushort type; /* correlation with Chan */
681: ushort dev; /* ... */
682: ulong id; /* ... */
683: QLock rdlock; /* read lock */
684: Queue *procq; /* write queue at process end */
685: Queue *devq; /* read queue at device end */
686: Block *err; /* error message from down stream */
687: int flushmsg; /* flush up till the next delimiter */
688: };
689:
690: /*
691: * useful stream macros
692: */
693: #define RD(q) ((q)->other < (q) ? (q->other) : q)
694: #define WR(q) ((q)->other > (q) ? (q->other) : q)
695: #define STREAMTYPE(x) ((x)&0x1f)
696: #define STREAMID(x) (((x)&~CHDIR)>>5)
697: #define STREAMQID(i,t) (((i)<<5)|(t))
698: #define PUTTHIS(q,b) (*(q)->put)((q), b)
699: #define PUTNEXT(q,b) (*(q)->next->put)((q)->next, b)
700: #define BLEN(b) ((b)->wptr - (b)->rptr)
701: #define QFULL(q) ((q)->flag & QHIWAT)
702: #define FLOWCTL(q,b) { if(QFULL(q->next)) flowctl(q,b); else PUTNEXT(q,b);}
703:
704: /*
705: * stream file qid's & high water mark
706: */
707: enum
708: {
709: Shighqid = STREAMQID(1,0) - 1,
710: Sdataqid = Shighqid,
711: Sctlqid = Sdataqid-1,
712: Slowqid = Sctlqid,
713: Streamhi = (32*1024), /* byte count high water mark */
714: Streambhi = 128, /* block count high water mark */
715: };
716:
717: /*
718: * a multiplexed network
719: */
720: struct Netprot
721: {
722: int id;
723: Netprot *next; /* linked list of protections */
724: ulong mode;
725: char owner[NAMELEN];
726: };
727:
728: struct Netinf
729: {
730: char *name;
731: void (*fill)(Chan*, char*, int);
732: };
733:
734: struct Network
735: {
736: Lock;
737: char *name;
738: int nconv; /* max # of conversations */
739: Qinfo *devp; /* device end line disc */
740: Qinfo *protop; /* protocol line disc */
741: int (*listen)(Chan*);
742: int (*clone)(Chan*);
743: int ninfo;
744: Netinf info[5];
745: Netprot *prot; /* linked list of protections */
746: };
747:
748: /*
749: * Parallax for pen pointers
750: */
751: struct Parallax
752: {
753: int xoff;
754: int xnum;
755: int xdenom;
756:
757: int yoff;
758: int ynum;
759: int ydenom;
760: };
761:
762: enum
763: {
764: PRINTSIZE = 256,
765: MAXCRYPT = 127,
766: NUMSIZE = 12, /* size of formatted number */
767: MB = (1024*1024),
768: };
769:
770: extern Conf conf;
771: extern char* conffile;
772: extern int cpuserver;
773: extern Rune* devchar;
774: extern Dev devtab[];
775: extern char eve[];
776: extern char hostdomain[];
777: extern int hwcurs;
778: extern uchar initcode[];
779: extern FPsave initfp;
780: extern KIOQ kbdq;
781: extern IOQ lineq;
782: extern IOQ mouseq;
783: extern Ref noteidalloc;
784: extern int nrdy;
785: extern IOQ printq;
786: extern char* statename[];
787: extern Image swapimage;
788: extern char sysname[NAMELEN];
789: extern Talarm talarm;
790: extern Palloc palloc;
791: extern int cpuserver;
792: extern Physseg physseg[];
793:
794: enum
795: {
796: CHDIR = 0x80000000L,
797: CHAPPEND = 0x40000000L,
798: CHEXCL = 0x20000000L,
799: CHMOUNT = 0x10000000L,
800: };
801:
802: /*
803: * auth messages
804: */
805: enum
806: {
807: FScchal = 1,
808: FSschal,
809: FSok,
810: FSctick,
811: FSstick,
812: FSerr,
813:
814: RXschal = 0,
815: RXstick = 1,
816: };
817:
818: /*
819: * mouse types
820: */
821: enum
822: {
823: Mouseother= 0,
824: Mouseserial= 1,
825: MousePS2= 2,
826: Mousekurta= 3,
827: };
828: extern int mouseshifted;
829: extern int mousetype;
830: extern int mouseswap;
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.