CP/M/CPM_CDROM.iso/cpm/utils/txtutl/unix2cpm.lbr/UNIX2CPM.CZ/UNIX2CPM.C

C/C++ Source or Header | 1988-04-18 | 5.0 KB | 211 lines

/*
 * UNIX2CPM  Converts Unix-format EOL's to CP/M ones (LF=>CRLF).
 *
 *         Optimized for ease of use, ease of writing, and for
 *         fast speed operation under CP/M.  This is for Z80s ONLY.
 *
 * Version 1.2
 *
 * Change from 1.1->1.2:
 *             Files processed now stay on the "other disk" for
 *             situations like "A> unix2cpm c:fred.c"
 *
 *             Improved malloc scheme for use on systems with
 *             teeny tiney TPA memory.
 *
 *                Original (and modifying) author:
 *
 *                -Mike Kersenbrock
 *                  tektronix!copper!michaelk
 *
 */


#include "c:stdio.h"    /* Kept in my 720K RAMDISK "C:"    */
#include "c:fcntl.h"

int Input;        /* File desciptor for input files  */
int Tempfile;        /* File desciptor for output files */

char *Tbuf;        /* Pointer to Input buffer         */
int Count;        /* Number of bytes in input buffer */
int Tbufsize;        /* Size of that buffer             */

char *Obuf;        /* Pointer to Output buffer        */
int Obufsize;        /* Size of that buffer             */

char *xlate();        /* making everybody happy          */
int  look4eof();    /* just keeping in habit       */

char Tempname[] = "z:temp@@83.$$$";

main(argc,argv)
int argc;
char *argv[];
{

    register int loop;
    register char *temp;
    register char *tmpname;

    puts("\nUNIX2CPM     Version 1.2 (M. Kersenbrock)");

    if (argc < 2 ) {
        puts("Usage: unix2cpm  filename [filename...]  afn's OK");
        exit(3);
    }

    /*
     * This way the output buffer is twice the size of the
     * input buffer. So, in a near worse case inputfile of almost pure LFs,
     * the output buffer will still just hold it all w/o having to check.
     */
    for (Obufsize=0x7000 ; (1) ; Obufsize /= 2) {
        if ((Obuf=malloc(Obufsize))!=NULL) {
            Tbufsize=Obufsize/2;
            if ((Tbuf=malloc(Tbufsize))!=NULL) {
                break;
            }
            else {
                free(Obuf);
            }
        }
    }

    for (loop = 1 ; loop < argc ; loop++) {
        if ((Input=open(argv[loop],O_RDONLY)) < 0) {
            fputs("\nproblem opening file: ",stdout);
                  puts(argv[loop]);
            puts("\n");
            exit(1);
        }
        chekkbd();
        if (*(argv[loop] + 1) == ':') {
            Tempname[0] = *argv[loop];
            tmpname = Tempname;
        }
        else {
            tmpname = &Tempname[2];
        }
        fputs("\nStarting to process file: ",stdout);
        fputs(argv[loop],stdout);
        Tempfile = open(tmpname,O_WRONLY+O_CREAT);
        if (Tempfile < 0) {
            puts("\nproblem opening temp file ");
            puts(tmpname);
            puts("\n");
            exit(2);
        }
        chekkbd();

        while ((Count=read(Input,Tbuf,Tbufsize)) > 0) {

            /*
             * Observe the CTL-Z that may be in the
             * input buffer.
             */
            Count = look4eof(Tbuf,Count);

            /*
                 * Xlate translates Count chars of data from Tbuf to
             * Obuf, returning a pointer one past end of data in
             * the Obuf.
             */
            temp=xlate();
            chekkbd();
            write(Tempfile,Obuf,temp-Obuf);
        }
        *Obuf = '\032';
        write(Tempfile,Obuf,1);
        close(Tempfile);
        unlink(argv[loop]);
        close(Input);
        rename(tmpname,argv[loop]);
    }
    puts("\n");
    exit(0);
}

#define LBCD db 0edh,4bh    /*LD BC,(nn)  where nn follows */
#define LDI  db 0edh,0a0h     /*LDI incremental block move Z80 instruction */

#asm

xlate_:
    push b        ; Save register variable
    mvi a,0ah    ; Lookn for linefeeds
    LBCD
    dw Count_    ; Load count into BC
    lhld Obuf_    ; Get destination buffer address
    xchg        ; and put it into DE
    lhld Tbuf_    ; Put Source address into HL

look4:
    cmp m        ; linefeed?
    jnz noinsert    ; nope
    xchg        ; yup
    mvi m,0dh
    xchg        ; put CR into destination string
    inx d        ; then update dest. pointer
            ; and drop down to transfer the LF
noinsert:
    LDI        ;  so do straight copy transfer
    jpe look4    ; if Count not done, go do another

    xchg        ; put destination pointer into HL
    pop b        ; put register variable back
    mov a,h
    ora l        ; set flags to HLs contents
    ret
#endasm



/*
 * Search a buffer of length maxcount, and return the number
 * of characters *before* finding CP/M's EOF.  If EOF is not found
 * then maxcount is returned.  Uses Z80 Block-search instruction.
 *
 * This is for a Z80 only.        -Mike Kersenbrock
 *                         tektronix!copper!michaelk
 * look4eof(buffer,maxcount)
 * char *buffer;
 * int maxcount;
 *
 */

#asm

look4eof_:
    lxi h,2
    dad sp
    mov e,m
    inx h
    mov d,m            ; buffer pointer is now in DE
    push b            ; Save incoming register variable
    inx h
    mov c,m
    inx h
    mov b,m            ; maxcount is now in BC
    xchg            ; buffer pointer is now in HL
    mov e,c
    mov d,b            ; (save original count in DE)
    mvi a,1ah        ; EOF in accumulator
    db 0edh,0b1h        ; Z80 Block-compare look for EOF (CPIR)
    xchg            ; put original count into HL
    jnz nofound        ; nope, hadnt found EOF
                ; else,...

    stc            ; set carry flag
    db 0edh,042h        ; subtract current count(BC) from orig count-1
                ; (leave new actual count in HL (rtn value))
nofound:            ; The calling count is still in HL
    mov a,h
    ora l            ; set zero flag to HLs contents
    pop b            ; return register variable back again
    ret

#endasm
 * then maxcount is returned.  Uses Z80 Block-search instruction.
 *
 * This is for a Z80 only.        -