genio.c

地球模拟器

    if (!tp_indx->psize)
#ifdef ARG
    {   fprintf(stderr, "Tierra add_gen() tp_indx corrupted");
        exit(errno);
    }
#else  /* ARG */
        FEError(-407,EXIT,NOWRITE, "Tierra add_gen() tp_indx corrupted");
#endif /* ARG */
#else /* __TURBOC__ */
    for (i = 0; i < head->n; i++)
        if (!(*indx)[i].psize)
#ifdef ARG
        {   fprintf(stderr, "Tierra add_gen() indx array corrupted");
            exit(errno);
        }
#else  /* ARG */
            FEError(-408,EXIT,NOWRITE,
                "Tierra add_gen() indx array corrupted");
#endif /* ARG */
#endif /* __TURBOC__ */
#endif /* ERROR */
#ifdef __TURBOC__
    fseek(fp,((n * sizeof(indx_t)) + sizeof(head_t)), 0);
    fwrite(tp_indx, sizeof(indx_t), 1, fp);
#else /* __TURBOC__ */
    write_indx(fp, head, *indx);
#endif /* __TURBOC__ */

/* 8) We return add or replace. */

    Swap = 1;
    return !ret;
}

I16s GetAscGen(g, ifile)
    Pgl g;
    I8s ifile[];
{
    I8s bit[4], chm[4], buf[81], tbuf[81], *gdat, inst[9];
    I16s t1, format;
    I32s j, k, p, stl;
    I8u ti, dontfgets = 1;
    FILE *inf;

    inf = fopen(ifile, "r");
    if (inf == NULL)
    {
#ifdef ARG
        fprintf(stderr,"Tierra GetAscGen() file %s not opened, exiting", ifile);
        exit(errno);
#else
        FEError(-409,EXIT,WRITE,
            "Tierra GetAscGen() file %s not opened, exiting", ifile);
#endif
    }
    gdat = (I8s *) tcalloc(85, sizeof(I8s));
    g->ploidy = (I8s) 1;   /* default ploidy */
    fgets(gdat, 84, inf);
    while (strlen(gdat) < 3)  /* eat blank lines */
        fgets(gdat, 84, inf);
    while (1)
    {   if (dontfgets)
            dontfgets = 0;
        else
            fgets(gdat, 84, inf);
        if (strlen(gdat) < 3) break;     /* get a blank line and break */
        sscanf(gdat, "%s", buf);
        if (!strcmp(buf, "format:"))
        {   sscanf(gdat, "%*s%hd%*s%lu", &format, &g->bits);
            if (GFormat < 0 ) GFormat = format;
            continue;
        }
        if (!strcmp(buf, "genotype:"))
        {   sscanf(gdat, "%*s%ld%s%*s%*s%ld%s", &g->gen.size,
                g->gen.label, &g->parent.size, g->parent.label);
            continue;
        }
        if (!strcmp(buf, "1st_daughter:"))
        {   sscanf(gdat, "%*s%*s%ld%*s%ld%*s%ld%*s%hd",
                &g->d1.flags, &g->d1.inst, &g->d1.mov_daught, &t1);
            g->d1.BreedTrue = t1;
            continue;
        }
        if (!strcmp(buf, "2nd_daughter:"))
        {   sscanf(gdat, "%*s%*s%ld%*s%ld%*s%ld%*s%hd",
                &g->d2.flags, &g->d2.inst, &g->d2.mov_daught, &t1);
            g->d2.BreedTrue = t1;
            continue;
        }
        if (!strcmp(buf, "InstExe.m:"))
        {   sscanf(gdat, "%*s%ld%%*s%ld%*s%ld",
                &g->originI.m, &g->originI.i, &g->originC);
            continue;
        }
        if (!strcmp(buf, "MaxPropPop:"))
        {   if(format < 2)
                sscanf(gdat, "%*s%f%*s%f", &g->MaxPropPop, &g->MaxPropInst);
            else
               sscanf(gdat, "%*s%f%*s%f%*s%ld,%ld", 
                   &g->MaxPropPop, &g->MaxPropInst,
                   &g->mpp_time.m, &g->mpp_time.i);
            continue;
        }
        if (!strcmp(buf, "Origin:"))
        {   sscanf(gdat, "%*s%ld,%ld%*s%ld",
                &g->originI.m, &g->originI.i, &g->originC);
            continue;
        }
        if (!strcmp(buf, "ploidy:"))
        {   sscanf(gdat, "%*s%ld%*s%ld", &j, &k);
            g->ploidy = (I8s) j;
            g->track = (I8s) k;
            continue;
        }
        if (!strcmp(buf, "comments:"))
        {   do
            {   fgets(gdat, 84, inf);
                sscanf(gdat ,"%s", tbuf);
            }   while (strlen(gdat) > 2 && tbuf[strlen(tbuf) - 1] != ':');
            dontfgets = 1;
        }
    }
    g->genome = (FpInst) tcalloc(g->gen.size, sizeof(Instruction));
    g->gbits = (FpGenB) tcalloc(g->gen.size, sizeof(GenBits));
#if PLOIDY == 1
    fgets(gdat, 84, inf);
    fgets(gdat, 84, inf);
    for (j = 0; j < g->gen.size; j++)
    {   fgets(gdat, 84, inf);
        stl = sscanf(gdat, "%s%*s%s%s", inst, chm, bit);
        if (stl > 1 && strlen(chm) == 3)
        {   g->genome[j].read = chm[2] - '0';
            g->genome[j].write = chm[1] - '0';
            g->genome[j].exec = chm[0] - '0';
        }
        if (stl > 2 && strlen(bit) == 3)
        {   if (bit[0] - '0') g->gbits[j] |= (I8s) 1;
            if (bit[1] - '0') g->gbits[j] |= (I8s) (1 << 1);
            if (bit[2] - '0') g->gbits[j] |= (I8s) (1 << 2);
        }
        for (k = 0; k < INSTNUM; k++)
        {   if (!strcmp(inst, id[k].mn))
            {   ti = id[k].op;
                break;
            }
        }
        if (k == INSTNUM)
        {
#ifdef ARG
           fprintf(stderr,
               "Tierra GetAscGen() mnemonic %s not recognized\n", inst);
#else
            FEError(-410,NOEXIT,WRITE,
               "Tierra GetAscGen() mnemonic %s not recognized\n", inst);
#endif
            ti = 0;
        }
        g->genome[j].inst = ti;
    }
#else /* PLOIDY > 1 */
    for (p = 0; p < PLOIDY; p++)
    {   if (p) fgets(gdat, 84, inf);
        fgets(gdat, 84, inf);
        fgets(gdat, 84, inf);
        for (j = 0; j < g->gen.size; j++)
        {   fgets(gdat, 84, inf);
            stl = sscanf(gdat, "%s%*s%s%s", inst, chm, bit);
            if (stl > 1 && strlen(chm) == 3)
            {   g->genome[j][p].read = chm[2] - '0';
                g->genome[j][p].write = chm[1] - '0';
                g->genome[j][p].exec = chm[0] - '0';
            }
            if (stl > 2 && strlen(bit) == 3)
            {   if (bit[0] - '0') g->gbits[j][p] |= (I8s) 1;
                if (bit[1] - '0') g->gbits[j][p] |= (I8s) (1 << 1);
                if (bit[2] - '0') g->gbits[j][p] |= (I8s) (1 << 2);
            }
            for (k = 0; k < INSTNUM; k++)
            {   if (!strcmp(inst, id[k].mn))
                {   ti = id[k].op;
                    break;
                }
            }
            if (k == INSTNUM)
            {
#ifdef ARG
                fprintf(stderr,
                    "Tierra GetAscGen() mnemonic %s not recognized\n", inst);
#else
                FEError(-411,NOEXIT,WRITE,
                    "Tierra GetAscGen() mnemonic %s not recognized\n", inst);
#endif
                ti = 0;
            }
            g->genome[j][p].inst = ti;
        }
    }
#endif /* PLOIDY >  1 */
    fclose(inf);
    g->hash = Hash(g->gen.size, g->genome);
#ifdef IBM3090
    Ebcdic2Ascii(g->gen.label);
    Ebcdic2Ascii(g->parent.label);
#endif
    if (gdat)
    {   tfree(gdat);
        gdat = NULL;
    }
    return 1;
}

