analyse_check.c File Reference

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "analyse_define.h"
#include "analyse_name.inc"
#include "analyse.h"
#include "analyse_print.h"
#include "analyse_memory.h"
#include "analyse_getall.h"
#include "analyse_comment.h"
#include "analyse_read_tools.h"
#include "analyse_check.h"

Go to the source code of this file.

Functions
static int	compar_check_group (const void *group_1_p, const void *group_2_p)
static int	compar_check_group_by_order (const void *group_1_p, const void *group_2_p)
static int	compar_check (const void *check_1_p, const void *check_2_p)
static analyse_check_group_t *	check_group_create (int nb_check_group)
static analyse_check_t *	check_create (int nb_check)
void	analyse_check_store (analyse_check_t *check_list, int language, int id)
void	analyse_check_file_read (analyse_check_t **check_p, analyse_check_group_t **check_group_p, char *infilename)
void	analyse_check_file_write (analyse_check_t *check_list, analyse_check_group_t *check_group_list, int language)
void	analyse_check_clean_memory (analyse_check_t *check_list, analyse_check_group_t *check_group_list)

Variables
static int	ANALYSE_NB_CHECK_GROUP =0
static int	ANALYSE_NB_CHECK =0

Function Documentation

analyse_check_clean_memory()

void analyse_check_clean_memory	(	analyse_check_t *	check_list,
		analyse_check_group_t *	check_group_list )

Definition at line 372 of file analyse_check.c.

{
 
 
}

analyse_check_file_read()

void analyse_check_file_read	(	analyse_check_t **	check_p,
		analyse_check_group_t **	check_group_p,
		char *	infilename )

Definition at line 152 of file analyse_check.c.

