在版本 6 Unix 中取消转储 od（八进制或十六进制转储）

看起来 Unix 版本 6 还没有包含许多只出现在版本 7 中的常用工具（如sed和awk）。那时，Unix 还没有商业化，所以“反向十六进制转储”可能会丢失，这仅仅是因为对该操作没有广泛的需求，或者因为 Ken（或其他一些程序员）从他们/usr在贝尔实验室的非官方目录中提供了这样的工具。谁知道。

但这是我在 Unix V6 上反转十六进制转储的实现。当像 一样编译时cc -s -O unhex.c，生成的可执行文件只有 1160 字节，并且比转储更快（如预期的那样）。

请注意当时的 C 语言如何仍然具有 B ( , 等) 的复合赋值语法，=+以及=*它如何期望程序员为文件 I/O 提供自己的缓冲区。

/* reverse "od -h" operation on Unix V6 */
/* written in pre-K&R C */
/* derived from wc.c and cvopt.c */

int ibuf[259];
int obuf[259];

main(argc,argv)
char **argv;
{
    int token, bytecnt;
    register char *p1, *p2;         /* input buffer pointers */
    register int c;                 /* char or read count */
    char sp, b1, b2, lastc, lastb2, nfirst;

    obuf[0] = 1;                    /* standard output by default */
    if (argc>2) {
                                    /* create output file */
            if ((obuf[0] = creat(argv[2], 0666)) < 0) {
                    diag(argv[2]);
                    diag(": failed to create\n");
                    return;
            }
    }
    if (argc>1 && fopen(argv[1], ibuf)>=0) {
            p1 = 0;
            p2 = 0;
            sp = 0;
            token = 0;
            bytecnt = 0;
            nfirst = 0;
            for(;;) {
                    /* reading from file */
                    if (p1 >= p2) {
                            p1 = &ibuf[1];
                            c = read(ibuf[0], p1, 512);
                            if (c <= 0)
                                    break;
                            p2 = p1+c;
                    }
                    /* decoding loop */
                    c = 0;
                    c =| *p1++;
                    if (c==' ' || c=='\n') {
                            b1 = token;
                            b2 = token >> 8;
                            if (lastc!=' ' && lastc!='\n') {
                                    /* end of token */
                                    if (sp>0) {
                                            if (nfirst) putc(lastb2, obuf);
                                            putc(b1, obuf);
                                            lastb2 = b2;
                                            nfirst = 1;
                                    } else {
                                            /* first token in the line */
                                            bytecnt = token;
                                    }
                            }
                            if (c==' ') sp++;
                            else {
                                    /* new line */
                                    sp = 0;
                                    fflush(obuf);
                            }
                            token = 0;
                    } else {
                            /* actual hex and octal conversion */
                            token =* sp>0 ? 16 : 8;
                            token =+ c<='9' ? c-'0' : c-'W';
                    }
                    lastc = c;
            }
            if (!(bytecnt & 1)) {
                    putc(lastb2, obuf);
                    fflush(obuf);
            }
            close(ibuf[0]);
            close(obuf[0]);
    } else if (argc>1) {
            diag(argv[1]);
            diag(": cannot open\n");
    } else {
            diag("error: filename missing\n");
    }
}

diag(s)
char *s;
{
    while(*s)
            write(2,s++,1);
}

UPD。我在GitHub 上发布了一个更快、更简单的版本，其中还突出显示了语法。

这是一个您可以尝试在 V6 Unix 中编译的最小 C 程序。

#define EOF (-1)
int main(){
  int i,a,b;
  while(scanf("%*7o") != EOF){
    for(i = 0; i<8; i++)
      if(scanf("%2x%2x",&a,&b) != EOF){putchar(a); putchar(b);}
  }
}

如果结果以字节交换结束，您可能需要反转 2 个 putchar。