I8s WritAscFile(g, file)
    Pgl g;
    I8s *file;
{
    I8s bit[4], chm[4];
    I16s t1;
    I16u di, t, j;
    I8s format = GFormat;
    long int tp;
    FILE *fp;

#ifdef IBM3090
    I8s lbl[4], plbl[4], *comnts;

#endif
    if (format < 0) format = INST;
    if (!strcmp(file, "-"))
        fp = stdout;
    else if (!(fp = fopen(file, "w"))) {
#ifdef ARG
        fprintf(stderr,
            "Tierra WritAscFile() unable to open WritAscFile file %s",file);
        exit(errno);
#else
        FEError(-412,EXIT,NOWRITE,
            "Tierra WritAscFile() unable to open WritAscFile file %s",file);
#endif
    }
    WritEcoB(g->bits, mes[9]);
    fprintf(fp, "\nformat: %hd  bits: %lu  %s\n", format, g->bits,mes[9]);
#ifdef IBM3090
    strcpy(lbl, g->gen.label);
    strcpy(plbl, g->parent.label);
    Ascii2Ebcdic(lbl);
    Ascii2Ebcdic(plbl);
    fprintf(fp, "genotype: %04ld%s  parent genotype: %04ld%s\n",
            g->gen.size, lbl, g->parent.size, plbl);
#else
    fprintf(fp, "genotype: %04ld%s  parent genotype: %04ld%s\n",
            g->gen.size, g->gen.label, g->parent.size, g->parent.label);
#endif
    t1 = g->d1.BreedTrue;
    fprintf(fp, "1st_daughter:  flags: %ld  inst: %ld  mov_daught: %ld  \
        breed_true: %hd\n", g->d1.flags, g->d1.inst, g->d1.mov_daught, t1);
    t1 = g->d2.BreedTrue;
    fprintf(fp, "2nd_daughter:  flags: %ld  inst: %ld  mov_daught: %ld  \
        breed_true: %hd\n", g->d2.flags, g->d2.inst, g->d2.mov_daught, t1);
    tp = g->originC;
    if(format < 2)
       {
       fprintf(fp, "InstExe.m: %ld InstExe.i: %ld  origin: %ld  %s",
            g->originI.m, g->originI.i, g->originC, ctime(&tp));
       fprintf(fp, 
       "MaxPropPop: %g  MaxPropInst: %g \n", g->MaxPropPop, g->MaxPropInst);
       }
    else
       {
       fprintf(fp, "Origin: InstExe: %ld,%ld  clock: %ld  %s",
            g->originI.m, g->originI.i, g->originC, ctime(&tp));
       fprintf(fp, 
       "MaxPropPop: %g  MaxPropInst: %g mpp_time: %ld,%ld \n", 
            g->MaxPropPop, g->MaxPropInst,g->mpp_time.m,g->mpp_time.i);
        }
    fprintf(fp, "ploidy: %ld  track: %ld\n", (I32s) g->ploidy,
            (I32s) g->track);
    fprintf(fp, "\n");
    chm[3] = bit[3] = 0;

#if PLOIDY == 1
        fprintf(fp, "track 0: prot\n          xwr\n" );
        for (t = 0; t < g->gen.size; t++) {
            di = g->genome[t].inst;
            bit[0] = IsBit(g->gbits[t], 0) ? '1' : '0';
            bit[1] = IsBit(g->gbits[t], 1) ? '1' : '0';
            bit[2] = IsBit(g->gbits[t], 2) ? '1' : '0';
            chm[0] = '0' + g->genome[t].exec;
            chm[1] = '0' + g->genome[t].write;
            chm[2] = '0' + g->genome[t].read;
            fprintf(fp, "%-8s; %s %s %02x %3u\n", id[di].mn, chm, 
                    bit, di, t);
        }
#else /* PLOIDY > 1 */
    for (j = 0; j < PLOIDY; j++) {
        if (j)
            fprintf(fp, "\n");
        fprintf(fp, "track %ld: prot\n          xwr\n", j);
        for (t = 0; t < g->gen.size; t++) {
            di = g->genome[t][j].inst;
            bit[0] = IsBit(g->gbits[t][j], 0) ? '1' : '0';
            bit[1] = IsBit(g->gbits[t][j], 1) ? '1' : '0';
            bit[2] = IsBit(g->gbits[t][j], 2) ? '1' : '0';
            chm[0] = '0' + g->genome[t][j].exec;
            chm[1] = '0' + g->genome[t][j].write;
            chm[2] = '0' + g->genome[t][j].read;
            fprintf(fp, "%-8s; %s %s %02x %3u\n", id[di].mn, chm, 
                    bit, di, t);
        }
    }
#endif /* PLOIDY > 1 */
if (fp!= stdout) {fflush(fp);fclose(fp);}
}