{
  FILE *infile=NULL;
  char line[ANALYSE_SIZE_OF_LINE];
  char key[ANALYSE_SIZE_OF_LINE];
  int i, id;
  int linecount = 0;
 
  analyse_comment_t *comment;
 
  analyse_check_t *work_check;
  analyse_check_t tmp_check;
 
  analyse_check_group_t *work_check_group;
  analyse_check_group_t tmp_check_group;
  
  int count_check_group = 0;
  int check_group_already_print = 0;
 
  int count_check = 0;
  int check_already_print = 0;
 
  int nb_check, nb_check_group, size, size2;
  int *tab, *tab2;
 
  int nb_elt;
  int *elt;
 
  /*************/
  /* Open File */
  /*************/
  if (infilename != NULL)
    {
      infile = fopen(infilename,"r");
    }
 
  if (infile == NULL)
    {
      Analyse_Print_Debug("\nNo Check File Found. Use Default\n\n");
 
 
      return;
    }
 
 
  /***************************/
  /* Allocate Message Memory */
  /***************************/
 
  /* Count message */
  analyse_count_check(line, infile, infilename, &linecount, &nb_check, &nb_check_group);
  rewind(infile);
  analyse_stack_check(line, infile, infilename, &linecount, &nb_check_group, &size, &tab, &nb_check, &size2, &tab2 );
 
  ANALYSE_NB_CHECK_GROUP = nb_check_group;
  ANALYSE_NB_CHECK = nb_check;
 
  analyse_free(tab);
  analyse_free(tab2);
 
  *check_p = check_create(ANALYSE_NB_CHECK);
  *check_group_p = check_group_create(ANALYSE_NB_CHECK_GROUP);
  
 
  /****************/
  /* Read Message */
  /****************/
  rewind(infile);
  while ( ( analyse_getline(line, infile, infilename, &linecount) != -1) &&
      ( strncmp(line, "/END", 4) != 0 ))
    {
      if (strstr(line, "/ANALYSE/CHECK/GROUP") != NULL)                      
    {
      /* Search Group id */
      analyse_getkey(4 , line, key);
      sscanf(key, "%d", &id );  
      
      /* Search id */
      tmp_check_group.id = id;
      work_check_group = bsearch( &tmp_check_group, *check_group_p, ANALYSE_NB_CHECK_GROUP, sizeof(analyse_check_group_t), compar_check_group);
 
      if ( work_check_group == NULL)
        {
          if (count_check_group >= ANALYSE_NB_CHECK_GROUP)
        {
          if ( check_group_already_print == 0)
            {
              Analyse_Print_Error_Level("\n\n*** Analyse Internal Error (ANALYSE_NB_CHECK_GROUP) : Too Many Messages \n\n", 2);
              check_group_already_print = 1;
            }
          continue;
        }
 
          work_check_group = *check_group_p + count_check_group;
 
          work_check_group->order = count_check_group;
          work_check_group->id = id;
          
          /* Note : if file order is in id increase, this qsort does nothing ... */
          qsort(*check_group_p, ANALYSE_NB_CHECK_GROUP, sizeof(analyse_check_group_t), compar_check_group);         
          tmp_check_group.id = id;
          /* .. and this bsearch gives the same work_group */
          work_check_group = bsearch( &tmp_check_group, *check_group_p, ANALYSE_NB_CHECK_GROUP, sizeof(analyse_check_group_t), compar_check_group);
 
          count_check_group++;
        }
 
      analyse_getkey(5 , line, key);
 
      if (strncmp(key, "TITLE", 5) == 0)
        {
          /* Read Comment */
          comment = analyse_read_comment(line, infile, infilename, &linecount);
          analyse_add_comment(ANALYSE_CHECK_GROUP, (void *)work_check_group, comment);
        }
      else if (strncmp(key, "DESCRIPTION", 5) == 0)
        {
          /* Read list of ids */
          if ( analyse_getlist_of_int(&nb_elt, &elt, infile, infilename, &linecount) == 0)
        {
          work_check_group->check_list = (int *)analyse_realloc(work_check_group->check_list, (work_check_group->nb_check + nb_elt)*sizeof(int));
          work_check_group->check_message = (char **)analyse_realloc(work_check_group->check_message, (work_check_group->nb_check + nb_elt)*sizeof(char *));
          
          for(i=0; i<nb_elt; i++)
            {
              work_check_group->check_list[work_check_group->nb_check + i] = elt[i];
              work_check_group->check_message[work_check_group->nb_check + i] = NULL;
            }
          analyse_free(elt);
          work_check_group->nb_check = work_check_group->nb_check + nb_elt;
        }
        }
    }
      else if (strstr(line, "/ANALYSE/CHECK") != NULL)                       
    {
      analyse_getkey(3 , line, key);
      sscanf(key, "%d", &id );
      
      /* Search id */
      tmp_check.id = id;
      work_check = bsearch( &tmp_check, *check_p, ANALYSE_NB_CHECK, sizeof(analyse_check_t), compar_check);
      
      if ( work_check == NULL)
        {
          if (count_check >= ANALYSE_NB_CHECK)
        {
          if ( check_already_print == 0)
            {
              Analyse_Print_Error_Level("\n\n*** Analyse Internal Error (ANALYSE_NB_CHECK) : Too Many Messages \n\n", 2);
              check_already_print = 1;
            }
          continue;
        }
          
          work_check = *check_p + count_check;
          count_check++;
 
          work_check->id = id;
          
          /* Note : if file order is in id increase, this qsort does nothing ... */
          qsort(*check_p, ANALYSE_NB_CHECK, sizeof(analyse_check_t), compar_check);       
          tmp_check.id = id;
          /* .. and this bsearch gives the same work_check */
          work_check = bsearch( &tmp_check, *check_p, ANALYSE_NB_CHECK, sizeof(analyse_check_t), compar_check);
 
        }
      
      /* Read Comment */
      comment = analyse_read_comment(line, infile, infilename, &linecount);
      analyse_add_comment(ANALYSE_CHECK, (void *)work_check, comment);
      
    }
    }
  
  fclose(infile);
 
}

analyse_check_file_write()

void analyse_check_file_write	(	analyse_check_t *	check_list,
		analyse_check_group_t *	check_group_list,
		int	language )

Definition at line 330 of file analyse_check.c.

{
  int i,j, nb_check;
 
  analyse_comment_t *scan_comment;
 
  analyse_check_group_t *work_check_group;
  
  analyse_check_t tmp_check;
  analyse_check_t *work_check;
  
  /* re order groups by order appearance in file, and no more by id */
  qsort(check_group_list, ANALYSE_NB_CHECK_GROUP, sizeof(analyse_check_group_t), compar_check_group_by_order);         
          
  for (i=0; i<ANALYSE_NB_CHECK_GROUP; i++)
    {
      work_check_group = check_group_list+i;
      nb_check = work_check_group->nb_check;
 
      scan_comment = analyse_get_right_comment( work_check_group->title, language, ANALYSE_ENGLISH);
      
      if ((scan_comment != NULL) && (scan_comment->text != NULL))
    {
      analyse_write_f("\n\n");
      analyse_write_f(scan_comment->text);
      /* analyse_write_f("\n"); */
    }
 
      for( j=0; j<nb_check; j++)
    {
      tmp_check.id = work_check_group->check_list[j];
      work_check = bsearch( &tmp_check, check_list, ANALYSE_NB_CHECK, sizeof(analyse_check_t), compar_check);
 
      if ((work_check != NULL) && (work_check->check_message!= NULL))
        {
          analyse_write_f(work_check->check_message);
          /* analyse_write_f("\n"); */
        }
    }
    }
}

