/****************************************************************************
* pulse.c
* David Boozer
* 27 August 2002
* 25 September 2003
* 12 January 2004 add looping command
* 16 January 2004 use for loops for looping
* 02 Febuary 2004 add nested loops
* 15 March 2004 add analog output
* 31 March 2006 fix problem with two pokes in a row
* 14 April 2006 change syntax, add inlines, etc
* 17 April 2006 minor changes
* 20 April 2006 add comment command
* 29 April 2006 minor changes
* 16 August 2006 allow higher time resolution
* 28 September 2006 add scan command, allow pulses to nudge loops
* 15 November 2006 change pokes so zero appears in front of hex word
* 25 January 2009 change name from "hirez.c" to "pulse.c"
*****************************************************************************
* Compile timing pulses
*****************************************************************************
* Command syntax:
*
* <cmd> --> p<name> : <cmd>
*       --> invert <digital channel>
*       --> define t<name> <time>
*       --> define c<name> <int>
*       --> define a<name> <int>
*       --> begin_comment <cmds> end_comment
*       --> [<time>, <time>] <digital channel>
*       --> <time> aout <analog channel> > <float>
*       --> <time> inline ' <string> '
*       --> <time> loop <int> { <cmds> }
*       --> <time> scan { <cmds> }
*
* <time> --> <time> + <time>
*        --> <time> - <time>
*        --> ( <time> )
*        --> start( p<name> )
*        --> stop( p<name> )
*        --> t<name>
*        --> <float>
*
* <digial channel> --> c<name>
*                  --> <int>
*
* <analog channel> --> a<name>
*                  --> <int>
*
****************************************************************************/

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <math.h>

#define NUM_PULSES_MAX 1000

/* tokens */

#define START     4
#define STOP      5
#define DEFINE    6
#define INVERT    7
#define STRING   16
#define NUM       8
#define VOLTAGE  14
#define COMMENTB 19
#define COMMENTE 20
#define SCAN     21

/* name types */

#define TNAME     3
#define CNAME     1
#define ANAME    13
#define PNAME     2

/* pulse types */

#define DPULSE   12
#define LOOP     18
#define AOUT     11
#define INLINE   15

#define T_MAX  ((long long int) (1e11))

void match (int);
long long int time_terminal (int owner);
long long int time (int owner);

FILE *input_file;

int line_num = 1;
double tokenval;
int lookahead;
int num_pulses = 0;
char buffer[128];

/*
 * There are four types of pulses:
 *
 * DPULSE   digital pulse
 * LOOP     loop
 * AOUT     analog out
 * INLINE   inline command
 *
 * Each pulse has a channel, a start time, and a stop time
 */
struct {
  /* defined for all pulse types */
  int type;
  int owner;
  long long int time[2];

  /* defined for DPULSE and AOUT */
  int channel;

  /* defined for LOOP */
  int nesting;
  int scope;
  int iterations;

  /* defined for AOUT */
  double volts;

  /* defined for INLINE */
  char *str;
} pulse[NUM_PULSES_MAX];


/*
 * There are four types of names:
 *
 * CNAME    digital channel name
 * PNAME    pulse name
 * TNAME    time name
 * ANAME    analog channel name
 *
 * Each name is bound to a value
 */
struct node {
  char name[32];
  int type;
  long long int val;
  struct node *next;
};

struct node *head = NULL;

int polarity[32];

void print_name_type (FILE *file, int type) {
  switch (type) {
  case CNAME: fprintf (file, "channel"); break;
  case PNAME: fprintf (file, "pulse"); break;
  case TNAME: fprintf (file, "time"); break;
  case ANAME: fprintf (file, "aout"); break;
  }
}

void print_binary (int n) {
  int i;

  for (i=15; i>=0; i--) printf ("%c", (n>>i & 1) + '0');
  printf ("b");
}

void syntax_error () {
  fprintf (stderr, "Error: syntax error in line %d\n", line_num);
  exit (0);
}

