instruct.c

地球模拟器

            && (!soup[*f][ce->d.tr].read || IsInsideCell(ce,*f))
#endif /* READPROT */
            )
            || (db &&  /* backward */
            (soup[*b][ce->d.tr].inst == Nop0 || soup[*b][ce->d.tr].inst==Nop1)
#ifdef READPROT
            && (!soup[*b][ce->d.tr].read || IsInsideCell(ce,*b))
#endif /* READPROT */
            ))
#endif /* PLOIDY > 1 */
            break;
        if (df)
        {   (*f)++;
            *f = ad(*f);
        }
        if (db)
        {   (*b)--;
            *b = ad(*b);
        }
        l++;
        if (l > *slim)   /* if we exceed the search limit abort */
        {   adrt = -1;
            *mode = 0;
            goto finish;
        }
    }

    /* forward */
#if PLOIDY == 1
    if (df && (soup[*f].inst == Nop0    /* if NOPs */
           ||  soup[*f].inst == Nop1))
#else /* PLOIDY > 1 */
    if (df && (soup[*f][ce->d.tr].inst == Nop0    /* if NOPs */
           ||  soup[*f][ce->d.tr].inst == Nop1))
#endif /* PLOIDY > 1 */
    {   fmatch = 1;
        for (i = 0; i < tz; i++)   /* over the full template size */
        {   
#if PLOIDY == 1
            if (soup[ad(o + i)].inst +
                soup[ad(*f + i)].inst - NopS
#ifdef READPROT
                || (soup[ad(*f + i)].read
                && !IsInsideCell(ce,ad(*f + i)))
#endif /* READPROT */
#else /* PLOIDY > 1 */
            if (soup[ad(o + i)][ce->d.tr].inst +
                soup[ad(*f + i)][ce->d.tr].inst - NopS
#ifdef READPROT
                || (soup[ad(*f + i)][ce->d.tr].read
                && !IsInsideCell(ce,ad(*f + i)))
#endif /* READPROT */
#endif /* PLOIDY > 1 */
                )
            {   fmatch = 0;
                break;
            }
        }
    }
    else fmatch = 0;

    /* backward */
#if PLOIDY == 1
    if (db && (soup[*b].inst == Nop0    /* if NOPs */
           ||  soup[*b].inst == Nop1))
#else /* PLOIDY > 1 */
    if (db && (soup[*b][ce->d.tr].inst == Nop0    /* if NOPs */
           ||  soup[*b][ce->d.tr].inst == Nop1))
#endif /* PLOIDY > 1 */
    {   bmatch = 1;
        for (i = 0; i < tz; i++)  /* over the full template size */
        {
#if PLOIDY == 1
            if (soup[ad(o + i)].inst +
                soup[ad(*b + i)].inst - NopS
#ifdef READPROT
                || (soup[ad(*b + i)].read
                && !IsInsideCell(ce,ad(*b + i)))
#endif /* READPROT */
#else /* PLOIDY > 1 */
            if (soup[ad(o + i)][ce->d.tr].inst +
                soup[ad(*b + i)][ce->d.tr].inst - NopS
#ifdef READPROT
                || (soup[ad(*b + i)][ce->d.tr].read
                && !IsInsideCell(ce,ad(*b + i)))
#endif /* READPROT */
#endif /* PLOIDY > 1 */
                )
            {   bmatch = 0;
                break;
            }
        }
    }
    else bmatch = 0;

    if (fmatch && bmatch)
    {   if (*mode == 1)
        {   *f += flaw(ce);
            adrt = ad(*f + tz);
            *mode = 3;
            goto finish;
        }
        else if (*mode == 2)
        {   *b += flaw(ce);
            adrt = ad(*b + tz);
            *mode = 3;
            goto finish;
        }
    }
    else if (fmatch)
    {   *f += flaw(ce);
        adrt = ad(*f + tz);
        *mode = 1;
        goto finish;
    }
    else if (bmatch)
    {   *b += flaw(ce);
        adrt = ad(*b + tz);
        *mode = 2;
        goto finish;
    }

    if (db)      /* increment search pointers, backward and forward */
    {   (*b)--;
        *b = ad(*b);
    }
    if (df)
    {   (*f)++;
        *f = ad(*f);
    }
    l++;
    if (l > *slim)   /* if we exceed the search limit abort */
    {   adrt = -1;
        *mode = 0;
        goto finish;
    }
    }  /* outermost while(1) */
finish:
    *slim = l;
    if (1 && WatchTem)
    tgl = sl[ce->d.gen.size]->g[ce->d.gi];
    if (1 && WatchTem && adrt >= 0 && !ce->d.flaw && !ce->d.mut &&
        ce->mm.p <= ce->c.ip && ce->c.ip < (ce->mm.p + ce->mm.s) &&
        IsBit(tgl->bits, 0))
    GenExTemp(ad(adrt - tz), ce, tz);
    return adrt;  /* address of instruction following target template */
}