#ifdef IBM3090
static unsigned char a2e[] = {
    0000, 0001, 0002, 0003, 0067, 0055, 0056, 0057, 0026, 0005, 0045, 0013, 0014, 0015, 0016,
    0017, 0020, 0021, 0022, 0023, 0074, 0075, 0062, 0046, 0030, 0031, 0077, 0047, 0034, 0035,
    0036, 0037, 0100, 0117, 0177, 0173, 0133, 0154, 0120, 0175, 0115, 0135, 0134, 0116, 0153,
    0140, 0113, 0141, 0360, 0361, 0362, 0363, 0364, 0365, 0366, 0367, 0370, 0371, 0172, 0136,
    0114, 0176, 0156, 0157, 0174, 0301, 0302, 0303, 0304, 0305, 0306, 0307, 0310, 0311, 0321,
    0322, 0323, 0324, 0325, 0326, 0327, 0330, 0331, 0342, 0343, 0344, 0345, 0346, 0347, 0350,
    0351, 0112, 0340, 0132, 0137, 0155, 0171, 0201, 0202, 0203, 0204, 0205, 0206, 0207, 0210,
    0211, 0221, 0222, 0223, 0224, 0225, 0226, 0227, 0230, 0231, 0242, 0243, 0244, 0245, 0246,
    0247, 0250, 0251, 0300, 0152, 0320, 0241, 0007, 0040, 0041, 0042, 0043, 0044, 0025, 0006,
    0027, 0050, 0051, 0052, 0053, 0054, 0011, 0012, 0033, 0060, 0061, 0032, 0063, 0064, 0065,
    0066, 0010, 0070, 0071, 0072, 0073, 0004, 0024, 0076, 0341, 0101, 0102, 0103, 0104, 0105,
    0106, 0107, 0110, 0111, 0121, 0122, 0123, 0124, 0125, 0126, 0127, 0130, 0131, 0142, 0143,
    0144, 0145, 0146, 0147, 0150, 0151, 0160, 0161, 0162, 0163, 0164, 0165, 0166, 0167, 0170,
    0200, 0212, 0213, 0214, 0215, 0216, 0217, 0220, 0232, 0233, 0234, 0235, 0236, 0237, 0240,
    0252, 0253, 0254, 0255, 0256, 0257, 0260, 0261, 0262, 0263, 0264, 0265, 0266, 0267, 0270,
    0271, 0272, 0273, 0274, 0275, 0276, 0277, 0312, 0313, 0314, 0315, 0316, 0317, 0332, 0333,
    0334, 0335, 0336, 0337, 0352, 0353, 0354, 0355, 0356, 0357, 0372, 0373, 0374, 0375, 0376,
0377};