/* return the value bound to a pulse with a given name and type */
long long int lookup_name (char *name, int type) {
  struct node *ptr;

  ptr = head;
  while (ptr != NULL) {
    if ((strcmp (ptr->name, name) == 0) && (ptr->type == type))
      return (ptr->val);
    ptr = ptr->next;
  }
  fprintf (stderr, "Error in line %d: ", line_num);
  print_name_type (stderr, type);
  fprintf (stderr, " name '%s' not defined\n", name);
  exit (0);
}

/* define a new pulse with given name and type; bind it to num */
void define_name (char *name, int type, long long int num) {
  struct node *ptr, *ptr_last;

  ptr = head;
  while (ptr != NULL) {
    if ((strcmp (ptr->name, name) == 0) && (ptr->type == type)) {
      fprintf (stderr, "Error in line %d: ", line_num);
      print_name_type (stderr, type);
      fprintf (stderr, " name '%s' already defined\n", name);
      exit (0);
    }
    ptr_last = ptr;
    ptr = ptr->next;
  }
  ptr = (struct node *) malloc (sizeof (struct node));
  if (head == NULL) head = ptr;
  else ptr_last->next = ptr;
  strcpy (ptr->name, name);
  ptr->type = type;
  ptr->val = num;
  ptr->next = NULL;
}

int next_token (void) {
  char t;
  int i;
  
  while (1) {
    t = getc (input_file);
    if (t == ' ' || t == '\t') ;
    else if (t == '\n') line_num++;
    else if (t == '\'') {
      i = 0;
      do {
	t = getc (input_file);
	buffer[i++] = t;
      } while (t != '\'');
      buffer[i-1] = '\0';
      return STRING;
    }
    else if (isdigit(t)) {
      ungetc (t, input_file);
      fscanf (input_file, "%lf", &tokenval);
      return NUM;
    }
    else if (t == '>') {
       fscanf (input_file, "%lf", &tokenval);
       return VOLTAGE;
    }
    else if (isalpha(t)) {
      i = 0;
      while (isalpha(t) || t == '_' || isdigit(t)) {
	buffer[i++] = t;
	t = getc (input_file);
      }
      buffer[i] = '\0';
      if (t != EOF) ungetc (t, input_file);
      if (strcmp (buffer, "start") == 0) return START;
      else if (strcmp (buffer, "stop") == 0) return STOP;
      else if (strcmp (buffer, "define") == 0) return DEFINE;
      else if (strcmp (buffer, "invert") == 0) return INVERT;
      else if (strcmp (buffer, "loop") == 0) return LOOP;
      else if (strcmp (buffer, "scan") == 0) return SCAN;
      else if (strcmp (buffer, "inline") == 0) return INLINE;
      else if (strcmp (buffer, "aout") == 0) return AOUT;
      else if (strcmp (buffer, "begin_comment") == 0) return COMMENTB;
      else if (strcmp (buffer, "end_comment") == 0) return COMMENTE;
      else if (buffer[0] == 'c') return CNAME;
      else if (buffer[0] == 'p') return PNAME;
      else if (buffer[0] == 't') return TNAME;
      else if (buffer[0] == 'a') return ANAME;
      else syntax_error ();
    }
    else if (t == ';') {
      while (t != '\n') t = getc (input_file);
      line_num++;
    }
    else return t;
  }
}

void match (int token) {
  if (lookahead == token) lookahead = next_token ();
  else syntax_error ();
}

/* return a time */
long long int time_terminal (int owner) {
  long long int t;
  int sign, n;

  switch (lookahead) {
  case NUM:
    t = (long long int) floor (1e6*tokenval);
    match (lookahead);
    return (t);
  case TNAME:
    t = lookup_name (buffer, TNAME);
    match (TNAME);
    return (t);
  case START:
  case STOP:
    sign = (lookahead == START) ? 0 : 1;
    match (lookahead);
    match ('(');
    n = (int) lookup_name (buffer, PNAME);
    if (pulse[n].owner != owner) {
      fprintf (stderr, "Error: invalid pulse referencing in line %d\n",
	       line_num);
      exit (0);
    }
    t = pulse[n].time[sign];
    match (PNAME);
    match (')');
    return (t);
  case '(':
    match ('(');
    t = time (owner);
    match (')');
    return (t);
  default:
    syntax_error ();
  }

}

