med.c

Go to the documentation of this file.

/*
 * This file handles the multiplex table entry descriptors.
 *
 * Format for MED strings (and examples):  See H.223.
 *  
 * External Interface:
 * 
 * mux_table_entry *new_mux_table(char *name);
 * 
 */
#include <stdio.h>
#include "med.h"

extern int debug;


int prefix (char *s1, char *s2)
     /* 
      * Returns 1 iff s1 is a prefix of s2.
      */
{
  while ((*s1) && (*s2) && (*s1==*s2)) {
    s1++;
    s2++;
  }
  return (!*s1);
}


static void upstring(char *s)
     /*
      * Converts a string to upper case.  Assumes ASCII.
      */
{
  while (*s) {
    if ((*s >= 'a') && (*s <= 'z'))
      *s = *s - 'a' + 'A';
    s++;
  }
}


static void stripwhitespace(char *s)
     /*
      * This function does exactly what it says it does.
      */
{
  char *r = s;

  while (*s) {
    if ((*s!=' ') && (*s!='\t') && (*s!='\n')) {
      *r=*s;
      r++;
    }
    s++;
  }
  *r='\0';
}


static int balanced(char *s)
     /*
      * Returns 1 iff the sequence of {'s and }'s in *s forms a DYCK word. 
      */
{
  int leftbraces=0,rightbraces=0;
  int good=1;
  while (*s) {
    if (*s=='{')
      leftbraces++;
    else if (*s=='}')
      rightbraces++;
    if (rightbraces > leftbraces)
      good = 0;
    s++;
  }
  return((good) && (leftbraces==rightbraces));
}


static int atom(char *s)
     /*
      * Returns 1 iff prefix(s) is an atom (i.e. one { followed by one }).  
      */
{
  int leftbraces=0;
  while ((*s) && (*s != '}')) {
    if (*s=='{')
      leftbraces++;
    s++;
  }
  return(leftbraces==1);
}



static char *advance_past_comma(char *s)
/*
 * Advances to just past the next comma, ignoring stuff in nested {}'s. 
 */
{
  int paren=0;
  while (*s) {
    if (*s=='{')
      paren++;
    else if (*s=='}')
      paren--;
    else if ((*s==',') && (paren==0)) {
      s++;
      break;
    }
    s++;
  }
  return (s);
}


static med *new_med(void)
{
  med *bob = (med *) malloc(sizeof(med));
  if (bob==NULL) {
    fflush(stdout);
    fprintf(stderr, "new_med(): malloc() returned NULL.\n");
    exit(1);
  }
  return(bob);
}





/* 
 * Variable used by check_med() and check_med1()
 */
static int depth;               
static int gotucf;

static void check_med1(med *m)
{
  depth++;
  while (m != NULL) {
    if (m->type == MedList)
      check_med1(m->list);
    if (m->rc == UCF) {
      if (gotucf) {
        fflush(stdout);
        fprintf(stderr, "check_med1(): Multiple 'RC UCF's are not allowed.\n");
        exit(1);
      }
      else {
        gotucf=1;
      }
      if (depth > 1) {
        fflush(stdout);
        fprintf(stderr, "check_med1(): 'RC UCF's not allowed in a nested sub-expression.\n");
        exit(1);
      } 
    }
    m = m->next;
  }
  depth--;
}

static void check_med(med *m)
/*
 * Checks multiplex entry for multiple RC UCF's or an RC UCF in a nested sub-expression.
 * Most of the code is in check_med1();
 */
{
  depth=0;
  gotucf=0;

  check_med1(m);

  while (m->next != NULL) {
    m = m->next;
  }

  if ((m->next == NULL) && (m->rc != UCF)) {
    printf("check_med(): Last entry in MultiplexEntryDescriptor should contain a 'RC UCF'.\n");
    exit(1);
  }
}



/*
 * Main parsing functions. 
 */