static unsigned char e2a[] = {
    0000, 0001, 0002, 0003, 0234, 0011, 0206, 0177, 0227, 0215, 0216, 0013, 0014, 0015, 0016,
    0017, 0020, 0021, 0022, 0023, 0235, 0205, 0010, 0207, 0030, 0031, 0222, 0217, 0034, 0035,
    0036, 0037, 0200, 0201, 0202, 0203, 0204, 0012, 0027, 0033, 0210, 0211, 0212, 0213, 0214,
    0005, 0006, 0007, 0220, 0221, 0026, 0223, 0224, 0225, 0226, 0004, 0230, 0231, 0232, 0233,
    0024, 0025, 0236, 0032, 0040, 0240, 0241, 0242, 0243, 0244, 0245, 0246, 0247, 0250, 0133,
    0056, 0074, 0050, 0053, 0041, 0046, 0251, 0252, 0253, 0254, 0255, 0256, 0257, 0260, 0261,
    0135, 0044, 0052, 0051, 0073, 0136, 0055, 0057, 0262, 0263, 0264, 0265, 0266, 0267, 0270,
    0271, 0174, 0054, 0045, 0137, 0076, 0077, 0272, 0273, 0274, 0275, 0276, 0277, 0300, 0301,
    0302, 0140, 0072, 0043, 0100, 0047, 0075, 0042, 0303, 0141, 0142, 0143, 0144, 0145, 0146,
    0147, 0150, 0151, 0304, 0305, 0306, 0307, 0310, 0311, 0312, 0152, 0153, 0154, 0155, 0156,
    0157, 0160, 0161, 0162, 0313, 0314, 0315, 0316, 0317, 0320, 0321, 0176, 0163, 0164, 0165,
    0166, 0167, 0170, 0171, 0172, 0322, 0323, 0324, 0325, 0326, 0327, 0330, 0331, 0332, 0333,
    0334, 0335, 0336, 0337, 0340, 0341, 0342, 0343, 0344, 0345, 0346, 0347, 0173, 0101, 0102,
    0103, 0104, 0105, 0106, 0107, 0110, 0111, 0350, 0351, 0352, 0353, 0354, 0355, 0175, 0112,
    0113, 0114, 0115, 0116, 0117, 0120, 0121, 0122, 0356, 0357, 0360, 0361, 0362, 0363, 0134,
    0237, 0123, 0124, 0125, 0126, 0127, 0130, 0131, 0132, 0364, 0365, 0366, 0367, 0370, 0371,
    0060, 0061, 0062, 0063, 0064, 0065, 0066, 0067, 0070, 0071, 0372, 0373, 0374, 0375, 0376,
0377};