/* return a time */
long long int time (int owner) {
  char operation;
  long long int t;

  t = time_terminal (owner);
  while ((lookahead == '+') || (lookahead == '-')) {
    operation = lookahead;
    match (lookahead);
    if (operation == '+') t += time_terminal (owner);
    if (operation == '-') t -= time_terminal (owner);
  }
  return (t);
}

/* return a digital channel number */
int digital_channel () {
  int c_num;

  if (lookahead == CNAME)
    c_num = (int) lookup_name (buffer, CNAME);
  else if (lookahead == NUM)
    c_num = (int) tokenval;
  else
    syntax_error ();
  match (lookahead);
  if (c_num < 0 || c_num >= 32) {
    fprintf (stderr, "Error in line %d: channel %d does not exist\n",
	     line_num, c_num);
    exit (0);
  }
  return (c_num);
}

/* return an analog channel number */
int analog_channel () {
  int a_num;
  
  if (lookahead == ANAME)
    a_num = (int) lookup_name (buffer, ANAME);
  else if (lookahead == NUM)
    a_num = (int) tokenval;
  else
    syntax_error ();
  match (lookahead);
  if (a_num < 0 || a_num > 4) {
    fprintf (stderr, "Error in line %d: channel %d does not exist\n",
	     line_num, a_num);
    exit (0);
  }
  return (a_num);
}

/* return a time */
long long int line (int owner, int nesting) {
  char name[32];
  long long int t_period;
  long long int t, t_a, t_b, t_last, t_line;
  int n, loop_num;
  
  t_last = 0;
  switch (lookahead) {
  case COMMENTB:
    match (COMMENTB);
    while (lookahead != COMMENTE) match (lookahead);
    match (COMMENTE);
    break;
  case DEFINE:
    match (DEFINE);
    if (lookahead != TNAME && lookahead != CNAME && lookahead != ANAME)
      syntax_error ();
    strcpy (name, buffer);
    n = lookahead;
    match (lookahead);
    if (n == TNAME)
      define_name (name, TNAME, time (owner));
    else {
      define_name (name, n, (long long int) tokenval);
      match (NUM);
    }
    break;
  case INVERT:
    match (INVERT);
    polarity[digital_channel ()] = 1;
    break;
  case PNAME:
    define_name (buffer, PNAME, (long long int) num_pulses);
    match (PNAME);
    match (':');
    break;
  case '[':
    match ('[');
    t_a = time (owner);
    match (',');
    t_b = time (owner);
    match (']');
    if (t_b <= t_a) {
      fprintf (stderr, "Error: invalid pulse in line %d\n", line_num);
      exit (0);
    }
    pulse[num_pulses].type = DPULSE;
    pulse[num_pulses].owner = owner;
    pulse[num_pulses].time[0] = t_a;
    pulse[num_pulses].time[1] = t_b;
    pulse[num_pulses].channel = digital_channel ();
    num_pulses++;
    t_last = t_b;
    break;
  default:
    t = time (owner);
    switch (lookahead) {
    case AOUT:
      match (AOUT);
      pulse[num_pulses].type = AOUT;    
      pulse[num_pulses].owner = owner;
      pulse[num_pulses].time[0] = t;
      pulse[num_pulses].time[1] = t;
      pulse[num_pulses].channel = analog_channel ();
      pulse[num_pulses].volts = tokenval;
      match (VOLTAGE);
      num_pulses++;
      t_last = t;
      break;
    case INLINE:
      match (INLINE);
      pulse[num_pulses].type = INLINE;
      pulse[num_pulses].owner = owner;
      pulse[num_pulses].time[0] = t;
      pulse[num_pulses].time[1] = t;
      pulse[num_pulses].str = strdup(buffer);
      match (STRING);
      num_pulses++;
      t_last = t;
      break;
    case LOOP:
      match (LOOP);
      n = (int) tokenval;
      match (NUM);
      if (nesting > 2) {
	fprintf (stderr, "Error: loop nesting too deep in line %d\n",
		 line_num);
	exit (0);      
      }

      loop_num = num_pulses;
      num_pulses++;

      match ('{');
      t_period = 0;
      do {
	t_line = line (loop_num, nesting+1);
	if (t_line > t_period) t_period = t_line;
      } while (lookahead != '}');
      match ('}');

      t_last = t + n*t_period;

      pulse[loop_num].type = LOOP;
      pulse[loop_num].owner = owner;
      pulse[loop_num].time[0] = t;
      pulse[loop_num].time[1] = t_last;
      pulse[loop_num].iterations = n;
      pulse[loop_num].nesting = nesting;
      pulse[loop_num].scope = num_pulses-1;
      break;
    case SCAN:
      match (SCAN);

      if (nesting == 0) {
	fprintf (stderr, "Error: scanning in outer loop in line %d\n",
		 line_num);
	exit (0);      
      }
      if (nesting > 2) {
	fprintf (stderr, "Error: loop nesting too deep in line %d\n",
		 line_num);
	exit (0);      
      }

      loop_num = num_pulses;
      num_pulses++;

      match ('{');
      t_period = 0;
      do {
	t_line = line (loop_num, nesting+1);
	if (t_line > t_period) t_period = t_line;
      } while (lookahead != '}');
      match ('}');

      t_last = t + t_period;

      pulse[loop_num].type = LOOP;
      pulse[loop_num].owner = owner;
      pulse[loop_num].time[0] = t;
      pulse[loop_num].time[1] = t_last;
      pulse[loop_num].iterations = -1;
      pulse[loop_num].nesting = nesting;
      pulse[loop_num].scope = num_pulses-1;
      break;
    default:
      fprintf (stderr, "Error: unknown token type on line %d\n", line_num);
      exit (0);
    }
  }
  return (t_last);
}