analyse_check_store()

void analyse_check_store	(	analyse_check_t *	check_list,
		int	language,
		int	id )

Definition at line 118 of file analyse_check.c.

{
  analyse_comment_t *scan_comment;
  analyse_check_t tmp_check;
  analyse_check_t *work_check;
 
  char line[ANALYSE_SIZE_OF_LINE];
 
  /* Search id */
  tmp_check.id = id;
  work_check = bsearch( &tmp_check, check_list, ANALYSE_NB_CHECK, sizeof(analyse_check_t), compar_check);
      
  if ( work_check == NULL)
    {
      sprintf(line, "Unknown Id for Check %d\nNo Message Available\n", id );
      Analyse_Print_Error_Level(line, 2);
    }
 
  if ( work_check->check_message != NULL )
    {
      analyse_free(work_check->check_message);
      work_check->check_message = NULL;
    }
 
  scan_comment = analyse_get_right_comment( work_check->title, language, ANALYSE_ENGLISH);
 
  work_check->check_message = analyse_fill_description(AN_CHECK, scan_comment->text);
 
}

check_create()

analyse_check_t * check_create ( int nb_check )

static

Definition at line 100 of file analyse_check.c.

{
  analyse_check_t *check;
  int i;
 
  check = (analyse_check_t *)analyse_malloc(nb_check*sizeof(analyse_check_t));
  
  for(i=0; i<nb_check; i++)
    {
      (check+i)->id = -i-1;
      (check+i)->title = NULL;
      (check+i)->check_message = NULL;
    }
 
  return check;
}

check_group_create()

analyse_check_group_t * check_group_create ( int nb_check_group )

static

Definition at line 80 of file analyse_check.c.

{
  analyse_check_group_t *check_group;
  int i;
 
  check_group = (analyse_check_group_t *)analyse_malloc(nb_check_group*sizeof(analyse_check_group_t));
 
  for(i=0; i<nb_check_group; i++)
    {
      (check_group+i)->order = 0;
      (check_group+i)->id = -i-1;
      (check_group+i)->title = NULL;
      (check_group+i)->nb_check = 0;
      (check_group+i)->check_list = NULL;
      (check_group+i)->check_message = NULL;
    }
 
  return check_group;
}

compar_check()

int compar_check ( const void * check_1_p, const void * check_2_p )

static

Definition at line 67 of file analyse_check.c.

{
  analyse_check_t *check_1 = (analyse_check_t *)check_1_p;
  analyse_check_t *check_2 = (analyse_check_t *)check_2_p;
 
  if ( (check_1->id < 0) &&(check_2->id < 0)) return (check_2->id - check_1->id);
  if (check_1->id < 0) return 1;
  if (check_2->id < 0) return -1;
 
  return (check_1->id - check_2->id);
}

compar_check_group()

int compar_check_group ( const void * group_1_p, const void * group_2_p )

static

Definition at line 43 of file analyse_check.c.

{
  analyse_check_group_t *group_1 = (analyse_check_group_t *)group_1_p;
  analyse_check_group_t *group_2 = (analyse_check_group_t *)group_2_p;
 
  if ( (group_1->id < 0) &&(group_2->id < 0)) return (group_2->id - group_1->id);
  if (group_1->id < 0) return 1;
  if (group_2->id < 0) return -1;
 
  return (group_1->id - group_2->id);
}

compar_check_group_by_order()

int compar_check_group_by_order ( const void * group_1_p, const void * group_2_p )

static

Definition at line 55 of file analyse_check.c.

{
  analyse_check_group_t *group_1 = (analyse_check_group_t *)group_1_p;
  analyse_check_group_t *group_2 = (analyse_check_group_t *)group_2_p;
 
  if ( (group_1->order < 0) &&(group_2->order < 0)) return (group_2->order - group_1->order);
  if (group_1->order < 0) return 1;
  if (group_2->order < 0) return -1;
 
  return (group_1->order - group_2->order);
}

Variable Documentation

ANALYSE_NB_CHECK

int ANALYSE_NB_CHECK =0

static

Definition at line 41 of file analyse_check.c.

ANALYSE_NB_CHECK_GROUP

int ANALYSE_NB_CHECK_GROUP =0

static

Definition at line 40 of file analyse_check.c.