#include "cubes.h"
#define CR '\n'
#define BL ' '

/*

COMMON VARIABLES
	The variables defined below are used in many modules and are defined
	external in the file cube.h
*/

int
	input_number,		/* number of input variables */
	output_number,		/* number of outpput variables */
	total_number,		/* number of variables */
	input_length,		/* number of long int words to store inputs */
        output_length,		/* number of long int words to store outputs */
	total_length;		/* number of long int words to store a cube */

char error_buffer[132];		/* buffer to hold the error messages */ 

unsigned
	node_size,		/* size in bytes of a node including the cube*/
	cube_list_size;		/* size of a cube_list including the cube */

struct node *spare_node;	/* a node is allocated for temp usage */

/*

TABLES
	Here are defined and initialized the tables useful for the input
	and output of cubes. We have the literal corresponding to each
	internal code for a boolean variable.

*/

char 
	input_literal[4] = { 'x','X','0','1' },	
				/* holds the characters accepted for the
				   input variables			  */

	output_literal[4] = { '0','1','d','D' };
				/* holds the characters accepted for output
				   variables				  */

long int
	input_code[4],		/* holds the code for the character at input */
	output_code[4];		/* holds the code for the output characters */

/****************************************************************************

NAME
	ffind_car

PURPOSE
	this functions skips characters in the input file until a EOF or the
	specified character is found.

SYNOPSIS
	char ffind_car(fp,lineno,car_searched)
	FILE *fp;
	int *lineno;
        char car_searched;

DESCRIPTION
	the characters are skipped from the file pointed by fp; EOF or
	the specified character is returned depending which is 
        encountered first. The line number is updated if needed.

COORDINATES
	McGill University Electrical Engineering VLSI Lab MONTREAL CANADA
	19 june 1984

AUTHOR
	Michel DAGENAIS

************************************************************************/

char ffind_car(fp,lineno,car_searched)

FILE *fp;
int *lineno;
char car_searched;
 {
   int	car;		/* byte to store the character read */

   for(; (car = getc(fp)) > EOF ;)
    { if(car == CR) (*lineno)++ ;
      if(car ==  car_searched) break;
    }			
   return(car);
 }

/***************************************************************************

NAME
	fread_bit_string

PURPOSE
	This function reads a string of bits and pack them in long words
	at the rate of 4 input bits per byte since up to 4 codes are
	recognized by this function.

SYNOPSIS
	fread_bit_string(fp,lineno,word,bit_number,terminator,literal,code)
	FILE *fp;
	long int *word,code[4];
	int bit_number,*lineno;
	char terminator,literal[4];

DESCRIPTION
	the characters are read from the file pointed by fp;
	When we encounter the terminator, we stop reading.
	The comments and blanks are skipped. The non-blank
	character are compared with the literals in the table;
	if the character is not in the table a message is issued.
	When we found the character in the table the corresponding code
	is placed in the long word. When a word is full, we increment the
	pointer. When the number of bits read is not bit_number, a 
	message is issued to the user. We keep track of the number of lines
	for diagnostic purpose. The function returns 1 when a cube was read
	properly, -1 when a cube was read but the terminator was missing and EOF
	was encountered. If anything goes wrong a message is issued
	and the function never returns. The function returns 0 when the EOF
	was encountered before any bit was found.

COORDINATES
	McGill University Electrical Engineering VLSI Lab MONTREAL CANADA
	19 june 1984

AUTHOR
	Michel DAGENAIS

************************************************************************/

int fread_bit_string(fp,lineno,word,bit_number,terminator,literal,code)

FILE *fp;
long int *word,code[4];
int bit_number,*lineno;
char terminator,literal[4];
{
  unsigned long int mask;     /* mask used to pack the variables in long int */

  int car;		/* byte to store the character returned by functions */

  int 
	nb_bit_read,	/* number of bits read */
	i;		/* loop counter	for code determination */

/* we fill the long words right to left as the variables values are read, 
   using the mask which is shifted left 2 bits each time to go to the next
   variable stored in the long word.					*/

  nb_bit_read = 0;
  for(; ;)
   { *word = mask00;
     for( mask = 3 ; mask != NULL ; mask = mask << 2)

/* We read characters at input until the EOF or the terminator is reached */

      { for(; ;)
	 { car = getc(fp);
	   if(car == CR) (*lineno)++;
	   if(car == terminator && nb_bit_read != 0) break;
	   if(car == '/') 
	    { car = ffind_car(fp,lineno,'/');
              if(car == '/') continue;
	    }
	   if(car <= EOF) break;
	   if(car <= BL) continue;
	   break;
	 }

/* The terminator is reached, we will check that the number of bits read was
   correct. The rest of the word is filled with the default code (code[0]). */

	if(car == terminator)
	 { if(nb_bit_read != bit_number)
	    { sprintf(error_buffer,
	      "wrong number of bits on line %d '%c' was reached after %d bits",
	      *lineno,terminator,nb_bit_read);
	      fatal_user_error(error_buffer);
	    }
           for(; mask > 3 ; mask = mask << 2) *word |= code[0] & mask; 
           return(1);
	 }

/* The end of file is reached, if a string of proper length was read the
   user is warned that the terminator is missing and we return -1.	*/

	if(car <= EOF)
	 { if(nb_bit_read == bit_number)
	    { for(; mask > 3 ; mask = mask << 2) *word |= code[0] & mask;
	      warning_user_error("missing terminator at end of file");
	      return(-1);
	    }
           if(nb_bit_read == 0) return(0);
	   sprintf(error_buffer,"EOF encountered after %d bits %d were expected"
			       ,nb_bit_read,bit_number);
	   fatal_user_error(error_buffer);
	 }

/* We will try to find the literal in the table */

        for(i = 0 ; i < 4 ; i++) if(car == literal[i]) break;
 
/* The literal was not found, it is an invalid character, a message is issued */

	if(i == 4)
	 { sprintf(error_buffer,"invalid character '%c' in line %d",car,*lineno);
	   fatal_user_error(error_buffer);
	 }

/* The specified number of bits were read and the terminator is not reached
   a message will be issued.					*/

	if(nb_bit_read >= bit_number)
	 { sprintf(error_buffer,"too many bits on line %d '%c' not reached",
		   *lineno,terminator);
	   fatal_user_error(error_buffer);
	 }

/* it is in the table so we put it in the long word			*/

        *word |= mask & code[i];
        nb_bit_read++;
      }
     word++;
   }
}

