Return to atari.c CVS log

Up to [MW Coherent from dump] / coherent / g / usr / bin / vi

Annotation of coherent/g/usr/bin/vi/atari.c, revision 1.1

1.1     ! root        1: /* atari.c */
        !             2: 
        !             3: /* Author:
        !             4:  *     Guntram Blohm
        !             5:  *     Buchenstrasse 19
        !             6:  *     7904 Erbach, West Germany
        !             7:  *     Tel. ++49-7305-6997
        !             8:  *     sorry - no regular network connection
        !             9:  */
        !            10: 
        !            11: /*
        !            12:  * This file contains the 'standard' functions which are not supported
        !            13:  * by Atari/Mark Williams, and some other TOS-only requirements.
        !            14:  */
        !            15:  
        !            16: #include "config.h"
        !            17: #include "vi.h"
        !            18: 
        !            19: #if TOS
        !            20: #include <osbind.h>
        !            21: 
        !            22: /* vi uses mode==0 only ... */
        !            23: int access(file, mode)
        !            24:        char *file;
        !            25: {
        !            26:        int fd=Fopen(file, 0);
        !            27:        if (fd<0)
        !            28:                return -1;
        !            29:        Fclose(fd);
        !            30:        return 0;
        !            31: }
        !            32: 
        !            33: char *mktemp(template)
        !            34:        char *template;
        !            35: {
        !            36:        return template;
        !            37: }
        !            38: 
        !            39: #ifndef __GNUC__
        !            40: char *getcwd(buf, size)
        !            41:        char *buf;
        !            42: {
        !            43:        if (size < 2 + 64)
        !            44:                return (char *)0;
        !            45:        buf[0] = Dgetdrv() + 'A';
        !            46:        buf[1] = ':';
        !            47:        Dgetpath(buf + 2, 0);
        !            48:        return buf;
        !            49: }
        !            50: #endif
        !            51: 
        !            52: /* read -- text mode, compress \r\n to \n
        !            53:  * warning: might fail when maxlen==1 and at eol
        !            54:  */
        !            55: 
        !            56: int tread(fd, buf, maxlen)
        !            57:        int fd;
        !            58:        char *buf;
        !            59:        int maxlen;
        !            60: {
        !            61:        int i, j, nread=read(fd, buf, (unsigned)maxlen);
        !            62: 
        !            63:        if (nread && buf[nread-1]=='\r')
        !            64:        {       nread--;
        !            65:                lseek(fd, -1l, 1);
        !            66:        }
        !            67:        for (i=j=0; j<nread; i++,j++)
        !            68:        {       if (buf[j]=='\r' && buf[j+1]=='\n')
        !            69:                        j++;
        !            70:                buf[i]=buf[j];
        !            71:        }
        !            72:        return i;
        !            73: }
        !            74: 
        !            75: int twrite(fd, buf, maxlen)
        !            76:        int fd;
        !            77:        char *buf;
        !            78:        int maxlen;
        !            79: {
        !            80:        int i, j, nwritten=0, hadnl=0;
        !            81:        char writbuf[BLKSIZE];
        !            82: 
        !            83:        for (i=j=0; j<maxlen; )
        !            84:        {
        !            85:                if ((writbuf[i++]=buf[j++])=='\n')
        !            86:                {       writbuf[i-1]='\r';
        !            87:                        if (i<BLKSIZE)
        !            88:                                writbuf[i++]='\n';
        !            89:                        else
        !            90:                                hadnl=1;
        !            91:                }
        !            92:                if (i==BLKSIZE)
        !            93:                {
        !            94:                        write(fd, writbuf, (unsigned)i);
        !            95:                        i=0;
        !            96:                }
        !            97:                if (hadnl)
        !            98:                {
        !            99:                        writbuf[i++]='\n';
        !           100:                        hadnl=0;
        !           101:                }
        !           102:        }
        !           103:        if (i)
        !           104:                write(fd, writbuf, (unsigned)i);
        !           105:        return j;
        !           106: }
        !           107: 
        !           108: 
        !           109: /* The "timer" variable is used as a shadow of the system's timer.  Since the
        !           110:  * system's timer can only be accessed in Supervisor mode, we are forced to
        !           111:  * do a Supexec(gettime) to copy the system's timer in to the User-mode "timer"
        !           112:  * variable.
        !           113:  */
        !           114: static int timer;
        !           115: static gettime()
        !           116: {
        !           117:        timer = *(long *)(0x4ba);
        !           118: }
        !           119: 
        !           120: /* This function implements a read-with-timeout from the keyboard. */
        !           121: /*ARGSUSED*/
        !           122: int ttyread(buf, len, time)
        !           123:        char    *buf;   /* where to store the gotten characters */
        !           124:        int     len;    /* maximum number of characters to get -- ignored */
        !           125:        int     time;   /* maximum time to allow for reading */
        !           126: {
        !           127:        int     pos=0;
        !           128:        long    l;
        !           129:        long    endtime;
        !           130: 
        !           131:        /* compute the ending time, in increments of 1/200th seconds */
        !           132:        Supexec(gettime);
        !           133:        endtime = time * 20 + timer;
        !           134: 
        !           135:        /* wait until time runs out, or we get a keystroke */
        !           136:        while (!pos && (!time || timer < endtime))
        !           137:        {
        !           138:                if (Bconstat(2))
        !           139:                {
        !           140:                        l = Bconin(2);
        !           141:                        buf[pos] = l;
        !           142:                        if (buf[pos++] == '\0')
        !           143:                        {
        !           144:                                buf[pos - 1] = '#';
        !           145:                                buf[pos++] = l >> 16;
        !           146:                        }
        !           147:                }
        !           148:                Supexec(gettime);
        !           149:        }
        !           150:        return pos;
        !           151: }
        !           152: 
        !           153: /* This function writes characters to the screen */
        !           154: ttywrite(buf, len)
        !           155:        char *buf;
        !           156:        int len;
        !           157: {
        !           158:        while (len--)
        !           159:                Bconout(2, *buf++);
        !           160: }
        !           161: #endif

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.