void parse_input_file (char *input_filename) {
  long long int t, t_max;

  if ((input_file = fopen (input_filename, "r")) == NULL) {
    fprintf(stderr, "Error reading from file: %s\n", input_filename);
    exit (0);
  }

  t_max = -1;
  lookahead = next_token ();
  while (lookahead != EOF) {
    t = line (-1, 0);
    if (t > t_max) t_max = t;
  }

  /*
    fprintf (stderr, "[%4.3f, %4.3f]\n", 0.0, (double) 1e-6*t_max);
  */

  fclose (input_file);
}

char *output_filename = "foo.txt\0";
FILE *output_file;

/****************************************************************************
* poke (addr, num)           4 cycles
* inc a                      3 cycles
* a = 0                      2 cycles
* for a = 1 to n; next a     8*n cycles
****************************************************************************/
void print_wait (long long int tau) {
  long long int n_cycles, temp;
  int n, a, b, c;
  int j;

  n_cycles = tau/25;
  temp = n_cycles - 4;
  b = temp % 2;
  if (b == 1) temp -= 3;
  n = temp / 40000;
  temp = temp % 40000;
  a = temp >> 3;
  c = (temp % 8) >> 1;

  fprintf (output_file, "' wait for %f ms (%lld cycles)\n",
	   (double) 1e-6*tau, n_cycles);
  fprintf (output_file, "' %lld = 4e5*%d + 8*%d + 3*%d + 2*%d + 4 = %lld\n",
	   n_cycles, n, a, b, c,
	   (long long int) 40000*n + 8*a + 3*b + 2*c + 4);
  
  if (n < 0 || a < 0 || b < 0 || c < 0) {
    fprintf (stderr, "Error: pulse too short\n");
    exit (0);
  }

  if (n > 0) {
    fprintf (output_file, "for a = 1 to %d\n", n);
    fprintf (output_file, "for b = 1 to 4999\n");
    fprintf (output_file, "next b\n");
    fprintf (output_file, "next a\n");
  }
  if (a > 0) {
    fprintf (output_file, "for a = 1 to %d\n", a);
    fprintf (output_file, "next a\n");
  }
  if (b > 0)
    fprintf (output_file, "inc a\n", a);
  for (j=0; j<c; j++)
    fprintf (output_file, "a = 0\n");
}