static med *parse_med1(char *s)
     /*
      * Returns a med structure from a string (i.e., a pointer to the start 
      * of a MED list).  String is expected to have been removed of whitespace
      * and converted to uppercase.
      *
      * Recursion: See *parse_med(char *s).
      *
      */
{
  int i=0, paren=0;
  char *r, *t;
  med *head, *bob;

  /*
   * Two possible cases here.  Either we have something like "{LCN<i>,RC<j>}",
   * or we have something like "{{...}, ..., RC<j>}".
   */
  
  s++;
  if (*s == '{') { 
    /* 
     * Make a list, recursing when necessary. 
     */
    head = new_med();
    head->type = MedList;
    head->next = NULL;

    head->list = bob = parse_med1(s);
    
    s = advance_past_comma(s);
    
    while (*s == '{') {
      bob->next = parse_med1(s);
      bob = bob->next;
      bob->next = NULL;

      s = advance_past_comma(s);
    }

    if (prefix("RCUCF", s)) {
      head->rc = UCF;
    }
    else if (prefix("RC", s)) {      head->rc = atoi(s+2);
    }
    else {
      fflush(stdout);
      fprintf(stderr, "parse_med1(): Parse error at %s.\n", s);
      exit(1);
    }
  } 
  /* Base case (just a single channel) */
  else {
    if (prefix("LCN", s)) {
      head = new_med();
      s+=3;
      head->type = MedAtom;
      head->ch = atoi(s);
      head->next = NULL;
      
      s = advance_past_comma(s);
      if (prefix("RCUCF", s)) {
        head->rc = UCF;
      }
      else if (prefix("RC", s)) {
        head->rc = atoi(s+2);
      }
      else {
        fflush(stdout);
        fprintf(stdout,"parse_med1(): Parse_error at %s.\n", s);
        exit(1);
      }
    }
    else {
      fflush(stdout);
      fprintf(stderr,"parse_med1(): Parse error at %s.\n", s);
      exit(1);
    }
  }   
  return (head);
}


static med *parse_med(char *s)
     /*
      * This is the toplevel function. 
      * The top layer is different, since we can have stuff like:
      * {...},{...}
      */
{
  med *bob, *alice;

  upstring(s);
  stripwhitespace(s);
  
  if (!balanced(s)) {
    printf("Error: Unbalanced {}'s.\n");
  }

  if (*s != '{') {
    fflush(stdout);
    fprintf(stderr, "parse_med(): Parse error at %s.\n", s);
    exit(1);
  }
  bob = alice = parse_med1(s);
  
  s = advance_past_comma(s);
  
  while (*s) {
    alice->next = parse_med1(s);
    alice = alice->next;
    alice->next = NULL;
    s = advance_past_comma(s);
  }

  check_med(bob);
  return(bob);
}


static void print_med(med *m)
     /*
      * Prints out the med pointed to by m.
      *
      * Is recursive (i.e. See print_med(med *m)).
      */
{
  while (m != NULL) {
    printf("{");
    if (m->type == MedAtom) {
      printf("LCN%d", m->ch);
    } 
    else {
      print_med(m->list);
    }
    if (m->rc == -1)
      printf(",RC UCF}");
    else
      printf(",RC %d}", m->rc);
    if (m->next != NULL)
      printf(",");
    m = m->next;
  }
}


static void print_sample(med *m)
     /* 
      * Prints out a sample of what output the code will produce. 
      *
      * Ex.  {{LCN1,RC5},{LCN2,RC2},RC UCF} will produce:
      *
      * 1111122 repeat until closing flag
      */
{
  int i;

  while (m) {
    if (m->type == MedAtom) {
      if (m->rc == UCF) {
        printf("{%d} repeat until closing flag", m->ch);
      }
      else {
        for (i=0;i<m->rc;i++) {
          printf("%d", m->ch);
        }
      }
    }
    else if (m->type == MedList) {
      if (m->rc == UCF) {
        printf("{");
        print_sample(m->list);
        printf("} repeat until closing flag");
      }
      else {
        for (i=0; i<m->rc; i++) {
          print_sample(m->list);
        }
      }
    }
    m = m->next;
  }
}


static int figure_length1(med *m)
     /*
      * Only called on (*m)'s of depth greater than 1 from valid 
      * MultiplexEntryDescriptors.  Therefore we can ignore
      * checking for RC UCF's.  
      */
{
  int sum=0;
  while (m != NULL) {
    if (m->type == MedAtom) {
      sum += m->rc;
    } 
    else {
      sum += m->rc * figure_length1(m->list);
    }
    m = m->next;
  }
  return (sum);
}

static int figure_length(med *m)
     /*
      * Figure out the length of a pattern a med produces.  
      * Do not follow (*next) pointers of (*m).
      */
{
  int sum=0;
  if (m->type == MedAtom) {
    if (m->rc == UCF)
      sum = 1;
    else
      sum = m->rc;
  }
  else {
    if (m->rc == UCF) {
      sum += figure_length1(m->list);
    }
    else {
      sum += m->rc * figure_length1(m->list);
    }
  }
  return(sum);
}