#ifdef FUTURE

I32s template(f, b, slim, tz, dir, mode, ce)
 /* search in specified direction for */
 /* nop template return address, returns address of instruction following */
 /* target template, i.e., target + tz */
 /* NOTE: ce->c.ip must point to the instruction (agent) being executed */
    I32s f;    /* starting address for forward search */
    I32s b;    /* starting address for backward search */
    I32s *slim;
    I32s tz;  /* template size */
    I32s dir;  /* direction of search, f = forward, b = backward, o = out */
    I8s mode; /* match mode: 0 = complement, 1 = direct */
    Pcells  ce; /* which cell */
{
    I32s o, l = 1, adrt;
    I32s i = 0, match;
    I8s df, db;
    Pgl tgl;

    if ((tz < MinTemplSize) || (tz > SoupSize))
    {   adrt = -1;
        goto finish;
    }
    if ((I8s) dir == 'o') df = db = 1;       /* both directions */
    if ((I8s) dir == 'f') /* forward only */
    {   df = 1;
        db = 0;
    }
    if ((I8s) dir == 'b') /* backwards only */
    {   df = 0;
        db = 1;
    }
    o = ad(ce->c.ip + 1);
    while (1) {
    while (1) /* this skips sections of codes that are not templates (NOPs) */
    {   
        if (df && (soup[f][ce->d.tr].inst == Nop0 /* forward */
               ||  soup[f][ce->d.tr].inst == Nop1))
        break;
        else
        {   f++;
            f = ad(f);
        }
        if (db && (soup[b][ce->d.tr].inst == Nop0 /* backward */
               ||  soup[b][ce->d.tr].inst == Nop1))
        break;
        else
        {   b--;
            b = ad(b);
        }
    }
    match = 1;       /* forward */
    if (df && (soup[f][ce->d.tr].inst == Nop0
           ||  soup[f][ce->d.tr].inst == Nop1))  /* if NOPs */
    {   if (!mode)  /* compliment match mode */
        {   for (i = 0; i < tz; i++) /* over the full template size */
            {   if (!(soup[ad(o + i)][ce->d.tr].inst   /* if not compl */
                    - soup[ad(f + i)][ce->d.tr].inst ))
                {   match = 0;
                    break;
                }
            }
        }
        else  /* direct match mode */
        {   for (i = 0; i < tz; i++)  /* over the full template size */
            {   if (soup[ad(o + i)][ce->d.tr].inst         /* if compl */
                    - soup[ad(f + i)][ce->d.tr].inst )
                {   match = 0;
                    break;
                }
            }
        }
        if (match)
        {   f += flaw(ce);
            adrt = ad(f + tz);
            goto finish;
        }
    }
    match = 1;  /* backward */
    if (db && (soup[b][ce->d.tr].inst == Nop0
           ||  soup[b][ce->d.tr].inst == Nop1))  /* if NOPs */
    {   if (!mode)  /* compliment match mode */
        {   for (i = 0; i < tz; i++)  /* over the full template size */
            {   if (!(soup[ad(o + i)][ce->d.tr].inst
                    - soup[ad(b + i)][ce->d.tr].inst ))
                {   match = 0;
                    break;
                }
            }
        }
        else  /* direct match mode */
        {   for (i = 0; i < tz; i++) /* over the full template size */
            {   if (soup[ad(o + i)][ce->d.tr].inst
                    - soup[ad(b + i)][ce->d.tr].inst)
                {   match = 0;
                    break;
                }
            }
        }
        if (match)
        {   b += flaw(ce);
            adrt = ad(b + tz);
            goto finish;
        }
    }   /* increment search pointers, backward and forward */
    if (db)
    {   b--;
        b = ad(b);
    }
    if (df)
    {   f++;
        f = ad(f);
    }
    l++;
    if (l > *slim)  /* if we exceed the search limit abort */
    {   adrt = -1;
        goto finish;
    }
    }
finish:
    *slim = l;
    if (1 && WatchTem)
    tgl = sl[ce->d.gen.size]->g[ce->d.gi];
    if (1 && WatchTem && adrt >= 0 && !ce->d.flaw && !ce->d.mut &&
        ce->mm.p <= ce->c.ip && ce->c.ip < (ce->mm.p + ce->mm.s) &&
        IsBit(tgl->bits, 0))
    GenExTemp(ad(adrt - tz), ce, tz);
    return adrt; /* address of instruction following target template */
}