void print_pulses (int owner, unsigned int output_l, unsigned int output_h) {
  int num_edges, n, i, flag_output_l, flag_output_h;
  int bit, channel_mod_16;
  long long int t_min, t_old, t, t_loop_end;
  int flag_loop;

  struct edge_node {
    int pulse_num;
    int sign;
  } edge[NUM_PULSES_MAX];

  t_old = -1;
  t_loop_end = 0;
  flag_loop = 1;

  do {
    t_min = T_MAX;
    num_edges = 0;
    
    for (n=0; n<num_pulses; n++) for (i=0; i<2; i++) {
      t = pulse[n].time[i];
      if (pulse[n].owner == owner && t > t_old && t <= t_min &&
	  (pulse[n].type == DPULSE || i == 0)) {
	if (t < t_min) {
	  num_edges = 0;
	  t_min = t;
	}
	edge[num_edges].pulse_num = n;
	edge[num_edges].sign = i;
	num_edges++;
      }
    }
    
    if (num_edges == 0) break;

    if (flag_loop) {
      if (t_min > t_loop_end) print_wait (t_min - t_loop_end);
      if (t_min < t_loop_end) {
	fprintf (stderr, "Error: edge overlaps with loop in print_pulses\n");
	exit (0);
      }
    }
    else
      if (t_min > t_old) print_wait (t_min - t_old);    

    t_old = t_min;

    flag_output_l = 0;
    flag_output_h = 0;
    
    for (i=0; i<num_edges; i++) {
      n = edge[i].pulse_num;
      switch (pulse[n].type) {
      case AOUT:
	fprintf (output_file, "dac (%d, %d) ' %f volts\n",
		 pulse[n].channel,
		 (unsigned int) ((pulse[n].volts + 10.0)*(1<<16)/20.0),
		 pulse[n].volts);
	break;
      case INLINE:
	fprintf (output_file, "%s\n", pulse[n].str);
	break;
      case DPULSE:
	bit = edge[i].sign^polarity[pulse[n].channel]^1;
	channel_mod_16 = pulse[n].channel % 16;
	
	fprintf (output_file, "' %d %s\n", pulse[n].channel,
		 bit ? "high" : "low");
	
	if (pulse[n].channel < 16) {
	  output_l &= ~(1 << channel_mod_16);
	  output_l |= bit << channel_mod_16;
	  flag_output_l = 1;
	}
	else {
	  output_h &= ~(1 << channel_mod_16);
	  output_h |= bit << channel_mod_16;
	  flag_output_h = 1;
	}
	break;
      case LOOP:
	  break;
      default:
	fprintf (stderr, "Error: unkown pulse type in print_pulses\n");
	  exit (0);
      }
    }

    if (flag_output_l)
      fprintf (output_file, "poke(204001C0h,0%04xh)\n", output_l);
    if (flag_output_l && flag_output_h) {
      fprintf (stderr, "Warning: simultaneous pulses on both banks\n");
      print_wait (200);
    }
    if (flag_output_h)
      fprintf (output_file, "poke(204000C0h,0%04xh)\n", output_h);

    flag_loop = 0;

    for (i=0; i<num_edges; i++) {
      n = edge[i].pulse_num;
      if (pulse[n].type == LOOP) {
	if (flag_loop) {
	  fprintf (stderr, "Error: overlapping loops\n");
	  exit (0);
	}

	if (pulse[n].iterations > 0) {
	  fprintf (output_file, "for %c = 1 to %d\n",
		   'i' + pulse[n].nesting, pulse[n].iterations);
	  print_pulses (n, output_l, output_h);
	  fprintf (output_file, "next %c\n", 'i' + pulse[n].nesting);
	}
	else {
	  fprintf (output_file, "if (i > 1) then\n");
	  fprintf (output_file, "for %c = 1 to i-1\n",
		   'i' + pulse[n].nesting);
	  print_pulses (n, output_l, output_h);
	  fprintf (output_file, "next %c\n", 'i' + pulse[n].nesting);
	  fprintf (output_file, "endif\n");
	}
	flag_loop = 1;
	t_loop_end = pulse[n].time[1];
      }
    }
  } while (1);
}

void print_output_file () {
  unsigned int output_l = 0, output_h = 0;
  int i;

  if ((output_file = fopen (output_filename, "w")) == NULL) {
    fprintf(stderr, "Error writing to file: %s\n", output_filename);
    exit (0);
  }

  for (i=0; i<16; i++) output_l |= polarity[i]<<i;
  for (i=16; i<32; i++) output_h |= polarity[i]<<(i%16);

  fprintf (output_file, "poke(204001C0h,0%04xh)\n", output_l);
    print_wait (200);
  fprintf (output_file, "poke(204000C0h,0%04xh)\n", output_h);

  print_pulses (-1, output_l, output_h);
  
  fclose (output_file);
}

