ca_shell.c

细胞自动机的一个源代码

#include "main.h"

/* display command window */
void cas_display(cas_t *cas) {
  int i, j, k, b, e;


  glColor3f(cas->r, cas->g, cas->b);
  glRasterPos3f(cas->x, cas->y, cas->z);


  b = (((cas->by - cas->wh)>0) ? (cas->by - cas->wh) : 0);
  e = b + cas->wh;
  k=0;


  for (i=b; i<e; i++) {
    glRasterPos3f(worl.v[0] + ( (float)fabs(worl.v[0] - worl.v[1]) / 20.0 ), /* cas->x,*/
		  (cas->y - ((float)k*(worl.v[3]/(float)cas->cnl))),
		  -worl.v[4] - 0.1); /*cas->z);*/
    k++;
    for (j=0; j<cas->ww; j++) {
      //glBitmap(cas->cw, cas->ch, 0.0, 0.0, cas->cspace,
      //       0.0, cas->a[cas->buf[i][j]]);

      //glutBitmapCharacter(GLUT_BITMAP_9_BY_15, cas->buf[i][j]);
      glutBitmapCharacter(GLUT_BITMAP_9_BY_15, cas->buf[i][j]);


    }
    //glBitmap(0, 0, 0.0, 0.0,
    //     -(cas->cspace*((float)cas->ww)),
    //     -cas->cnl, NULL);
  }

}

/* slide window for new line */
void cas_slide(cas_t *cas) {
  int i, j, k;

  for (i=1; i<cas->bh; i++) {
    for (j=0; j<cas->bw; j++) {
      cas->buf[i-1][j] = cas->buf[i][j];
    }
  }

  i--;
  for (j=0; j<cas->bw; j++) {
    cas->buf[i][j]=0;
  }

}


void cas_addstr(cas_t *cas, char *s) {
  int i, j, k;

  for (i=0; s[i]; i++) {
    cas_addch(cas, s[i]);
  }

}

void cas_addstr_norun(cas_t *cas, char *s) {
  int i, j, k;

  for (i=0; s[i]; i++) {
    cas_addch_norun(cas, s[i]);
  }
}

void cas_addch_norun(cas_t *cas, int ch) {
  int i, j, k;

  if (ch==XK_Return) {
    cas->buf[cas->by][cas->bx] = (char)' ';
    //cas_runcmd(cas);
    cas->bx = 0;
    cas->by++;
    if (cas->by >= cas->bh) {
      cas->by--;
      cas_slide(cas);
    }
    cas->buf[cas->by][cas->bx] = (char)'$';
    return;
  }

  if (ch==XK_BackSpace) {

    cas->buf[cas->by][cas->bx] = (char)(' ');
    cas->bx -= ((cas->bx<=0) ? 0 : 1);
    cas->buf[cas->by][cas->bx] = (char)('$');
    return;

  }

  cas->buf[cas->by][cas->bx] = (char)ch;
  cas->bx++;
  cas->buf[cas->by][cas->bx] = (char)'$';


  if (cas->bx >= cas->bw) {

    cas->bx = 0;
    cas->by++;
    if (cas->by >= cas->bh) {
      cas_slide(cas);
      cas->by--;
    }

  }

}


/* add character to buffer */
void cas_addch(cas_t *cas, int ch) {
  int i, j, k;

  if (ch==XK_Return) {
    cas->buf[cas->by][cas->bx] = (char)' ';

    cas->comx = cas->bx;

    cas->bx = 0;
    cas->by++;
    if (cas->by >= cas->bh) {
      cas->by--;
      cas_slide(cas);
    }
    cas->buf[cas->by][cas->bx] = (char)'$';

    cas->comy = cas->by - 1;

    cas_runcmd(cas);

    return;
  }

  if (ch==XK_BackSpace) {

    cas->buf[cas->by][cas->bx] = (char)(' ');
    cas->bx -= ((cas->bx<=0) ? 0 : 1);
    cas->buf[cas->by][cas->bx] = (char)('$');
    return;

  }

  cas->buf[cas->by][cas->bx] = (char)ch;
  cas->bx++;
  cas->buf[cas->by][cas->bx] = (char)'$';


  if (cas->bx >= cas->bw) {

    cas->bx = 0;
    cas->by++;
    if (cas->by >= cas->bh) {
      cas_slide(cas);
      cas->by--;
    }

  }

}

/* parse command.  null terminated pointer array.
   max of five operands (correct word?) */