I32s btemplate(f, b, slim, tz, dir, mode, ce)
 /* search in specified direction for */
 /* binary template return address, returns address of instruction */
 /* following target template, i.e., target + tz */
 /* NOTE: ce->c.ip must point to the instruction (agent) being executed */
    I32s f;    /* starting address for forward search */
    I32s b;    /* starting address for backward search */
    I32s *slim;
    I32s tz;  /* template size */
    I8s dir;  /* direction of search, f = forward, b = backward, o = out */
    I8s mode; /* match mode: 0 = complement, 1 = direct */
    Pcells  ce; /* which cell */
{   I32s o, l = 1, adrt;
    I32s i = 0, match;
    I32s  fd = 0, bd = 0; /* search distance, forward and backward */
    I8s df, db;
    Pgl tgl;

    if ((tz < MinTemplSize) || (tz > SoupSize))
    {   adrt = -1;
        goto finish;
    }
    if (dir == 'o') df = db = 1; /* both directions */
    if (dir == 'f') /* forward only */
    {   df = 1;
        db = 0;
    }
    if (dir == 'b') /* backwards only */
    {   df = 0;
        db = 1;
    }
    o = ad(ce->c.ip + 1);
    while (1) {
    match = 1;
    if (df)  /* if direction forwards */
    {   if (!mode) /* compliment match mode */
        {   for (i = 0; i < tz; i++) /* for full template size */
            {   if ((soup[ad(o + i)][ce->d.tr].inst
                ^ soup[ad(f + i)][ce->d.tr].inst) == 31)
                {   match = 0;
                    break;
                }
            }
        }
        else  /* direct match mode */
        {   for (i = 0; i < tz; i++) /* for full template size */
            {   if (soup[ad(o + i)][ce->d.tr].inst
                    == soup[ad(f + i)][ce->d.tr].inst)
                {   match = 0;
                    break;
                }
            }
        }
        if (match)
        {   f += flaw(ce);
            adrt = ad(f + tz);
            goto finish;
        }
    }
    if (db) /* if direction backwards */
    {   match = 1;
        if (!mode) /* compliment match mode */
        {   for (i = 0; i < tz; i++) /* for full template size */
            {   if ((soup[ad(o + i)][ce->d.tr].inst
                ^ soup[ad(b + i)][ce->d.tr].inst) == 31)
                {   match = 0;
                    break;
                }
            }
        }
        else  /* direct match mode */
        {   for (i = 0; i < tz; i++) /* for full template size */
            {   if (soup[ad(o + i)][ce->d.tr].inst
                    == soup[ad(b + i)][ce->d.tr].inst)
                {   match = 0;
                    break;
                }
            }
        }
        if (match)
        {   b += flaw(ce);
            adrt = ad(b + tz);
            goto finish;
        }
    }   /* increment search pointers, backward and forward */
    if (db)
    {   b--;
        b = ad(b);
    }
    if (df)
    {   f++;
        f = ad(f);
    }
    l++;
    if (l > *slim)
    {   adrt = -1;
        goto finish;
    }
    }
finish:
    *slim = l;
    if (1 && WatchTem)
    tgl = sl[ce->d.gen.size]->g[ce->d.gi];
    if (1 && WatchTem && adrt >= 0 && !ce->d.flaw && !ce->d.mut &&
        ce->mm.p <= ce->c.ip && ce->c.ip < (ce->mm.p + ce->mm.s) &&
        IsBit(tgl->bits, 0))
    GenExTemp(ad(adrt - tz), ce, tz);
    return adrt; /* address of instruction following target template */
}

