Subversion Repositories adv_debug_sys

/* bsdl_parse.c - BSDL parser for the advanced JTAG bridge
   Copyright(C) 2008 - 2010 Nathan Yawn
 
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 
*/
 
#include <stdio.h>
#include <string.h>
#include <ctype.h>  // isspace(), etc.
#include <stdlib.h>  // malloc(), strtoul(), etc.
#include "bsdl.h"  // has constants
 
 
#define debug(...) //fprintf(stderr, __VA_ARGS__ )
 
char * strtoupper(char *str);
int get_line(char *filedata, int startpos, char **linedata, int filesize);
char * strchr_s(char *str, char *chars);
void parse_opcodes(char *cmdbuf, uint32_t *debug_cmd, uint32_t *user1_cmd, uint32_t *idcode_cmd);
 
// We assume that no value will be more than 128 chars
char tmpbuf[128];
 
 
 /////////////////////////////////////////////////////////////////
 // API call: extract desired info from 1 BSDL fise
 
bsdlinfo *parse_extract_values(char *bsdlfilename)
{
  FILE *fd;
  int filesize;
  bsdlinfo *ret;
  char *filedata;
  char *linedata;
  char *token;
  char *last;
  char *cmdbuf;
  int filepos = 0;
  int i,j;
  char done,valid,opens;
 
  int IR_size = -1;
  uint8_t found_IR_size = 0;
  uint32_t debug_cmd = TAP_CMD_INVALID;
  uint32_t user1_cmd = TAP_CMD_INVALID;
  uint32_t idcode_cmd = TAP_CMD_INVALID;
  uint8_t found_cmds = 0;
  uint32_t idcode = 0;
  uint32_t idcode_mask = 0xFFFFFFFF;  // 'X' is a valid char in an IDCODE, set 0's here for X's.
  uint8_t found_idcode = 0;
  char *entityname = NULL;
 
  // Open the file
  fd = fopen(bsdlfilename, "r");
  if(fd == NULL) {
    printf("ERROR:  failed to open BSDL file %s\n", bsdlfilename);
    return NULL;
  }
 
  fseek(fd, 0, SEEK_END);
  filesize = ftell(fd);
  fseek(fd, 0, SEEK_SET);
 
  filedata = (char *) malloc(filesize);
  if(filedata == NULL) {
    printf("ERROR: failed to allocate memory for BSDL file %s\n", bsdlfilename);
    return NULL;
  }
 
  if(fread(filedata, 1, filesize, fd) < filesize) {  // 1 long read will be faster than many short ones
    printf("Warning: failed to read entire BSDL file %s\n", bsdlfilename);
  }
 
  fclose(fd);
 
 
  // while there's more data and not all values have been found
  while((filepos < filesize) && (!found_IR_size || !found_cmds || !found_idcode))
    {
      // Get a line.  Replace any "--" with a \0 char
      filepos = get_line(filedata, filepos, &linedata, filesize);
 
      // look for each value
      token = strtok_r(linedata, " \t", &last);
      if(token == NULL) {
	printf("ERROR: End of file reached before END statement is BSDL file \'%s\'\n", bsdlfilename);
	break;
      }
 
      if(!strcmp(strtoupper(token), "ENTITY")) {
	// Parse an entity line
	token = strtok_r(NULL, " \t", &last);
	if(token != NULL) {
	  entityname = strdup(token);
	  if(entityname != NULL) 
	    {
	      debug("Found entity \'%s\'\n", entityname);
	    }
	} else {
	  printf("Parse error near ENTITY token in file %s\n", bsdlfilename);
	}
      }
      else if(!strcmp(strtoupper(token), "CONSTANT")) {
	// Parse a constant declaration...we ignore them, just get lines until we find a ';' char
	// assume nothing else useful comes on the line after the ';'
	// Slightly awkward, since we have to search the rest of the line after the strtok, then possible
	// new lines as well.
	token = strtok_r(NULL, " \t", &last);  // debug...don't worry about error, token only used in printf
	debug("Ignoring constant \'%s\'\n", token);  // debug
	while(strchr(last, ';') == NULL) { 
	  filepos = get_line(filedata, filepos, &last, filesize); 
	}
      }
      else if(!strcmp(strtoupper(token), "GENERIC")) {
	// Parse a generic declaration...we ignore them, just get lines until we find a ';' char
	// assume nothing else useful comes on the line after the ';'
	// Slightly awkward, since we have to search the rest of the line after the strtok, then possible
	// new lines as well.
	token = strtok_r(NULL, " \t", &last);  // debug...don't worry about error, token only used in printf
	debug("Ignoring generic \'%s\'\n", token);  // debug
	while(strchr(last, ';') == NULL) { 
	  filepos = get_line(filedata, filepos, &last, filesize); 
	}
      }
      else if(!strcmp(strtoupper(token), "USE")) {
	// Parse a 'use' declaration...we ignore them, just get lines until we find a ';' char
	// assume nothing else useful comes on the line after the ';'
	// Note that there may be no space after the token, so add ';' to the tokenizing list in the debug bits.
	// Slightly awkward, since we have to search the rest of the line after the strtok, then possible
	// new lines as well.
	token = strtok_r(NULL, " \t;", &last);  // debug ...don't worry about error, token only used in printf
	debug("Ignoring use \'%s\'\n", token);  // debug
	while(strchr(last, ';') == NULL) { 
	  filepos = get_line(filedata, filepos, &last, filesize); 
	}
      }
      else if(!strcmp(strtoupper(token), "END")) {
	// We're done, whether we've found what we want or not.  Eject eject eject...
	debug("Found END token, stopping parser\n");
	break;
      }
      else if(!strcmp(strtoupper(token), "PORT")) {
	// Parse a port list.  Find a '(', find a ')', find a ';'.
	// Note that "()" pairs may occur in between.
	// 'last' must be set in the first two strchr() calls so that the next strchr() call will
	// begin parsing after the previous char position.  Otherwise, e.g. a ';' before the ')' but on the same
	// line would (incorrectly) satisfy the search.
	while((last = strchr(last, '(')) == NULL) { 
	  filepos = get_line(filedata, filepos, &last, filesize); 
	}
	opens = 1;
	last++;  // don't leave 'last' pointing at the '(' char, since we're looking for another
 
	do {
	  while((last = strchr_s(last, "()")) == NULL) { 
	    filepos = get_line(filedata, filepos, &last, filesize); // *** abort if new line is empty
	  }
	  if(*last == '(') opens++;
	  else if(*last == ')') opens--;
	  last++;  // don't leave last pointing at the same "()" char, since we're looking for another
	} while(opens);
 
 
	while(strchr(last, ';') == NULL) { 
	  filepos = get_line(filedata, filepos, &last, filesize); 
	}
	debug("Ignored port statement\n");
      }
      else if(!strcmp(strtoupper(token), "ATTRIBUTE")) {
	// Parse an attribute
	token = strtok_r(NULL, " \t", &last);  // *** check for error
	if(!strcmp(strtoupper(token), "INSTRUCTION_LENGTH")) {
	  // Find ':', then "entity", then "is", then take anything before the ';' as the value
	  while((last = strchr(last, ':')) == NULL) { 
	    filepos = get_line(filedata, filepos, &last, filesize); // *** check last actually has data?
	  }
	  while((last = strstr(last, "entity")) == NULL) { // don't do strtoupper() here, that would do the entire line
	    filepos = get_line(filedata, filepos, &last, filesize); // *** check last actually has data?
	  }
	  while((last = strstr(last, "is")) == NULL) { 
	    filepos = get_line(filedata, filepos, &last, filesize); // *** check last actually has data?
	  }
 
	  // scan until the end of the line looking for data
	  j = 0;
	  done = 0;
	  while(*last != '\0') {
	    if(isdigit(*last)) tmpbuf[j++] = *last;
	    else if(*last == ';') { done = 1; break;}
	    last++;
	  }
	  // May need to go to additional lines
	  while(!done) {
	    filepos = get_line(filedata, filepos, &linedata, filesize);  // *** break if linedata has no data
	    while(*linedata != '\0') {
	      if(isdigit(*linedata)) tmpbuf[j++] = *linedata;
	      else if(*linedata == ';') { done = 1; break;}
	      linedata++;
	    }
	  }
 
	  tmpbuf[j] = '\0';
	  IR_size = strtoul(tmpbuf, NULL, 0);
	  found_IR_size = 1;
	  debug("Found IR size %i (%s)\n", IR_size, tmpbuf);
	}  // end if INSTRUCTION_LENGTH
 
	else if(!strcmp(strtoupper(token), "INSTRUCTION_OPCODE")) {
	  // Find ": entity is"
	  while((last = strchr(last, ':')) == NULL) { 
	    filepos = get_line(filedata, filepos, &last, filesize); // *** check last actually has data?
	  }
	  while((last = strstr(last, "entity")) == NULL) { // don't do strtoupper() here, that would do the entire line
	    filepos = get_line(filedata, filepos, &last, filesize); // *** check last actually has data?
	  }
	  while((last = strstr(last, "is")) == NULL) { 
	    filepos = get_line(filedata, filepos, &last, filesize); // *** check last actually has data?
	  }
 
	  // We're going to copy the entire attribute (all commands) into a temp. buffer.  We need a big enough buffer,
	  // and we can't just scan for ';' to find out because there's a '\0' at the end of this line.
	  // But, it can't be bigger than the entire rest of the file, so...
	  cmdbuf = (char *) malloc(filesize-filepos);
	  debug("Malloc'd %i bytes for INSTRUCTION_OPCODE\n", filesize-filepos);
 
	  // Parse until ';', and grab everything between each pair of "" found
	  // Note that 'last' still points at "is"
	  j = 0;
	  done = 0;
	  valid = 0;
	  while(*last != '\0') {
	    if(*last == ';') { done = 1; break;}  // Put this first in case of badly formed BSDL files
	    else if(valid && (*last != '\"')) cmdbuf[j++] = *last;
	    else if(*last == '\"') valid = !valid;
	    last++;
	  }
	  // May need to go to additional lines
	  while(!done) {
	    filepos = get_line(filedata, filepos, &linedata, filesize); // *** break if linedata has no data
	    while(*linedata != '\0') {
	      if(valid && (*linedata != '\"')) cmdbuf[j++] = *linedata;
	      else if(*linedata == '\"') valid = !valid;
	      else if(*linedata == ';') { done = 1; break;}
	      linedata++;
	    }
	  }
	  cmdbuf[j] = '\0';
	  debug("Finished copying INSTRUCTION_OPCODE, copied %i bytes", j+1);
 
	  // Parse the opcodes attribute.  This is an exercise unto itself, so do it in another function.
	  parse_opcodes(cmdbuf, &debug_cmd, &user1_cmd, &idcode_cmd);
	  found_cmds = 1;
	  free(cmdbuf);
 
	}   // end if INSTRUCTION_OPCODE
 
	else if(!strcmp(strtoupper(token), "IDCODE_REGISTER")) {
	  // Find : entity is
	  while((last = strchr(last, ':')) == NULL) { 
	    filepos = get_line(filedata, filepos, &last, filesize); // *** check last actually has data?
	  }
	  while((last = strstr(last, "entity")) == NULL) { // don't do strtoupper() here, that would do the entire line
	    filepos = get_line(filedata, filepos, &last, filesize); // *** check last actually has data?
	  }
	  while((last = strstr(last, "is")) == NULL) { 
	    filepos = get_line(filedata, filepos, &last, filesize); // *** check last actually has data?
	  }
 
	  // Parse until ';', and grab everything between each pair of "" found
	  // Note that 'last' still points at "is"
	  j = 0;
	  done = 0;
	  valid = 0;
	  while(*last != '\0') {
	    if(*last == ';') { done = 1; break;}  // Put this first in case of badly formed BSDL files
	    else if(valid && (*last != '\"')) tmpbuf[j++] = *last;
	    else if(*last == '\"') valid = !valid;
	    last++;
	  }
	  // May need to go to additional lines
	  while(!done) {
	    filepos = get_line(filedata, filepos, &linedata, filesize); // *** break if linedata has no data
	    while(*linedata != '\0') {
	      if(valid && (*linedata != '\"')) tmpbuf[j++] = *linedata;
	      else if(*linedata == '\"') valid = !valid;
	      else if(*linedata == ';') { done = 1; break;}
	      linedata++;
	    }
	  }
	  tmpbuf[j] = '\0';
 
	  // Parse the tmpbuf
	  if(j != 32) printf("Warning:  found %i chars (expected 32) while getting IDCODE in BSDL file %s.\n", j, bsdlfilename);  // Sanity check
	  debug("Got IDCODE string \'%s\'\n", tmpbuf);
	  for(i = 0; i < j; i++) {
	    if(tmpbuf[i] == '1') idcode |= 0x1<<(31-i);
	    else if(toupper(tmpbuf[i]) == 'X') idcode_mask &= ~(0x1<<(31-i)); 
	  }
	  debug("Found IDCODE 0x%08X (%s), mask is 0x%08X\n", idcode, tmpbuf, idcode_mask);
	  found_idcode = 1;
 
	}  // end if IDCODE_REGISTER
 
	else {
	  debug("Ignoring attribute \'%s\'\n", token);
	  // Consume chars until ';' found
	  while(strchr(last, ';') == NULL) { 
	    filepos = get_line(filedata, filepos, &last, filesize); 
	  }
	}
      }
      else {
	debug("Unknown token \'%s\' found in BSDL file %s\n", token, bsdlfilename);
      }
    }
 
  free(filedata);
 
  // Put the data in a struct for return and storage
  ret = (bsdlinfo *) malloc(sizeof(bsdlinfo));
  if(ret == NULL) {
       printf("Error: out of memory, unable to store BSDL info for file %s\n", bsdlfilename);
       return NULL;
  }
 
  ret->name = entityname;  // this was malloc'd, so it's persistant, this is safe
  ret->idcode = idcode;
  ret->idcode_mask = idcode_mask;
  ret->IR_size = IR_size;
  ret->cmd_debug = debug_cmd;
  ret->cmd_user1 = user1_cmd;
  ret->cmd_idcode = idcode_cmd;
  ret->next = NULL;
 
  return ret;
}
 
 
 