static void write_pattern1(int *pattern, int *offset, med *m)
     /*
      * We won't overwrite the (*pattern) array, because I checked how 
      * big to make it before the call to this function.  
      */ 
{
  int i;
  while (m != NULL) { 
    if (m->type == MedAtom) {
      if (m->rc == UCF) {
        pattern[(*offset)++]=m->ch;
      }
      else {
        for (i=0; i<m->rc; i++)
          pattern[(*offset)++]=m->ch;
      }
    }
    else if (m->type == MedList) {
      if (m->rc == UCF) {
        write_pattern1(pattern, offset, m->list);
      }
      else {
        for (i=0; i<m->rc; i++)
          write_pattern1(pattern, offset, m->list);
      }
    }
    m = m->next;
  }
}


static void write_pattern(int *pattern, int *offset, med *m)
     /*
      * We won't overwrite the (*pattern) array, because I checked how 
      * big to make it before the call to this function.  
      */ 
{
  int i;

  if (m->type == MedAtom) {
    if (m->rc == UCF) {
      pattern[(*offset)++]=m->ch;
    }
    else {
      for (i=0; i<m->rc; i++)
        pattern[(*offset)++]=m->ch;
    }
  }
  else if (m->type == MedList) {
    if (m->rc == UCF) {
      write_pattern1(pattern, offset, m->list);
    }
    else {
      for (i=0; i<m->rc; i++)
        write_pattern1(pattern, offset, m->list);
    }
  }
}



static med_pattern *make_pattern(med *m)
     /*
      * Makes a pattern for putting data in a MUX-PDU payload packet 
      * or removing data from a MUX-PDU payload.
      * 
      * Assumes (*m) is a vaild med structure;
      * 
      * See med.h for struct med_pattern.
      * 
      * Since logical channel numbers can only be between 0 and 65535, 
      * (according to H.223/AnnexA), an unnsigned short int array would 
      * suffice.  If logical channel numbers were between 0 and 255, an 
      * unsigned char would be fine.  I don't really care about storage, 
      * so I'm making them natural ints.
      */
{
  med_pattern *pat; 
  med *save_m;
  int x, y;

  pat = (med_pattern *) malloc(sizeof(med_pattern));
  if (debug)
    printf("make_pattern at %x...............................................\n",pat);
  if (pat == NULL) {
    /* 
     * I hate running out of memory.
     */
    warn("make_pattern", "malloc failed");
  }
  else {
    /*
     * First figure out how much space to allocate for patterns.
     */
    pat->non_repeating_part_length = 0;
    pat->non_repeating_part = NULL;
    pat->repeating_part_length = 0;
    pat->repeating_part = NULL;
    save_m = m;
    while (m != NULL) {
      if (m->rc != UCF)
        pat->non_repeating_part_length += figure_length(m);
      else
        pat->repeating_part_length += figure_length(m);

      m = m->next;
    }
    pat->non_repeating_part = (int *) malloc(pat->non_repeating_part_length * sizeof(int));
    pat->repeating_part = (int *) malloc(pat->repeating_part_length * sizeof(int));

    if (((pat->non_repeating_part == NULL)&&(pat->non_repeating_part_length>0)) ||
        ((pat->repeating_part == NULL)&&(pat->repeating_part_length>0))) {
      warn("make_pattern", "malloc failed");
    }
    else {
      m = save_m;
      x = 0;
      y = 0;
      while (m != NULL) {
        if (m->rc != UCF) {
          write_pattern(pat->non_repeating_part, &x, m);
        } 
        else {
          write_pattern(pat->repeating_part, &y, m);
        }
        m = m->next;
      } 
    }
  }
  return (pat);
}


static void print_pattern(med_pattern *pat)
{
  int i;
  printf("non-repeating part length: %d\n", pat->non_repeating_part_length);
  printf("non-repeating part: ");
  for (i=0; i<pat->non_repeating_part_length; i++) 
    printf("%d", pat->non_repeating_part[i]);
  printf("\n");
  printf("repeating part length: %d\n", pat->repeating_part_length);
  printf("repeating part    : ");
  for (i=0; i<pat->repeating_part_length; i++) 
    printf("%d", pat->repeating_part[i]);
  printf("\n");
}



void add_to_mux_table(mux_table_entry *mt, int *size, char *medstr)
{
  mt[*size].entry = parse_med(medstr);
  mt[*size].pattern = make_pattern(mt[*size].entry);
  
  if (debug)
    print_pattern(mt[*size].pattern);

  (*size)++;
}

---