Return to picopen_w.c CVS log

Up to [Research Unix] / researchv10no / libpicfile

Annotation of researchv10no/libpicfile/picopen_w.c, revision 1.1.1.1

1.1       root        1: #include <picfile.h>
                      2: #include <stdio.h>
                      3: #include <libc.h>
                      4: #define        NPROP   1024
                      5: PRD_error(f, buf)
                      6: PICFILE *f;
                      7: char *buf;
                      8: {
                      9:        return 0;
                     10: }
                     11: extern char cmdline[513];      /* from getflags */
                     12: PICFILE *picopen_w(file, type, x, y, w, h, chan, argv, cmap)
                     13: char *file, *type, *chan, *argv[], *cmap;
                     14: {
                     15:        int i;
                     16:        char prop[NPROP];
                     17:        PICFILE *p=(PICFILE *)malloc(sizeof(PICFILE));
                     18:        if(p==0) return 0;
                     19:        p->flags=PIC_NOCLOSE;
                     20:        p->argc=-1;
                     21:        p->cmap=0;
                     22:        if(strcmp(file, "OUT")==0)
                     23:                p->fd=1;
                     24:        else{
                     25:                p->fd=creat(file, 0666);
                     26:                if(p->fd<0){
                     27:                Error:
                     28:                        if(!(p->flags&PIC_NOCLOSE)) close(p->fd);
                     29:                        if(p->argc>=0){
                     30:                                for(i=0;i!=p->argc;i++) free(p->argv[i]);
                     31:                                free((char *)p->argv);
                     32:                        }
                     33:                        if(p->cmap) free(p->cmap);
                     34:                        free((char *)p);
                     35:                        return 0;
                     36:                }
                     37:                p->flags=0;
                     38:        }       
                     39:        p->argc=0;
                     40:        p->argv=(char **)malloc(sizeof(char *));
                     41:        p->argv[0]=0;
                     42:        for(i=0;PIC_conf[i].type;i++)
                     43:                if(strcmp(type, PIC_conf[i].type)==0) break;
                     44:        if(!PIC_conf[i].type){
                     45:                PIC_error="Illegal TYPE";
                     46:                goto Error;
                     47:        }
                     48:        p->rd=PRD_error;
                     49:        p->wr=PIC_conf[i].wr;
                     50:        p->cl=PIC_conf[i].cl;
                     51:        p->line=0;
                     52:        p->buf=0;
                     53:        picputprop(p, "TYPE", type);
                     54:        p->type=picgetprop(p, "TYPE");
                     55:        sprintf(prop, "%d %d %d %d", x, y, x+w, y+h);
                     56:        picputprop(p, "WINDOW", prop);
                     57:        p->x=x;
                     58:        p->y=y;
                     59:        p->width=w;
                     60:        p->height=h;
                     61:        p->nchan=strlen(chan);
                     62:        if(PIC_conf[i].nchan!=0 && PIC_conf[i].nchan!=p->nchan){
                     63:                PIC_error="wrong NCHAN for this TYPE";
                     64:                goto Error;
                     65:        }
                     66:        sprintf(prop, "%d", p->nchan);
                     67:        picputprop(p, "NCHAN", prop);
                     68:        picputprop(p, "CHAN", chan);
                     69:        p->chan=picgetprop(p, "CHAN");
                     70:        if(PIC_command) picputprop(p, "COMMAND", PIC_command);
                     71:        if(cmdline[0])
                     72:                strcpy(prop, cmdline);
                     73:        else if(argv){
                     74:                prop[0]='\0';
                     75:                for(i=0;argv[i];i++){
                     76:                        if(i!=0) strcat(prop, " ");
                     77:                        strcat(prop, argv[i]);
                     78:                }
                     79:        }
                     80:        else
                     81:                sprintf(prop, "magically-create %s", file);
                     82:        picputprop(p, "COMMAND", prop);
                     83:        if(cmap){
                     84:                p->cmap=malloc(3*256);
                     85:                if(p->cmap==0){
                     86:                        PIC_error="No memory for colormap";
                     87:                        goto Error;
                     88:                }
                     89:                memcpy(p->cmap, cmap, 3*256);
                     90:                picputprop(p, "CMAP", "");
                     91:        }
                     92:        else
                     93:                p->cmap=0;
                     94:        return p;
                     95: }
                     96: PWR_header(p)
                     97: PICFILE *p;
                     98: {
                     99:        register char **ap, *vp, *ep;
                    100:        int nlen;
                    101:        for(ap=p->argv;*ap;ap++){
                    102:                vp=strchr(*ap, '=')+1;
                    103:                nlen=vp-*ap;
                    104:                for(;;){
                    105:                        write(p->fd, *ap, nlen);
                    106:                        ep=strchr(vp, '\n');
                    107:                        if(ep){
                    108:                                write(p->fd, vp, ep+1-vp);
                    109:                                vp=ep+1;
                    110:                        }
                    111:                        else{
                    112:                                write(p->fd, vp, strlen(vp));
                    113:                                write(p->fd, "\n", 1);
                    114:                                break;
                    115:                        }
                    116:                }
                    117:        }
                    118:        write(p->fd, "\n", 1);
                    119:        if(p->cmap)
                    120:                write(p->fd, p->cmap, 3*256);
                    121: }

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