//////////////////////////////////////////////////////////////////////////////////////////////
// Local / helper functions
 
 
// Returns 1 line from a complete file buffer pointed to by *filedata.  Removes leading
// whitespace, ignores comment lines, removes trailing comments (comments denoted by "--")
// startpos: index in filedata[] to start looking for a new line.
// linedata:  set to point to the first char of the new line.
// filesize:  used so we don't go past the end of filedata[]
// The return value is the first index after the returned line.  This may be 1 past the end of the buffer.
int get_line(char *filedata, int startpos, char **linedata, int filesize)
{
  int lineidx = startpos;
  unsigned char loop;
  char *commentptr;
 
  do {
    loop = 0;
    while(isspace(filedata[lineidx]) && (lineidx < filesize)) lineidx++;  // burn leading whitespace chars
 
    if(lineidx >= (filesize-1)) { // We look at the data at lineidx and lineidx+1...don't look at invalid offsets. 
      lineidx = filesize-1; 
      break; 
    }
 
    if((filedata[lineidx] == '-') && (filedata[lineidx+1] == '-'))
      {  // then this is a full-line comment, with no useful data
	while(((filedata[lineidx] != '\n') && (filedata[lineidx] != '\r')) && (lineidx < filesize))
	  lineidx++;  // burn comment line up to CR/LF
	loop = 1;
      }
  } while(loop);
 
  // Set the line pointer
  *linedata = &filedata[lineidx];
 
  // Put a NULL char at the newline
  while(!iscntrl(filedata[lineidx]) && (lineidx < filesize)) lineidx++;
  if(lineidx >= filesize) { // Don't write past the end of the array.
    lineidx = filesize-1; 
  }
  filedata[lineidx] = '\0';
 
  // Put a NULL at the first "--" string, if any
  commentptr = strstr(*linedata, "--");
  if(commentptr != NULL) *commentptr = '\0';
 
  return lineidx+1;
}
 
 
// In-place string capitalizer
char * strtoupper(char *str)
{
  int i = 0;
 
  while(str[i] != '\0') { 
    str[i] = toupper(str[i]);
    i++;
  }
 
  return str;
}
 
