[deliverable/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

typedef struct _open_table open_table;
struct _open_table {
  size_t size;
  char *buffer;
  char *pos;
  int line_nr;
  int nr_fields;
  int nr_model_fields;
  char *file_name;
  open_table *parent;
  table *root;
};
struct _table {
  open_table *current;
};

void
table_push (table *root,
	    table_include *includes,
	    const char *file_name,
	    int nr_fields,
	    int nr_model_fields)

{
  int fd;
  struct stat stat_buf;
  open_table *file;
  table_include dummy;
  table_include *include = &dummy;
  int nr;

  /* dummy up a search of this directory */
  dummy.next = includes;
  dummy.dir = "";

  /* create a file descriptor */
  file = ZALLOC (open_table);
  ASSERT(file != NULL);
  file->nr_fields = nr_fields;
  file->nr_model_fields = nr_model_fields;
  file->root = root;
  file->parent = root->current;
  root->current = file;
  
  while (1)
    {
      /* save the file name */
      char *dup_name = NZALLOC (char, strlen (include->dir) + strlen (file_name) + 2);
      if (dup_name == NULL)
	{
	  perror (file_name);
	  exit (1);
	}
      if (include->dir[0] != '\0')
	{
	  strcat (dup_name, include->dir);
	  strcat (dup_name, "/");
	}
      strcat (dup_name, file_name);
      file->file_name = dup_name;
      /* open the file */
      fd = open (dup_name, O_RDONLY, 0);
      if (fd >= 0)
	break;
      /* zfree (dup_name); */
      if (include->next == NULL)
	{
	  error ("Problem opening file `%s'\n", file_name);
	  perror (file_name);
	  exit (1);
	}
      include = include->next;
  }

  /* 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 */
#ifdef __CYGWIN32__
  if ((file->size) && ((nr = read(fd, file->buffer, file->size)) <= 0)) {
#else
  if ((nr = read(fd, file->buffer, file->size)) < file->size) {
#endif
    perror("table_open.read");
    exit(1);
  }
  file->size = nr;
  file->buffer[file->size] = '\0';

  /* done */
  close(fd);
}

extern table *
table_open(const char *file_name,
	   int nr_fields,
	   int nr_model_fields)
{
  table *root;

  /* create a file descriptor */
  root = ZALLOC (table);
  if (root == NULL)
    {
      perror (file_name);
      exit (1);
    }

  table_push (root, NULL, file_name, nr_fields, nr_model_fields);
  return root;
}

extern table_entry *
table_entry_read(table *root)
{
  open_table *file = root->current;
  int field;
  table_entry *entry;

  /* skip comments/blanks */
  while(1) {
    /* end-of-file? */
    while (*file->pos == '\0')
      {
        if (file->parent != NULL)
          {
            file = file->parent;
            root->current = file;
          }
        else
          return NULL;
      }
    /* 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;
  }

  /* 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++;

  /* 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;
  }

  entry->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_print_cpp_line_nr(lf *file,
			      table_entry *entry)
{
  lf_print__external_reference(file, entry->line_nr, entry->file_name);
}
Commit	Line	Data
c906108c SS	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
	28	#include "config.h"
	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
43c4bab0 MG	41	typedef struct _open_table open_table;
43c4bab0 MG	42	struct _open_table {
c906108c SS	43	size_t size;
	44	char *buffer;
	45	char *pos;
	46	int line_nr;
	47	int nr_fields;
	48	int nr_model_fields;
	49	char *file_name;
43c4bab0 MG	50	open_table *parent;
	51	table *root;
	52	};
	53	struct _table {
	54	open_table *current;
c906108c SS	55	};
c906108c SS	56
43c4bab0 MG	57	void
	58	table_push (table *root,
	59	table_include *includes,
	60	const char *file_name,
	61	int nr_fields,
	62	int nr_model_fields)
	63
c906108c SS	64	{
	65	int fd;
	66	struct stat stat_buf;
43c4bab0 MG	67	open_table *file;
	68	table_include dummy;
	69	table_include *include = &dummy;
c906108c SS	70	int nr;
c906108c SS	71
43c4bab0 MG	72	/* dummy up a search of this directory */
	73	dummy.next = includes;
	74	dummy.dir = "";
	75
c906108c	76	/* create a file descriptor */
43c4bab0	77	file = ZALLOC (open_table);
c906108c SS	78	ASSERT(file != NULL);
	79	file->nr_fields = nr_fields;
	80	file->nr_model_fields = nr_model_fields;
43c4bab0 MG	81	file->root = root;
	82	file->parent = root->current;
	83	root->current = file;
	84
	85	while (1)
	86	{
	87	/* save the file name */
	88	char *dup_name = NZALLOC (char, strlen (include->dir) + strlen (file_name) + 2);
	89	if (dup_name == NULL)
	90	{
	91	perror (file_name);
	92	exit (1);
	93	}
	94	if (include->dir[0] != '\0')
	95	{
	96	strcat (dup_name, include->dir);
	97	strcat (dup_name, "/");
	98	}
	99	strcat (dup_name, file_name);
	100	file->file_name = dup_name;
	101	/* open the file */
	102	fd = open (dup_name, O_RDONLY, 0);
	103	if (fd >= 0)
	104	break;
	105	/* zfree (dup_name); */
	106	if (include->next == NULL)
	107	{
	108	error ("Problem opening file `%s'\n", file_name);
	109	perror (file_name);
	110	exit (1);
	111	}
	112	include = include->next;
	113	}
c906108c SS	114
	115	/* determine the size */
	116	if (fstat(fd, &stat_buf) < 0) {
	117	perror("table_open.fstat");
	118	exit(1);
	119	}
	120	file->size = stat_buf.st_size;
	121
	122	/* allocate this much memory */
	123	file->buffer = (char*)zalloc(file->size+1);
	124	if(file->buffer == NULL) {
	125	perror("table_open.calloc.file->size+1");
	126	exit(1);
	127	}
	128	file->pos = file->buffer;
	129
	130	/* read it in */
	131	#ifdef __CYGWIN32__
	132	if ((file->size) && ((nr = read(fd, file->buffer, file->size)) <= 0)) {
	133	#else
	134	if ((nr = read(fd, file->buffer, file->size)) < file->size) {
	135	#endif
	136	perror("table_open.read");
	137	exit(1);
	138	}
	139	file->size = nr;
	140	file->buffer[file->size] = '\0';
	141
	142	/* done */
	143	close(fd);
c906108c SS	144	}
c906108c SS	145
43c4bab0 MG	146	extern table *
	147	table_open(const char *file_name,
	148	int nr_fields,
	149	int nr_model_fields)
	150	{
	151	table *root;
	152
	153	/* create a file descriptor */
	154	root = ZALLOC (table);
	155	if (root == NULL)
	156	{
	157	perror (file_name);
	158	exit (1);
	159	}
	160
	161	table_push (root, NULL, file_name, nr_fields, nr_model_fields);
	162	return root;
	163	}
c906108c SS	164
c906108c SS	165	extern table_entry *
43c4bab0	166	table_entry_read(table *root)
c906108c	167	{
43c4bab0	168	open_table *file = root->current;
c906108c SS	169	int field;
	170	table_entry *entry;
	171
	172	/* skip comments/blanks */
	173	while(1) {
43c4bab0 MG	174	/* end-of-file? */
	175	while (*file->pos == '\0')
	176	{
	177	if (file->parent != NULL)
	178	{
	179	file = file->parent;
	180	root->current = file;
	181	}
	182	else
	183	return NULL;
	184	}
c906108c SS	185	/* leading white space */
	186	while (*file->pos != '\0'
	187	&& *file->pos != '\n'
	188	&& isspace(*file->pos))
	189	file->pos++;
	190	/* comment */
	191	if (*file->pos == '#') {
	192	do {
	193	file->pos++;
	194	} while (file->pos != '\0' && file->pos != '\n');
	195	}
	196	/* end of line? */
	197	if (*file->pos == '\n') {
	198	file->pos++;
	199	file->line_nr++;
	200	}
	201	else
	202	break;
	203	}
c906108c SS	204
	205	/* create this new entry */
	206	entry = (table_entry*)zalloc(sizeof(table_entry)
	207	+ (file->nr_fields + 1) * sizeof(char*));
	208	ASSERT(entry != NULL);
	209	entry->file_name = file->file_name;
	210	entry->nr_fields = file->nr_fields;
	211
	212	/* break the line into its colon delimitered fields */
	213	for (field = 0; field < file->nr_fields-1; field++) {
	214	entry->fields[field] = file->pos;
	215	while(file->pos && file->pos != ':' && *file->pos != '\n')
	216	file->pos++;
	217	if (*file->pos == ':') {
	218	*file->pos = '\0';
	219	file->pos++;
	220	}
	221	}
	222
	223	/* any trailing stuff not the last field */
	224	ASSERT(field == file->nr_fields-1);
	225	entry->fields[field] = file->pos;
	226	while (file->pos && file->pos != '\n') {
	227	file->pos++;
	228	}
	229	if (*file->pos == '\n') {
	230	*file->pos = '\0';
	231	file->pos++;
	232	}
	233	file->line_nr++;
	234
	235	/* if following lines begin with a star, add them to the model
	236	section. */
	237	while ((file->nr_model_fields > 0) && (file->pos == '')) {
	238	table_model_entry model = (table_model_entry)zalloc(sizeof(table_model_entry)
	239	+ (file->nr_model_fields + 1) * sizeof(char*));
	240	if (entry->model_last)
	241	entry->model_last->next = model;
	242	else
	243	entry->model_first = model;
	244	entry->model_last = model;
	245
	246	/* break the line into its colon delimitered fields */
	247	file->pos++;
	248	for (field = 0; field < file->nr_model_fields-1; field++) {
	249	model->fields[field] = file->pos;
	250	while(file->pos && file->pos != ':' && *file->pos != '\n')
	251	file->pos++;
	252	if (*file->pos == ':') {
	253	*file->pos = '\0';
	254	file->pos++;
	255	}
	256	}
	257
	258	/* any trailing stuff not the last field */
	259	ASSERT(field == file->nr_model_fields-1);
	260	model->fields[field] = file->pos;
	261	while (file->pos && file->pos != '\n') {
	262	file->pos++;
	263	}
	264	if (*file->pos == '\n') {
	265	*file->pos = '\0';
	266	file->pos++;
	267	}
268
269	file->line_nr++;
270	model->line_nr = file->line_nr;
271	}
272
273	entry->line_nr = file->line_nr;
274
275	/* if following lines are tab indented, put in the annex */
276	if (*file->pos == '\t') {
277	entry->annex = file->pos;
278	do {
279	do {
280	file->pos++;
281	} while (file->pos != '\0' && file->pos != '\n');
282	if (*file->pos == '\n') {
283	char *save_pos = ++file->pos;
284	int extra_lines = 0;
285	file->line_nr++;
286	/* Allow tab indented to have blank lines */
287	while (*save_pos == '\n') {
288	save_pos++;
289	extra_lines++;
290	}
291	if (*save_pos == '\t') {
292	file->pos = save_pos;
293	file->line_nr += extra_lines;
294	}
295	}
296	} while (file->pos != '\0' && file->pos == '\t');
297	if (file->pos[-1] == '\n')
298	file->pos[-1] = '\0';
299	}
300	else
301	entry->annex = NULL;
302
303	/* return it */
304	return entry;
305
306	}
307
308
309	extern void
310	dump_table_entry(table_entry *entry,
311	int indent)
312	{
313	printf("(table_entry*)%p\n", entry);
314
315	if (entry != NULL) {
316	int field;
317	char sep;
318
319	sep = ' ';
320	dumpf(indent, "(fields");
321	for (field = 0; field < entry->nr_fields; field++) {
322	printf("%c%s", sep, entry->fields[field]);
323	sep = ':';
324	}
325	printf(")\n");
326
327	dumpf(indent, "(line_nr %d)\n", entry->line_nr);
328
329	dumpf(indent, "(file_name %s)\n", entry->file_name);
330
331	dumpf(indent, "(annex\n%s\n", entry->annex);
332	dumpf(indent, " )\n");
333
334	}
335	}
336
337
338	extern void
339	table_entry_print_cpp_line_nr(lf *file,
340	table_entry *entry)
341	{
342	lf_print__external_reference(file, entry->line_nr, entry->file_name);
343	}
344
345