#endif /* FUTURE */

/* ------------------------------------------------------------------- */
#ifdef HSEX
   /* put this at movii at point of  x over  & at mal */

I8s FindMate(ce)
Pcells ce;
{
/* search out FORWARD (sorry ) to find cell of roughly the close size
 * but diff genotype
 * insert addr into ce->d.mate_addr
 * if (ce->d.x_over_addr > 0)
 *    ce->d.mate_addr = me->mm.p;
 * else
 *    ce->d.mate_addr = me->mm.p + ce->d.x_over_addr;
 * if one can't be found, return 0
 *
 */

Pcells me;
I32s fi,fmasl,ll;
I8s tmd, fi_not_free=0;

#ifdef ERROR
if ((!ce))
   {
   FEError(-12666,NOEXIT,NOWRITE,"FindMate - Bad cell passed !\n");
   return 0;
   }
#endif
/* bi = ad(ce->mm.p -1);   byte before cell */
fi = ad(ce->mm.p +ce->mm.s+1);  /* byte after cell */
fmasl = ad( (I32s) ( MateSearchL * AverageSize));

   while(1)
      {
      /* forward */
      if (!(IsFree(fi)))
         {
         fi_not_free =1;
         WhichCell(fi,&me,&tmd);
         if ((!MateSearchL) && (me == ce)) return 0;
         if ((tmd == 'm') &&
             (me->mm.s >= (ce->mm.s - MateSizeEp)) &&
             (me->mm.s <= (ce->mm.s + MateSizeEp)))
             {
             if (!IsSameGen(ce->mm.s,&soup[ce->mm.p],&soup[me->mm.p]))
                {
                if(ce->d.x_over_addr < 0)
                  {
                  ce->d.mate_addr = me->mm.p;
                  }
                else
                  {
                  ce->d.mate_addr = ad(me->mm.p + ce->d.x_over_addr);
                  }
                return 1;
                }

             }
         }

      /* not found so inc soup indexs */
      if(fi_not_free)
        {
        fi_not_free=0;
        fi = ad(me->mm.s+me->mm.p +1);
        }
      else fi = ad(fi+MinCellSize -1);

      /* check to see if we are done */
      if( fi < ce->mm.p) /* we have rolled of the top */
        {
        ll = SoupSize - ce->mm.p + fi;
        }
      else
        {
        ll = fi - ce->mm.p;
        }
      if ((!MateSearchL) && (ll > fmasl)) return 0;
      }
}       /* end of FindMate */

/* have func that chooses mate or not in mal */
I8s DoMate()
{
if ((NumCells) && (MateProb > 0.0 ) && ((tlrand() %101) < (100*MateProb))) 
   return 1;
return 0;
}
/* then have func that chooses x_over */
I16s SetXover(ce)
Pcells ce;
{
return (((tlrand() %2) ? 1: -1) *
        (tlrand() % ((I32s) (MateXoverProp * ce->mm.s)+1)));
}

void UseMate(ce)
Pcells ce;
{
if ((( ce->d.x_over_addr > 0) &&                /* second half, ! > x_over */
     (ce->d.mov_daught < ce->d.x_over_addr)) ||
    (( ce->d.x_over_addr < 0) &&                /* first half, > x_over */
     (ce->d.mov_daught > (-1*ce->d.x_over_addr))))
   {
   is.sval = ad((is.sval - ce->mm.p) + ce->d.mate_addr);
#if PLOIDY == 1
   is.dins = &soup[is.sval];
#else /* PLOIDY > 1 */
   is.dins = &soup[is.sval][ce-c.tr];
#endif /* PLOIDY > 1 */
   }
}

#endif /* ifdef HSEX */

/* ------------------------------------------------------------------- */
/* ------------------------------------------------------------------- */