/*****************************************************************************

NAME
	fread_nodes

PURPOSE
	This function reads all the cubes from the input file and store
	them in the proper form after allocating space for them.

SYNOPSIS
	int fread_nodes(fp,list)
	FILE *fp;
	struct node **list;

DESCRIPTION
	When this function is called for the first time, the variable
	input_number is 0; then we read one cube to determine the number of
	input and output bits and we compute the size of the structures needed.
	When the number of inputs is known, we simply read the cubes one by 
	one from fp and allocate space for them. The list formed goes in list
	and the number of cubes in list is returned. Any error reading the
	cube will be signaled by this function or by the function 
	fread_bit_string called to read the cubes. 

COORDINATES
	McGill University Electrical Engineering VLSI Lab MONTREAL CANADA
	19 june 1984

AUTHOR
	Michel DAGENAIS

************************************************************************/

int fread_nodes(fp,list)

FILE *fp;
struct node **list;
{
  int car;		/* character read */ 

  int 
	list_number,	/* number of cubes read and placed in the list */
	line_number,	/* number of lines read at input for diagnostic */
	answer;		/* return code of the function fread bit string */

  struct node **previous;	/* pointer to node.next_cube of the previous*/
				/* node to link the chain while reading */

/* We will read the first cube to count the number of input and output
   variables. The size of the structures will be computed.		*/

  if(input_number == 0)
   { line_number = 0;
     for(; ;)
      { car = getc(fp);
	if(car == read_interminator && input_number != 0) break; 
	if(car <= EOF) fatal_user_error("EOF encountered on first line"); 
        if(car <= BL) continue;
	if(car == '/') 
	 { car = ffind_car(fp,&line_number,'/');
	   if(car <= EOF) fatal_user_error("EOF encountered on first line");
	 }
	else input_number++;
      }
   
     for(; ;)
      { car = getc(fp);
	if(car == read_outterminator && output_number != 0) break;
	if(car <= EOF) break;
        if(car <= BL) continue;
	if(car == '/') 
	 { car = ffind_car(fp,&line_number,'/');
	   if(car <= EOF) break;
	 }
	else output_number++;
      }

/* We now have the number of input and output, so we can compute the different
   variables that depend on those values.				*/

     input_length = ((input_number - 1) / var_per_word) + 1;
     output_length = ((output_number - 1) / var_per_word) + 1;
     total_length = input_length + output_length;
     total_number = input_number + output_number;

/* The nodes already include 2 long int word which is the minimum space a cube
   is allowed to take. The actual length of the cube minus the 2 minimum
   is then added to the sizeof(node) to get the nodesize appropriate to our
   number of input and output.						*/

     node_size = sizeof(struct node) + (total_length - 2) * sizeof(long int);
     cube_list_size = 
	    sizeof(struct cube_list) + (total_length - 2) * sizeof(long int);

/* We now reset the file pointer to the beginning of the file to read all the
   nodes and place them in the list. Also we initialize all the constants needed
   to process the cubes. It is a convenient place to make this call since 
   before any processing can be done we have to read the cubes.		    */

     init_mask_and_codes();
     rewind(fp);
     spare_node = alloc_node();
   } 

/* We will now read the list of nodes from the file, the line number and the
   number of nodes in the list are initialized.				*/ 
 
  previous = list;
  line_number = 1;
  list_number = 0;
 
  for(; ;)

   { answer = fread_bit_string(fp,&line_number,spare_node->cube,input_number,
		read_interminator,input_literal,input_code);

/* No more cubes in the file, the EOF was encountered */

     if(answer == 0) break;
     if(answer == -1) fatal_user_error("last cube of file has no output part");

     answer = fread_bit_string(fp,&line_number,spare_node->cube + input_length,
	output_number,read_outterminator,output_literal,output_code);

/* The EOF was encountered but the cube was not finished */

     if(answer == 0)
      { fatal_user_error("The output of the last cube is incomplete");
      }

/* another node was read succesfully, place it next in the list.	*/

     *previous = spare_node;
     spare_node->next_node = alloc_node();
     previous = &(spare_node->next_node);
     spare_node = spare_node->next_node;
     list_number++;
 
 /* the cube read was the last one of the file */

     if(answer == -1) break;
   }

/* the last node we tried to read was not there, the eof was encountered,
   so we must remove it from the list				*/

  *previous = NULL;
  return(list_number);
}