static char **cas_parsecmd(char *cmd) {
  static char **com = NULL;
  char *c;
  int i, j, k, n;
  int cur=0, p=0;

  int max_cmd = 10, line_len = 200;


  if (!com) {
    com = (char **)malloc(sizeof(char *)*max_cmd);
    for (i=0; i<max_cmd; i++) {
      com[i] = (char *)malloc(sizeof(char)*line_len);
    }
  }

  for (i=0; i<max_cmd; i++) {

    /*
    for (j=0; j<line_len; j++) {
      com[i][j] = '\0';
    }
    */

    memset(com[i], '\0', sizeof(char)*line_len);

  }

  /* BUG: too many spaces gives a core dump... */

  n = strlen(cmd);
  i=0;
  while (cmd[i]) {

    //printf("cmd %i: %c\n", i, cmd[i]);

    if (cmd[i]==' ') {

      com[cur][p] = '\0';
      i++;
      cur++;
      p=0;
    }

    if (!cmd[i]) break;

    com[cur][p] = cmd[i];
    p++;
    i++;
  }

  cur++;
  com[cur][0] = '\0';
  
  return(com);
}

/* geez, is there a better way to do this? */
void cas_runcmd(cas_t *cas) {
  int i, j, k;
  char cmd[200];
  char com[100];
  char opts[4][100];
  char **cmda;
  char *p, *q;
  int ps[3] = {0,0,0}, pe[3] = {99,99,99};
  int tp[3], tq[3];
  int n;
  int poi[3] = {0,0,0};
  float f;
  FILE *fp;
  int pat_p[4] = { 1, 1, 1, 0 }, pat_pos[1] = { 50 }, pat_d[1] = { 4 }, pat_dim = 1;
  float v[6];

  for (i=0; i < cas->comx; i++) {
    cmd[i] = cas->buf[cas->comy][i];
  }
  cmd[i] = '\0';

  cmda = cas_parsecmd(cmd);


  for (i=0; cmda[i][0]; i++) {
    printf(",%s,", cmda[i]);
  }

  printf("\n");

  /* quit */
  if (strcmp(cmda[0], "quit")==0) {

    exit(1);

  }
  /* s(eries) <0/1>  (display time series) */
  else if (strcmp(cmda[0], "s")==0) {

    n = atoi(cmda[1]);
    if (n) {
      g_ca->slen = g_ca->wlen;
    } else {
      g_ca->slen = 1;
    }

  }
  /* r(un) <# steps> */
  else if (strcmp(cmda[0], "r")==0) {

    n = atoi(cmda[1]);
    for (i=0; i<n; i++) {
      (*ca_update_func)(g_ca, 0, g_ca->fd-1);
    }

  }
  /* p(oint) <x> ... <z> */
  else if (strcmp(cmda[0], "p")==0) {

    for (i=0; i<g_ca->dim; i++) {
      poi[i] = atoi(cmda[i+1]);
    }
    g_ca->ca[g_ca->cur][ca_point(g_ca, poi)] = 1;

  }
  /* u(pdate) */
  else if (strcmp(cmda[0], "u")==0) {
    (*ca_update_func)(g_ca, 0, g_ca->fd-1);
  }
  /* g(o) <0/1> */
  else if (strcmp(cmda[0], "g")==0) {

    g_ca->go = atoi(cmda[1]);

    printf("go %i\n", atoi(cmda[1]));

  }
  /* random [0..1] */
  else if (strcmp(cmda[0], "random")==0) {

    f = atof(cmda[1]);
    for (i=0; i<(g_ca->fd); i++) {
      if ( ((float)(1.0*rand()/(RAND_MAX+1.0))) < f ) {
	g_ca->ca[g_ca->cur][i] = 1;
      } else {
	g_ca->ca[g_ca->cur][i] = 0;
      }
    }
  }
  /* reset */
  else if (strcmp(cmda[0], "reset")==0) {
    for (i=0; i<(g_ca->fd); i++) {
      g_ca->ca[g_ca->cur][i] = 0;
    }
  }
  /* disp_config <file> */
  else if (strcmp(cmda[0], "disp_config")==0) {
  }
  /* diff <1/0> <diff> */
  else if (strcmp(cmda[0], "diff")==0) {

    if (atoi(cmda[1])==1) {
      g_ca->diff = atoi(cmda[2]);
      gwin.g_disp = displayfunc_diff;
    } else {
      gwin.g_disp = displayfunc;
    }

  }
  /* config <file> */
  else if (strcmp(cmda[0], "ca_config")==0) {

    if (!(fp = fopen(cmda[1], "r"))) {
      printf("BAD CONFIG READ");
      return;
    }

    ca_free(g_ca);
    g_ca = (ca_t *)malloc(sizeof(ca_t));
    ca_file_config(g_ca, fp);
    fclose(fp);

    ca_print(g_ca);

  }
  /* dfa <0/1> */
  else if (strcmp(cmda[0], "dfa")==0) {

    if (strcmp(cmda[1], "load")==0) {
      if (!(fp = fopen(cmda[2], "r"))) {
	printf("couldn't open %s\n", cmda[2]);
	return;
      }

      dfa_reset(g_dfa);
      dfa_ca_reset(g_dc);

      dfa_config(g_dfa, fp);
      dfa_ca_init(g_dc, g_dfa, g_ca);

      fclose(fp);

    } else if (atoi(cmda[1])==1) {
      if (!g_dfa->s) {
	cas_addstr_norun(cas, "error: must load dfa first");
	cas_addch_norun(cas, XK_Return);
	printf("load dfa first\n");
	return;
      }
      dfa_ca_update(g_dfa, g_dc, g_ca);
      gwin.g_disp = displayfunc_dfa;
    } else {
      gwin.g_disp = displayfunc;
    }

  }
  /* save the current CA */
  else if (strcmp(cmda[0], "save")==0) {
    ca_save_file(g_ca, (cmda[1][0] ? cmda[1] : NULL) );
  /* load CA from file */
  } else if (strcmp(cmda[0], "read")==0) {
    ca_read_file(g_ca, (cmda[1][0] ? cmda[1] : NULL) );
  /* pat load file
     pat on dim0 dim1 ... dimn
  */
  } else if (strcmp(cmda[0], "pat")==0) {

    if (strcmp(cmda[1], "load")==0) {

      fp = fopen(cmda[2], "r");
      if (!fp) {
	printf("bad file (couldn't read '%s'?)\n", cmda[2]);
	return;
      }
      pat_reset(g_pat);
      pat_load_file(g_pat, fp);
      fclose(fp);
      pat_print(g_pat);

    } else if (strcmp(cmda[1], "on")==0) {

      for (i=0; i<g_pat->dim; i++) {
	g_pat->pos[i] = atoi(cmda[i+2]);
      }
      printf("pattern on\n");
      pat_orig_get(g_pat, g_ca);
      pat_ca_put(g_pat, g_ca);
      g_pat->on = 1;
      if (gwin.g_disp == displayfunc_dfa) {
	dfa_ca_update(g_dfa, g_dc, g_ca);
      }

    } else {

      printf("invalid pattern command\n");

    }
    /* else if (strcmp(cmda[1], "test")==0) {
      printf("pattern test\n");
      pat_reset(g_pat);
      pat_init(g_pat,
	       pat_p,
	       pat_pos,
	       pat_d,
	       pat_dim);
      pat_orig_get(g_pat, g_ca);
      pat_ca_put(g_pat, g_ca);
      pat_print(g_pat);
      g_pat->on = 1;
      } */

  } else if (strcmp(cmda[0], "ortho")==0) {

    if (cmda[1][0]) {
      
      v[0] = (float)atof(cmda[1]);
      v[1] = (float)atof(cmda[2]);
      v[2] = (float)atof(cmda[3]);
      v[3] = (float)atof(cmda[4]);
      v[4] = (float)atof(cmda[5]);
      v[5] = (float)atof(cmda[6]);

    } else {

      v[0] = -20.0;
      v[1] = 20.0;
      v[2] = -20.0;
      v[3] = 20.0;
      v[4] = 1.0;
      v[5] = 100.0;

    }

    glinit(2, &worl, v);

  } else if (strcmp(cmda[0], "persp")==0) {


    if (cmda[1][0]) {
      
      v[0] = (float)atof(cmda[1]);
      v[1] = (float)atof(cmda[2]);
      v[2] = (float)atof(cmda[3]);
      v[3] = (float)atof(cmda[4]);
      v[4] = (float)atof(cmda[5]);
      v[5] = (float)atof(cmda[6]);

      glinit(1, &worl, v);

    } else {
      glinit(0, &worl, NULL);
    }
  } else if (strcmp(cmda[0], "help")==0) {
    cas_addstr_norun(cas, "help screen");
    cas_addch_norun(cas, XK_Return);
  }

}


void cas_init(cas_t *cas, int h, int w, char **a, int ch, int cw) {
  int i, j;
  char **alpha, **buf;

  //alpha = (char **)malloc(sizeof(char *)*256);
  //for (i=0; i<256; i++) {
  //alpha[i] = (char *)malloc(sizeof(char)*ch*cw);
  //memcpy(alpha[i], a[i], sizeof(char)*ch*cw);
  //}

  buf = (char **)malloc(sizeof(char *)*h);
  for (i=0; i<h; i++) {
    buf[i] = (char *)calloc(w, sizeof(char));
  }

  for (i=0; i<h; i++) {
    for (j=0; j<w; j++) {
      buf[i][j] = ' ';
    }
  }
  cas->buf = buf;

  cas->r = 0.0;
  cas->g = 1.0;
  cas->b = 0.0;

  cas->cspace = (float)(cw+1);
  cas->cnl = (float)(ch+1);

  cas->wh = h;
  cas->ww = w;

  cas->bx = 0;
  cas->by = 0;

  cas->bh = h;
  cas->bw = w;

  cas->x = -1.0;
  cas->y = 0.0;
  cas->z = -1.1;

  cas->show = 1;

}