[thirdparty/binutils-gdb.git] / sim / ppc / table.c

/*  This file is part of the program psim.

    Copyright (C) 1994-1995, Andrew Cagney <cagney@highland.com.au>

    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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
    */


#include <sys/types.h>
#include <sys/stat.h>
#include <stdio.h>
#include <fcntl.h>
#include <ctype.h>

#include "config.h"
#include "misc.h"
#include "lf.h"
#include "table.h"

#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif

#ifdef HAVE_STDLIB_H
#include <stdlib.h>
#endif

struct _table {
  size_t size;
  char *buffer;
  char *pos;
  int line_nr;
  int nr_fields;
  int nr_model_fields;
  char *file_name;
};

extern table *
table_open(char *file_name,
	   int nr_fields,
	   int nr_model_fields)
{
  int fd;
  struct stat stat_buf;
  table *file;

  /* create a file descriptor */
  file = ZALLOC(table);
  ASSERT(file != NULL);
  file->nr_fields = nr_fields;
  file->nr_model_fields = nr_model_fields;

  /* save the file name */
  file->file_name = (char*)zalloc(strlen(file_name) + 1);
  ASSERT(file->file_name != NULL);
  strcpy(file->file_name, file_name);

  /* open the file */
  fd = open(file->file_name, O_RDONLY, 0);
  ASSERT(fd >= 0);

  /* determine the size */
  if (fstat(fd, &stat_buf) < 0) {
    perror("table_open.fstat");
    exit(1);
  }
  file->size = stat_buf.st_size;

  /* allocate this much memory */
  file->buffer = (char*)zalloc(file->size+1);
  if(file->buffer == NULL) {
    perror("table_open.calloc.file->size+1");
    exit(1);
  }
  file->pos = file->buffer;

  /* read it in */
  if (read(fd, file->buffer, file->size) < file->size) {
    perror("table_open.read");
    exit(1);
  }
  file->buffer[file->size] = '\0';

  /* done */
  close(fd);
  return file;
}


extern table_entry *
table_entry_read(table *file)
{
  int field;
  table_entry *entry;

  /* skip comments/blanks */
  while(1) {
    /* leading white space */
    while (*file->pos != '\0'
	   && *file->pos != '\n'
	   && isspace(*file->pos))
      file->pos++;
    /* comment */
    if (*file->pos == '#') {
      do {
	file->pos++;
      } while (*file->pos != '\0' && *file->pos != '\n');
    }
    /* end of line? */
    if (*file->pos == '\n') {
      file->pos++;
      file->line_nr++;
    }
    else
      break;
  }
  if (*file->pos == '\0')
    return NULL;

  /* create this new entry */
  entry = (table_entry*)zalloc(sizeof(table_entry)
			       + (file->nr_fields + 1) * sizeof(char*));
  ASSERT(entry != NULL);
  entry->file_name = file->file_name;
  entry->nr_fields = file->nr_fields;

  /* break the line into its colon delimitered fields */
  for (field = 0; field < file->nr_fields-1; field++) {
    entry->fields[field] = file->pos;
    while(*file->pos && *file->pos != ':' && *file->pos != '\n')
      file->pos++;
    if (*file->pos == ':') {
      *file->pos = '\0';
      file->pos++;
    }
  }

  /* any trailing stuff not the last field */
  ASSERT(field == file->nr_fields-1);
  entry->fields[field] = file->pos;
  while (*file->pos && *file->pos != '\n') {
    file->pos++;
  }
  if (*file->pos == '\n') {
    *file->pos = '\0';
    file->pos++;
  }
  file->line_nr++;
  entry->line_nr = file->line_nr;

  /* if following lines begin with a star, add them to the model
     section.  */
  while ((file->nr_model_fields > 0) && (*file->pos == '*')) {
    table_model_entry *model = (table_model_entry*)zalloc(sizeof(table_model_entry)
							  + (file->nr_model_fields + 1) * sizeof(char*));
    if (entry->model_last)
      entry->model_last->next = model;
    else
      entry->model_first = model;
    entry->model_last = model;

    /* break the line into its colon delimitered fields */
    file->pos++;
    for (field = 0; field < file->nr_model_fields-1; field++) {
      model->fields[field] = file->pos;
      while(*file->pos && *file->pos != ':' && *file->pos != '\n')
	file->pos++;
      if (*file->pos == ':') {
	*file->pos = '\0';
	file->pos++;
      }
    }

    /* any trailing stuff not the last field */
    ASSERT(field == file->nr_model_fields-1);
    model->fields[field] = file->pos;
    while (*file->pos && *file->pos != '\n') {
      file->pos++;
    }
    if (*file->pos == '\n') {
      *file->pos = '\0';
      file->pos++;
    }

    file->line_nr++;
    model->line_nr = file->line_nr;
  }

  /* if following lines are tab indented, put in the annex */
  if (*file->pos == '\t') {
    entry->annex = file->pos;
    do {
      do {
	file->pos++;
      } while (*file->pos != '\0' && *file->pos != '\n');
      if (*file->pos == '\n') {
	char *save_pos = ++file->pos;
	int extra_lines = 0;
	file->line_nr++;
	/* Allow tab indented to have blank lines */
	while (*save_pos == '\n') {
	  save_pos++;
	  extra_lines++;
	}
	if (*save_pos == '\t') {
	  file->pos = save_pos;
	  file->line_nr += extra_lines;
	}
      }
    } while (*file->pos != '\0' && *file->pos == '\t');
    if (file->pos[-1] == '\n')
      file->pos[-1] = '\0';
  }
  else
    entry->annex = NULL;

  /* return it */
  return entry;

}