// Searches a string 'str' for the first occurance of any 
// character in the string 'chars'.  Returns a pointer to
// the char in 'str' if one is found, returns NULL if
// none of the chars in 'chars' are present in 'str'.
char * strchr_s(char *str, char *chars)
{
  int slen = strlen(chars);
  char *ptr = str;
  int i;
 
  while(*ptr != '\0') {
    for(i = 0; i < slen; i++) {
      if(*ptr == chars[i]) 
	return ptr;
    }
    ptr++;
  }
 
  return NULL;
}
 
 
// Parses a string with command name / opcode pairs of the format
// EXTEST    (1111000000),SAMPLE    (1111000001), [...]
// There may or may not be a space between the name and the open paren.
// We do not assume a comma after the last close paren.
#define TARGET_DEBUG  1
#define TARGET_USER1  2
#define TARGET_IDCODE 3
void parse_opcodes(char *cmdbuf, uint32_t *debug_cmd, uint32_t *user1_cmd, uint32_t *idcode_cmd)
{
  char *saveptr = NULL;
  char *cmd;
  char *token;
  char *saveptr2;
  int target;
  int opcode;
 
  cmd = strtok_r(cmdbuf, ",", &saveptr);
  while(cmd != NULL)
    {
      // 'cmd' should now have one pair in the form "EXTEST    (1111000000)"
      target = 0;
      token = strtok_r(cmd, " \t(", &saveptr2);
      if(!strcmp(strtoupper(token), "DEBUG")) {
	target = TARGET_DEBUG;
	debug("Found DEBUG opcode: ");
      }
      else if(!strcmp(strtoupper(token), "USER1")) {
	target = TARGET_USER1;
	debug("Found USER1 opcode:");
      }
      else if(!strcmp(strtoupper(token), "IDCODE")) {
	target = TARGET_IDCODE;
	debug("Found IDCODE opcode: ");
      }
 
      if(target) {  // don't parse opcode number unless necessary
	token = strtok_r(NULL, " \t()", &saveptr2);
	if(token != NULL) {
	  opcode = strtoul(token, NULL, 2); // *** Test for errors
	  debug("0x%X (%s)\n", opcode, token);
 
	  if(target == TARGET_DEBUG) *debug_cmd = opcode;
	  else if(target == TARGET_USER1) *user1_cmd = opcode;
	  else if(target == TARGET_IDCODE) *idcode_cmd = opcode;
	}
	else {
	  printf("Error:  failed to find opcode value after identifier.\n");
	}
      }
 
      cmd = strtok_r(NULL,  ",", &saveptr);
    }
 
 
}