void print_log_file () {
  char *log_filename = "foo.log\0";
  FILE *log_file;
  struct node *ptr;
  int i;

  if ((log_file = fopen (log_filename, "w")) == NULL) {
    fprintf(stderr, "Error writing to file: %s\n", log_filename);
    exit (0);
  }

  /* print channel polarities */

  for (i=0; i<32; i++)
    if (polarity[i]) fprintf (log_file, "channel %d inverted\n", i);

  /* print symbol table */

  fprintf (log_file, "\nSymbol table:\n\n");
  ptr = head;
  while (ptr != NULL) {
    fprintf (log_file, "%-32s", ptr->name);
    print_name_type (log_file, ptr->type);
    if (ptr->type == TNAME)
      fprintf (log_file, "\t\t%.6f\n", (double) 1e-6*ptr->val);
    else
      fprintf (log_file, "\t\t%d\n", (int) ptr->val);
    ptr = ptr->next;
  }

  /* print pulse table */

  fprintf (log_file, "\nPulse table:\n\n");
  for (i=0; i<num_pulses; i++)
    switch (pulse[i].type) {
    case DPULSE:
      fprintf (log_file,
	       "pulse %02d  [%13.6f, %13.6f]  %2d  "
	       "pulse  %2d\n", i,
	       (double) 1e-6*pulse[i].time[0],
	       (double) 1e-6*pulse[i].time[1],
	       pulse[i].owner, pulse[i].channel);
      break;
    case LOOP:
      fprintf (log_file,
	       "pulse %02d  [%13.6f, %13.6f]  %2d  "
	       "loop  %d  %d  (%d, %d)\n", i,
	       (double) 1e-6*pulse[i].time[0],
	       (double) 1e-6*pulse[i].time[1],
	       pulse[i].owner,
	       pulse[i].iterations, pulse[i].nesting, i+1, pulse[i].scope);
      break;
    case AOUT:
      fprintf (log_file,
	       "pulse %02d  [%13.6f, %13.6f]  %2d  "
	       "analog out  %d > %4.3f volts\n", i,
	       (double) 1e-6*pulse[i].time[0],
	       (double) 1e-6*pulse[i].time[1],
	       pulse[i].owner,
	       pulse[i].channel, pulse[i].volts);
      break;
    case INLINE:
      fprintf (log_file,
	       "pulse %02d  [%13.6f, %13.6f]  %2d  "
	       "inline  \'%s\'\n", i,
	       (double) 1e-6*pulse[i].time[0],
	       (double) 1e-6*pulse[i].time[1],
	       pulse[i].owner,
	       pulse[i].str);
      break;
    }

  fclose (log_file);
}

void check_pulses () {
  int i, j, k;

  for (i=0; i<num_pulses; i++) if (pulse[i].type == LOOP)
    for (j=0; j<num_pulses; j++)
      if (pulse[j].owner == pulse[i].owner &&
	  (j < i || j > pulse[i].scope))
	for (k=0; k<2; k++)
	  if (pulse[i].time[0] < pulse[j].time[k] &&
	      pulse[j].time[k] < pulse[i].time[1]) {
	    fprintf (stderr, "Error: pulse %d overlaps with loop %d\n",
		     j, i);
	    exit (0);
	  }
}

int main (int argc, char *argv[]) {
  int i;

  /*
  print_wait (1e6);
  exit (0);
  */

  for (i=0; i<32; i++) polarity[i] = 0;

  if (argc != 2) {
    fprintf (stderr, "Syntax: pulse <input file>\n");
    exit (0);
  }

  parse_input_file (argv[1]);
  print_log_file ();
  check_pulses ();
  print_output_file ();

  fprintf (stderr, "%d pulses compiled\n", num_pulses);

  for (i=0; i<num_pulses; i++)
    if (pulse[i].type == INLINE) free(pulse[i].str);

  return 0;
}