extern void
dump_table_entry(table_entry *entry,
		 int indent)
{
  printf("(table_entry*)%p\n", entry);

  if (entry != NULL) {
    int field;
    char sep;

    sep = ' ';
    dumpf(indent, "(fields");
    for (field = 0; field < entry->nr_fields; field++) {
      printf("%c%s", sep, entry->fields[field]);
      sep = ':';
    }
    printf(")\n");

    dumpf(indent, "(line_nr %d)\n", entry->line_nr);

    dumpf(indent, "(file_name %s)\n", entry->file_name);

    dumpf(indent, "(annex\n%s\n", entry->annex);
    dumpf(indent, " )\n");

  }
}


extern void
table_entry_lf_c_line_nr(lf *file,
			 table_entry *entry)
{
  lf_print_c_line_nr(file, entry->line_nr, entry->file_name);
}
Commit	Line	Data
c494cadd MM	1	/* This file is part of the program psim.
	2
	3	Copyright (C) 1994-1995, Andrew Cagney <cagney@highland.com.au>
	4
	5	This program is free software; you can redistribute it and/or modify
	6	it under the terms of the GNU General Public License as published by
	7	the Free Software Foundation; either version 2 of the License, or
	8	(at your option) any later version.
	9
	10	This program is distributed in the hope that it will be useful,
	11	but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	GNU General Public License for more details.
	14
	15	You should have received a copy of the GNU General Public License
	16	along with this program; if not, write to the Free Software
	17	Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
	18
	19	*/
	20
	21
	22	#include <sys/types.h>
	23	#include <sys/stat.h>
	24	#include <stdio.h>
	25	#include <fcntl.h>
	26	#include <ctype.h>
	27