Ascii2Ebcdic(s)
    char *s;
{
    while (*s = a2e[*s])
        s++;
}

Ebcdic2Ascii(s)
    char *s;
{
    while (*s = e2a[*s])
        s++;
}

#endif

void WritEcoB(bits, buf)
    I32u bits;
    I8s *buf;        /* changed by DAN */
{
    int i, j;
    
    if(!buf) return;
    sprintf(buf,"EX      TC      TP      MF      MT      MB      ");
    for (i = 0, j = 0; i < 6; i++, j = 0) {
        if (IsBit(bits, 5 * i + 2))
            buf[2+(i*8)+j++] = 's';
        if (IsBit(bits, 5 * i + 3))
            buf[2+(i*8)+j++] = 'd';
        if (IsBit(bits, 5 * i + 4))
            buf[2+(i*8)+j++] = 'o';
        if (IsBit(bits, 5 * i + 5))
            buf[2+(i*8)+j++] = 'f';
        if (IsBit(bits, 5 * i + 6))
            buf[2+(i*8)+j++] = 'h';
    }
}

void SetBit(seed, bit, value)
    I32u *seed, bit, value;
{
    if (value)
        (*seed) |= (ONE << bit);
    else
        (*seed) &= (~(ONE << bit));
}

I16s id_compare(i,j)
InstDef   *i,*j;
{   return(i->op - j->op);
}

void GetAMap(file)
    I8s file[85];
{   FILE  *afp;
    char  data[85];
    I32s  i, opc;

    if((afp = fopen(file,"r")) == NULL)
    {   fprintf(stderr,"unable to open IMapFile  - %s", file);
        exit(-666);
    }
    fgets(data, 84, afp);
    i = opc = 0;
    while (strlen(data) > 3)
    {   if (((sscanf(data,"%*[^x]x%lx%*[^\"]\"%[^\"]", &opc, id[i].mn))
            >= 2) && ((opc >= 0) && (opc < INSTNUM )))
        {   id[i].op = opc;
            if (!strcmp(id[i].mn, "nop0"))
            {   Nop0 = id[i].op;
                NopS = Nop0 + Nop1;
            }
            if (!strcmp(id[i].mn, "nop1"))
            {   Nop1 = id[i].op;
                NopS = Nop0 + Nop1;
            }
            i++;
        }
        if (fgets(data, 84, afp) == NULL)
            break ;
    }
    fclose(afp);
    qsort(id,INSTNUM, sizeof(InstDef), id_compare);
}

I32s Hash(size, v)
    I32s    size;
    FpInst  v;
{   I32s  h = 0;
    I32s  i, j;

    for (i = 0; i < size; i++) 
#if PLOIDY == 1
        h = (3 * h + (v + i)->inst) % 277218551L; /* 277218551 is prime */
#else /* PLOIDY > 1 */
        for (j = 0; j < PLOIDY; j++)
            h = (3 * h + (v + i)[j]->inst) % 277218551L;
#endif /* PLOIDY > 1 */
    return h;
}