73c4941b	28	#include "config.h"
c494cadd MM	29	#include "misc.h"
	30	#include "lf.h"
	31	#include "table.h"
	32
	33	#ifdef HAVE_UNISTD_H
	34	#include <unistd.h>
	35	#endif
	36
	37	#ifdef HAVE_STDLIB_H
	38	#include <stdlib.h>
	39	#endif
	40
	41	struct _table {
	42	size_t size;
	43	char *buffer;
	44	char *pos;
	45	int line_nr;
	46	int nr_fields;
845ff5a4	47	int nr_model_fields;
c494cadd MM	48	char *file_name;
	49	};
	50
	51	extern table *
	52	table_open(char *file_name,
845ff5a4 MM	53	int nr_fields,
845ff5a4 MM	54	int nr_model_fields)
c494cadd MM	55	{
	56	int fd;
	57	struct stat stat_buf;
	58	table *file;
	59
	60	/* create a file descriptor */
	61	file = ZALLOC(table);
	62	ASSERT(file != NULL);
	63	file->nr_fields = nr_fields;
845ff5a4	64	file->nr_model_fields = nr_model_fields;
c494cadd MM	65
	66	/* save the file name */
	67	file->file_name = (char*)zalloc(strlen(file_name) + 1);
	68	ASSERT(file->file_name != NULL);
	69	strcpy(file->file_name, file_name);
	70
	71	/* open the file */
	72	fd = open(file->file_name, O_RDONLY, 0);
	73	ASSERT(fd >= 0);
	74
	75	/* determine the size */
	76	if (fstat(fd, &stat_buf) < 0) {
	77	perror("table_open.fstat");
	78	exit(1);
	79	}
	80	file->size = stat_buf.st_size;
	81
	82	/* allocate this much memory */
	83	file->buffer = (char*)zalloc(file->size+1);
	84	if(file->buffer == NULL) {
	85	perror("table_open.calloc.file->size+1");
	86	exit(1);
	87	}
	88	file->pos = file->buffer;
	89
	90	/* read it in */
	91	if (read(fd, file->buffer, file->size) < file->size) {
	92	perror("table_open.read");
	93	exit(1);
	94	}
	95	file->buffer[file->size] = '\0';
	96
	97	/* done */
	98	close(fd);
	99	return file;
	100	}
	101
	102
	103	extern table_entry *
	104	table_entry_read(table *file)
	105	{
	106	int field;
	107	table_entry *entry;
	108
	109	/* skip comments/blanks */
	110	while(1) {
	111	/* leading white space */
	112	while (*file->pos != '\0'
	113	&& *file->pos != '\n'
	114	&& isspace(*file->pos))
	115	file->pos++;
	116	/* comment */
	117	if (*file->pos == '#') {
	118	do {
	119	file->pos++;
	120	} while (file->pos != '\0' && file->pos != '\n');
	121	}
	122	/* end of line? */
	123	if (*file->pos == '\n') {
	124	file->pos++;
	125	file->line_nr++;
	126	}
	127	else
	128	break;
129	}
130	if (*file->pos == '\0')
131	return NULL;
132
133	/* create this new entry */
134	entry = (table_entry*)zalloc(sizeof(table_entry)
135	+ (file->nr_fields + 1) * sizeof(char*));
136	ASSERT(entry != NULL);
137	entry->file_name = file->file_name;
138	entry->nr_fields = file->nr_fields;
139
140	/* break the line into its colon delimitered fields */
141	for (field = 0; field < file->nr_fields-1; field++) {
142	entry->fields[field] = file->pos;
143	while(file->pos && file->pos != ':' && *file->pos != '\n')
144	file->pos++;
145	if (*file->pos == ':') {
146	*file->pos = '\0';
147	file->pos++;
148	}
149	}
150
151	/* any trailing stuff not the last field */
152	ASSERT(field == file->nr_fields-1);
153	entry->fields[field] = file->pos;
154	while (file->pos && file->pos != '\n') {
155	file->pos++;
156	}
157	if (*file->pos == '\n') {
158	*file->pos = '\0';
159	file->pos++;
160	}
161	file->line_nr++;
162	entry->line_nr = file->line_nr;
163
845ff5a4 MM	164	/* if following lines begin with a star, add them to the model
	165	section. */
	166	while ((file->nr_model_fields > 0) && (file->pos == '')) {
	167	table_model_entry model = (table_model_entry)zalloc(sizeof(table_model_entry)
	168	+ (file->nr_model_fields + 1) * sizeof(char*));
	169	if (entry->model_last)
	170	entry->model_last->next = model;
	171	else
	172	entry->model_first = model;
	173	entry->model_last = model;
	174
	175	/* break the line into its colon delimitered fields */
	176	file->pos++;
	177	for (field = 0; field < file->nr_model_fields-1; field++) {
	178	model->fields[field] = file->pos;
	179	while(file->pos && file->pos != ':' && *file->pos != '\n')
	180	file->pos++;
	181	if (*file->pos == ':') {
	182	*file->pos = '\0';
	183	file->pos++;
	184	}
	185	}
	186
	187	/* any trailing stuff not the last field */
	188	ASSERT(field == file->nr_model_fields-1);
	189	model->fields[field] = file->pos;
	190	while (file->pos && file->pos != '\n') {
	191	file->pos++;
	192	}
	193	if (*file->pos == '\n') {
	194	*file->pos = '\0';
	195	file->pos++;
	196	}
	197
	198	file->line_nr++;
	199	model->line_nr = file->line_nr;
	200	}
	201
	202	/* if following lines are tab indented, put in the annex */
c494cadd MM	203	if (*file->pos == '\t') {
	204	entry->annex = file->pos;
	205	do {
	206	do {
	207	file->pos++;
	208	} while (file->pos != '\0' && file->pos != '\n');
	209	if (*file->pos == '\n') {
845ff5a4 MM	210	char *save_pos = ++file->pos;
845ff5a4 MM	211	int extra_lines = 0;
c494cadd	212	file->line_nr++;
845ff5a4 MM	213	/* Allow tab indented to have blank lines */
	214	while (*save_pos == '\n') {
	215	save_pos++;
	216	extra_lines++;
	217	}
	218	if (*save_pos == '\t') {
	219	file->pos = save_pos;
	220	file->line_nr += extra_lines;
	221	}
c494cadd MM	222	}
	223	} while (file->pos != '\0' && file->pos == '\t');
	224	if (file->pos[-1] == '\n')
	225	file->pos[-1] = '\0';
	226	}
	227	else
	228	entry->annex = NULL;
	229
	230	/* return it */
	231	return entry;
	232
	233	}
	234
	235
	236	extern void
	237	dump_table_entry(table_entry *entry,
	238	int indent)
	239	{
	240	printf("(table_entry*)%p\n", entry);
	241
	242	if (entry != NULL) {
	243	int field;
	244	char sep;
	245
	246	sep = ' ';
	247	dumpf(indent, "(fields");
	248	for (field = 0; field < entry->nr_fields; field++) {
	249	printf("%c%s", sep, entry->fields[field]);
	250	sep = ':';
	251	}
	252	printf(")\n");
	253
	254	dumpf(indent, "(line_nr %d)\n", entry->line_nr);
	255
	256	dumpf(indent, "(file_name %s)\n", entry->file_name);
	257
	258	dumpf(indent, "(annex\n%s\n", entry->annex);
	259	dumpf(indent, " )\n");
	260
	261	}
	262	}
	263
	264
	265	extern void
	266	table_entry_lf_c_line_nr(lf *file,
	267	table_entry *entry)
	268	{
	269	lf_print_c_line_nr(file, entry->line_nr, entry->file_name);
	270	}
	271
	272