analyse.c File Reference

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <signal.h>
#include "analyse_portage.h"
#include "analyse_name.inc"
#include "analyse_define.h"
#include "analyse_print.h"
#include "analyse_memory.h"
#include "analyse_getall.h"
#include "analyse_string.h"
#include "analyse_fill_info.h"
#include "analyse_error.h"
#include "analyse_check.h"
#include "analyse_GUI.h"
#include "analyse_structure.h"
#include "analyse.h"

Go to the source code of this file.

Macros
#define	SIZE_STEP   1000

Functions
static analyse_node_t *	search_for_node_with_id (int name_id)
static void	store_info_in_node_list (analyse_info_t *analyse_info)
static void	remove_node_data (analyse_node_t *node_scan)
static void	remove_node_structure (analyse_node_t *node_scan)
static void	remove_all_in_node_recursiv (analyse_node_t *node_scan)
static void	remove_data_in_node_recursiv (analyse_node_t *node_scan)
static void	manage_Core (int s)
static void	analyse_tree_enter (int name_id)
static void	analyse_tree_close (int name_id)
static void	analyse_tree_exit (int name_id)
static void	analyse_init (int prgrm, int GUI_mode, int prgrm_language)
void	analyse_stack_float (float r)
void	anstckf (float *r)
void	anstckf_ (float *r)
void	anstckf__ (float *r)
void _FCALL	ANSTCKF (float *r)
void	analyse_stack_int (int i)
void	anstcki (int *i)
void	anstcki_ (int *i)
void _FCALL	ANSTCKI (int *i)
int	analyse_get_datas (int name_id, int *nb_int, int **tab_int, int *nb_float, float **tab_float)
void	anenter (int *name_id)
void	anenter_ (int *name_id)
void _FCALL	ANENTER (int *name_id)
void	anclose (int *name_id)
void	anclose_ (int *name_id)
void	anclose__ (int *name_id)
void _FCALL	ANCLOSE (int *name_id)
void	anexit (int *name_id)
void	anexit_ (int *name_id)
void	anexit__ (int *name_id)
void _FCALL	ANEXIT (int *name_id)
void	analyse_call_error (int type, int id, int mode)
void	analyse_call_check (int id)
void	ancheck (int *id)
void	ancheck_ (int *id)
void	ancheck__ (int *id)
void _FCALL	ANCHECK (int *id)
void	aninit (int *prgrm, int *GUI_mode)
void	aninit_ (int *prgrm, int *GUI_mode)
void	aninit__ (int *prgrm, int *GUI_mode)
void _FCALL	ANINIT (int *prgrm, int *GUI_mode)
void	analyse_quit (void)
void	ancnts (int *id, int *value)
void	ancnts_ (int *id, int *value)
void	ancnts__ (int *id, int *value)
void _FCALL	ANCNTS (int *id, int *value)
void	ancntg (int *id, int *global_cnt, int *tmp_cnt)
void	ancntg_ (int *id, int *global_cnt, int *tmp_cnt)
void	ancntg__ (int *id, int *global_cnt, int *tmp_cnt)
void _FCALL	ANCNTG (int *id, int *global_cnt, int *tmp_cnt)
void	analyse_write_f (char *message)
void	qaclose_ ()
void	my_exit (int *i)
void	my_exit_ (int *i)
void	my_exit__ (int *i)
void _FCALL	MY_EXIT (int *i)

Variables
static int	LANGUAGE
static int *	int_stack =NULL
static int	int_stack_size =0
static int	int_stack_current =0
static int	int_stack_scan =0
static float *	float_stack =NULL
static int	float_stack_size =0
static int	float_stack_current =0
static int	float_stack_scan =0
analyse_node_t *	analyse_tree =NULL
static analyse_node_t *	current_node =NULL
static analyse_node_t *	last_node_in_list =NULL
static analyse_node_t *	first_free_in_list =NULL
static analyse_error_info_t *	analyse_error_list =NULL
static analyse_check_group_t *	analyse_check_group_list =NULL
static analyse_check_t *	analyse_check_list =NULL
static analyse_node_t *	current_node_child_sav = NULL
static analyse_node_t *	node_scan_sav = NULL

Macro Definition Documentation

SIZE_STEP

#define SIZE_STEP   1000

Definition at line 55 of file analyse.c.

Function Documentation

analyse_call_check()

void analyse_call_check

(

int

id

)

Definition at line 802 of file analyse.c.

{
  if (id == -1)
    {
      analyse_check_file_write(analyse_check_list, analyse_check_group_list, LANGUAGE);
    }
  else
    {
      analyse_tree_enter(AN_CHECK); 
      analyse_check_store(analyse_check_list, LANGUAGE, id);
      analyse_tree_close(AN_CHECK);
    }
}

analyse_call_error()

void analyse_call_error	(	int	type,
		int	id,
		int	mode )

Definition at line 580 of file analyse.c.

{
  int nb_int;
  int *tab_int=NULL;
 
  int nb_int_line;
  int *tab_int_line=NULL;
 
  char *title;
  char *description;
  
  int nb_err, nb_warn;
 
  char stop_message[]="\n\n %s STOPPED due to INPUT ERROR";
  char gene_message[]="\n******************************\n%s stopped with :\n    %d Error(s)\n    %d Warning(s)\n******************************\n";
  
  char error_id_message[]="ERROR id : %d";
  char warning_id_message[]="WARNING id : %d";
  char info_id_message[]="INFO id : %d";
  char unknown_id_message[]="??? id : %d";
 
  char id_message_real[20];
  char *message;
 
  /* Get tab for a new line */
  analyse_convert_string_to_int("\n", &nb_int_line, &tab_int_line);
 
 
  /* ADD ERROR in IERR */
  if (type == AN_ERROR)
    {
      anaderr();
      analyse_tree_enter(AN_ERROR);
      analyse_error_return_message(analyse_error_list, AN_ERROR, LANGUAGE, id, &title, &description, NULL);
    }
  else if (type == AN_WARNING)
    {
      anadwar();
      analyse_tree_enter(AN_WARNING);
      analyse_error_return_message(analyse_error_list, AN_WARNING, LANGUAGE, id, &title, &description, NULL);
    }
  else
    {
      analyse_tree_enter(AN_INFO);
      analyse_error_return_message(analyse_error_list, AN_INFO, LANGUAGE, id, &title, &description, NULL);
    }
 
  /* Count Error */
  analyse_error_cnt(analyse_error_list, id);
 
  /* Print Error Id + Title */
  if (type == AN_ERROR)
    sprintf(id_message_real, error_id_message, id);
  else if (type == AN_WARNING)
    sprintf(id_message_real, warning_id_message, id);
  else if (type == AN_INFO)
    sprintf(id_message_real, info_id_message, id);
  else
    sprintf(id_message_real, unknown_id_message, id);
 
   analyse_GUI_add_error_message(id_message_real);
   analyse_GUI_add_error_message(title);
 
  switch(mode)
    {
    case ANSTOP:
    case ANINFO: /* title+description on screen, title+description in file */
    case ANINFO_BLIND_1: /* only title on screen, title + description in file */
      /* Id */
      analyse_convert_string_to_int(id_message_real, &nb_int, &tab_int);
 
      wiout(&nb_int_line, tab_int_line);
      /* wistdo(&nb_int_line, tab_int_line); */
 
      wiout(&nb_int, tab_int);
      if (mode == ANINFO ) 
      wistdo(&nb_int, tab_int);
      
      analyse_free(tab_int);
 
      /* Title */
      analyse_convert_string_to_int(title, &nb_int, &tab_int);
      wistdo(&nb_int, tab_int);
      wiout(&nb_int, tab_int);
 
      analyse_free(tab_int);
      break;
      
    case ANINFO_BLIND_2: /* nothing on screen, title + description in file */
    case ANINFO_BLIND_3: /* nothing on screen, title in file */
 
      /* Id */
      analyse_convert_string_to_int(id_message_real, &nb_int, &tab_int);
 
      wiout(&nb_int_line, tab_int_line);
      wiout(&nb_int, tab_int);
 
      analyse_free(tab_int);
 
      /* Title */
      analyse_convert_string_to_int(title, &nb_int, &tab_int);
      wiout(&nb_int, tab_int);
 
      analyse_free(tab_int);
      break;
 
 
    case ANINFO_BLIND_4: /* nothing on screen, nothing in file */
    default :
      break;
    }
  analyse_free(title);
 
 
  /* Print Error Description */
  analyse_GUI_add_error_message(description);  
 
  switch(mode)
    {
    case ANSTOP:
    case ANINFO: /* title+description on screen, title+description in file */     
      analyse_convert_string_to_int(description, &nb_int, &tab_int);
 
      wiout(&nb_int, tab_int);
      wistdo(&nb_int, tab_int);
 
      wiout(&nb_int_line, tab_int_line);
      /* wistdo(&nb_int_line, tab_int_line); */
 
      analyse_free(tab_int);
      break;
 
    case ANINFO_BLIND_1: /* only title on screen, title + description in file */
      analyse_convert_string_to_int(description, &nb_int, &tab_int);
      
      wiout(&nb_int, tab_int);
 
      wiout(&nb_int_line, tab_int_line);
      /* wistdo(&nb_int_line, tab_int_line); */
 
      analyse_free(tab_int);
      break;
 
    case ANINFO_BLIND_2: /* nothing on screen, title + description in file */
      analyse_convert_string_to_int(description, &nb_int, &tab_int);
 
      wiout(&nb_int, tab_int);
 
      wiout(&nb_int_line, tab_int_line);
 
      analyse_free(tab_int);
      break;
 
    case ANINFO_BLIND_3: /* nothing on screen, title in file */
      wiout(&nb_int_line, tab_int_line);
      break;
 
    case ANINFO_BLIND_4: /* nothing on screen, nothing in file */
    default :
      break;
    }
  analyse_free(description);
  
 
  /* Error Management */
  switch(mode)
    {
    case ANSTOP:
      /* Stopped due to Input Errors */
      message = (char *)analyse_malloc((strlen(analyse_tree->info.calling_name)+strlen(stop_message)+1)*sizeof(char));
      sprintf(message,stop_message,analyse_tree->info.calling_name);
 
      /* Print Stop Message On SCREEN, IN L00 FILE and in GUI*/
      analyse_convert_string_to_int(message, &nb_int, &tab_int);
 
      wistdo(&nb_int, tab_int);
      wiout(&nb_int, tab_int);
  
      analyse_free(tab_int);
 
      analyse_GUI_add_error_message(message);
      analyse_free(message);
 
      /* Prepare GUI Message and start GUI*/
      angetnb(&nb_err, &nb_warn);
      message = (char *)analyse_malloc((strlen(analyse_tree->info.calling_name)+strlen(gene_message)+ 10+10+1)*sizeof(char));
      sprintf(message,gene_message,analyse_tree->info.calling_name, nb_err, nb_warn);
 
      analyse_GUI_add_error_message(message);
      analyse_free(message);
         
      analyse_GUI_start_loop();
  
      /* quit Program */
      analyse_quit();
      break;
      
    case ANINFO:
    case ANINFO_BLIND_1:
    case ANINFO_BLIND_2:
    case ANINFO_BLIND_3:
    case ANINFO_BLIND_4:
      if (type == AN_ERROR)
    analyse_tree_close(AN_ERROR);
      else if (type == AN_WARNING)
    analyse_tree_close(AN_WARNING);
      else
    analyse_tree_close(AN_INFO);
      break;
      
    default :
      break;
    }
  
  analyse_free(tab_int_line);
}

analyse_get_datas()

int analyse_get_datas	(	int	name_id,
		int *	nb_int,
		int **	tab_int,
		int *	nb_float,
		float **	tab_float )

Definition at line 364 of file analyse.c.

{
 
  analyse_node_t *node_scan;
 
  node_scan=search_for_node_with_id(name_id);
 
  if (node_scan == NULL)
    {
      if (nb_int!= NULL) *nb_int=0;
      if (tab_int !=NULL) *tab_int=NULL;
 
      if (nb_float != NULL) *nb_float=0;      
      if (tab_float != NULL) *tab_float=NULL;
 
      return -1;
    }
 
  if (nb_int != NULL) *nb_int=node_scan->info.nb_int_data;
  if (tab_int != NULL) *tab_int = int_stack + node_scan->info.int_data_offset_start;
 
  if (nb_float != NULL) *nb_float=node_scan->info.nb_float_data;
  if (tab_float != NULL) *tab_float = float_stack + node_scan->info.float_data_offset_start;
 
  return 0;
}

analyse_init()

void analyse_init ( int prgrm, int GUI_mode, int prgrm_language )

static

Definition at line 841 of file analyse.c.

{
  char *filename;
  char *path;
  char *tmp;
  char *env;
  char *var;
  int len_path;
 
  char *starter_filename="$RADIR/rad_err/starter_message_description.txt";
  char *radioss_filename="$RADIR/rad_err/radioss_message_description.txt";
  char *program_filename="$RADIR/rad_err/program_message_description.txt";
 
  int length;
 
  analyse_tree = (analyse_node_t *)analyse_malloc(sizeof(analyse_node_t));
 
  analyse_node_init(analyse_tree);
 
  LANGUAGE = prgrm_language;
 
  if (prgrm == AN_STARTER)
    {
      #ifdef _WIN64
        analyse_tree->info.calling_name=_strdup("Starter");
      #else
        analyse_tree->info.calling_name=strdup("Starter");
      #endif
      filename = starter_filename;
    }
  else if(prgrm == AN_RADIOSS)
    {
      #ifdef _WIN64
        analyse_tree->info.calling_name=_strdup("Radioss");
      #else
        analyse_tree->info.calling_name=strdup("Radioss");
      #endif
       filename = radioss_filename;
    }
  else 
    {
      #ifdef _WIN64
      analyse_tree->info.calling_name=_strdup("Program");
      #else
      analyse_tree->info.calling_name=strdup("Program");
      #endif
      filename = program_filename;
    }
 
  if (filename[0]=='$')
    {
      tmp=strchr(filename,'/');
      length = (int)(tmp-filename);
      var = (char*)analyse_malloc(length*sizeof(char));
      #ifdef _WIN64
      strncpy_s(var,length, filename+1, length-1);
      #else
      strncpy(var, filename+1, length-1);
      #endif
      var[length-1]='\0';
 
      env = getenv(var);
      analyse_free(var);
 
      if (env == NULL)
    {
    path = NULL;
    }
      else
    {
      len_path = (strlen(env)+strlen(tmp)+1)*sizeof(char);
      path = (char*)analyse_malloc(len_path);
      #ifdef _WIN64
      strcpy_s(path,len_path,"");
      strcat_s(path,len_path,env);
      strcat_s(path,len_path,tmp);
      #else
      strcpy(path,"");
      strcat(path,env);
      strcat(path,tmp);
      #endif
    }
    }
  else
    {
      #ifdef _WIN64
      path = _strdup(filename);
      #else
      path = strdup(filename);
      #endif
    }
 
 
  current_node=analyse_tree;
  last_node_in_list=analyse_tree;
  
  analyse_error_file_read(&analyse_error_list, path);
  analyse_free(path);
 
  analyse_GUI_window_create(GUI_mode);  
 
/*  setIgnoreCore (1); */
}

analyse_quit()

void analyse_quit

(

void

)

Definition at line 969 of file analyse.c.

{
  anend();
}

analyse_stack_float()

void analyse_stack_float

(

float

r

)

Definition at line 294 of file analyse.c.

{
  if (float_stack_scan == float_stack_size)
    {
      float_stack = (float *)analyse_realloc( (void *)float_stack, (float_stack_size + SIZE_STEP)*sizeof(float));
      
      float_stack_size = float_stack_size + SIZE_STEP;
    }
 
  float_stack[float_stack_scan] = r;
  float_stack_scan ++;
 
  
}

analyse_stack_int()

void analyse_stack_int

(

int

i

)

Definition at line 334 of file analyse.c.

{
  if (int_stack_scan == int_stack_size)
    {
      int_stack = (int *)analyse_realloc( (void *)int_stack, (int_stack_size + SIZE_STEP)*sizeof(int));
      
      int_stack_size = int_stack_size + SIZE_STEP;
    }
  
  int_stack[int_stack_scan] = i;
  int_stack_scan ++;
 
}

analyse_tree_close()

void analyse_tree_close ( int name_id )

static

Definition at line 472 of file analyse.c.

{
  analyse_node_t *node_scan;
  char tline[180];
 
  node_scan=search_for_node_with_id(name_id);
 
  if (node_scan == NULL)
    {
      sprintf(tline, "Unable to close Function id %d", name_id);
      Analyse_Print_Error_Level(tline, 2);
      return;
    }
 
  remove_data_in_node_recursiv(node_scan->child);
 
  remove_node_data(node_scan);
 
  current_node = node_scan->parent;
 
  analyse_GUI_tree_rebuild();
}

analyse_tree_enter()

void analyse_tree_enter ( int name_id )

static

Definition at line 395 of file analyse.c.

{
  analyse_node_t *node_scan;
  analyse_info_t analyse_info;
 
 
  analyse_info_init(&analyse_info);
  analyse_info.calling_id = name_id;
  analyse_fill_info(&analyse_info);
 
#ifdef ANALYSE_DEBUG 
  printf(" Enter analyse_tree_enter with %s\n", analyse_info.calling_name);
#endif
 
  analyse_info.nb_float_data = float_stack_scan - float_stack_current;
  analyse_info.float_data_offset_start = float_stack_current;
  
  float_stack_current = float_stack_scan;
 
  analyse_info.nb_int_data = int_stack_scan - int_stack_current;
  analyse_info.int_data_offset_start = int_stack_current;
 
  int_stack_current = int_stack_scan;
 
  /* transfer info to a node which is necessary last_node_in_list */
  store_info_in_node_list(&analyse_info);
 
  last_node_in_list->parent = current_node;
 
  if (current_node->child == NULL)
    {
      current_node->child = last_node_in_list;
    }
  else
    {
 
      if (current_node->child == current_node_child_sav) {
        node_scan = node_scan_sav;
      } else {
        current_node_child_sav = current_node->child;
        node_scan = current_node->child;
      }
      while (node_scan->next != NULL) node_scan = node_scan->next;
      node_scan_sav = node_scan;
      
      node_scan->next = last_node_in_list;
      last_node_in_list->prev = node_scan;
    }
      
  current_node = last_node_in_list;
 
  analyse_GUI_tree_rebuild();
 
}

analyse_tree_exit()

void analyse_tree_exit ( int name_id )

static

Definition at line 520 of file analyse.c.

{
  analyse_node_t *node_scan;
  char tline[180];
 
  node_scan=search_for_node_with_id(name_id);
 
  if (node_scan == NULL)
    {
      sprintf(tline, "Unable to close Function id %i", name_id);
      Analyse_Print_Error_Level(tline, 2);
      return;
    }
    
  remove_all_in_node_recursiv(node_scan->child);
 
  remove_node_data(node_scan);
  remove_node_structure(node_scan);
 
 
  if (node_scan->prev != NULL)
    node_scan->prev->next = node_scan->next;
 
  if (node_scan->next != NULL)
     node_scan->next->prev = node_scan->prev;
 
  /* if first node, then transfer childness to next one, even if null */
  if (node_scan->prev == NULL)
    node_scan->parent->child = node_scan->next;
 
  current_node = node_scan->parent;
  
  analyse_GUI_tree_rebuild();
 
}

analyse_write_f()

void analyse_write_f

(

char *

message

)

Definition at line 1022 of file analyse.c.

{
  int nb_int;
  int *tab_int=NULL;
 
  analyse_convert_string_to_int(message, &nb_int, &tab_int);
 
//  wif(&nb_int, tab_int);
 
  analyse_free(tab_int);
}

ANCHECK()

void _FCALL ANCHECK

(

int *

id

)

Definition at line 832 of file analyse.c.

{
  analyse_call_check(*id);
}

ancheck()

void ancheck

(

int *

id

)

Definition at line 817 of file analyse.c.

{
  analyse_call_check(*id);
}

ancheck_()

void ancheck_

(

int *

id

)

Definition at line 822 of file analyse.c.

{
  analyse_call_check(*id);
}

ancheck__()

void ancheck__

(

int *

id

)

Definition at line 827 of file analyse.c.

{
  analyse_call_check(*id);
}

ANCLOSE()

void _FCALL ANCLOSE

(

int *

name_id

)

Definition at line 509 of file analyse.c.

{
 analyse_tree_close(*name_id);
}

anclose()

void anclose

(

int *

name_id

)

Definition at line 495 of file analyse.c.

{
  analyse_tree_close(*name_id);
}

anclose_()

void anclose_

(

int *

name_id

)

Definition at line 500 of file analyse.c.

{
  analyse_tree_close(*name_id);
}

anclose__()

void anclose__

(

int *

name_id

)

Definition at line 505 of file analyse.c.

{
  analyse_tree_close(*name_id);
}

ANCNTG()

void _FCALL ANCNTG	(	int *	id,
		int *	global_cnt,
		int *	tmp_cnt )

Definition at line 1016 of file analyse.c.

{
  analyse_error_get_cnt(analyse_error_list, *id, global_cnt, tmp_cnt);
}

ancntg()

void ancntg	(	int *	id,
		int *	global_cnt,
		int *	tmp_cnt )

Definition at line 1001 of file analyse.c.

{
  analyse_error_get_cnt(analyse_error_list, *id, global_cnt, tmp_cnt);
} 

ancntg_()

void ancntg_	(	int *	id,
		int *	global_cnt,
		int *	tmp_cnt )

Definition at line 1006 of file analyse.c.

{
  analyse_error_get_cnt(analyse_error_list, *id, global_cnt, tmp_cnt);
} 

ancntg__()

void ancntg__	(	int *	id,
		int *	global_cnt,
		int *	tmp_cnt )

Definition at line 1011 of file analyse.c.

{
  analyse_error_get_cnt(analyse_error_list, *id, global_cnt, tmp_cnt);
} 

ANCNTS()

void _FCALL ANCNTS	(	int *	id,
		int *	value )

Definition at line 995 of file analyse.c.

{
  analyse_error_set_tmp_cnt(analyse_error_list, *id, *value);
}

ancnts()

void ancnts	(	int *	id,
		int *	value )

Definition at line 980 of file analyse.c.

{
  analyse_error_set_tmp_cnt(analyse_error_list, *id, *value);
}

ancnts_()

void ancnts_	(	int *	id,
		int *	value )

Definition at line 985 of file analyse.c.

{
  analyse_error_set_tmp_cnt(analyse_error_list, *id, *value);
}

ancnts__()

void ancnts__	(	int *	id,
		int *	value )

Definition at line 990 of file analyse.c.

{
  analyse_error_set_tmp_cnt(analyse_error_list, *id, *value);
}

ANENTER()

void _FCALL ANENTER

(

int *

name_id

)

Definition at line 460 of file analyse.c.

{
 analyse_tree_enter(*name_id);
}

anenter()

void anenter

(

int *

name_id

)

Definition at line 450 of file analyse.c.

{
  analyse_tree_enter(*name_id);
}

anenter_()

void anenter_

(

int *

name_id

)

Definition at line 455 of file analyse.c.

{
  analyse_tree_enter(*name_id);
}

ANEXIT()

void _FCALL ANEXIT

(

int *

name_id

)

Definition at line 570 of file analyse.c.

{
 analyse_tree_exit(*name_id);
}

anexit()

void anexit

(

int *

name_id

)

Definition at line 556 of file analyse.c.

{
  analyse_tree_exit(*name_id);
}

anexit_()

void anexit_

(

int *

name_id

)

Definition at line 561 of file analyse.c.

{
  analyse_tree_exit(*name_id);
}

anexit__()

void anexit__

(

int *

name_id

)

Definition at line 566 of file analyse.c.

{
  analyse_tree_exit(*name_id);
}

ANINIT()

void _FCALL ANINIT	(	int *	prgrm,
		int *	GUI_mode )

Definition at line 960 of file analyse.c.

{
  analyse_init(*prgrm, *GUI_mode, ANALYSE_ENGLISH);
}

aninit()

void aninit	(	int *	prgrm,
		int *	GUI_mode )

Definition at line 945 of file analyse.c.

{
  analyse_init(*prgrm, *GUI_mode, ANALYSE_ENGLISH);
}

aninit_()

void aninit_	(	int *	prgrm,
		int *	GUI_mode )

Definition at line 950 of file analyse.c.

{
  analyse_init(*prgrm, *GUI_mode, ANALYSE_ENGLISH);
}

aninit__()

void aninit__	(	int *	prgrm,
		int *	GUI_mode )

Definition at line 955 of file analyse.c.

{
  analyse_init(*prgrm, *GUI_mode, ANALYSE_ENGLISH);
}

ANSTCKF()

void _FCALL ANSTCKF

(

float *

r

)

Definition at line 324 of file analyse.c.

{
  analyse_stack_float(*r);
}

anstckf()

void anstckf

(

float *

r

)

Definition at line 309 of file analyse.c.

{
  analyse_stack_float(*r);
}

anstckf_()

void anstckf_

(

float *

r

)

Definition at line 314 of file analyse.c.

{
  analyse_stack_float(*r);
}

anstckf__()

void anstckf__

(

float *

r

)

Definition at line 319 of file analyse.c.

{
  analyse_stack_float(*r);
}

ANSTCKI()

void _FCALL ANSTCKI

(

int *

i

)

Definition at line 358 of file analyse.c.

{
  analyse_stack_int(*i);
}

anstcki()

void anstcki

(

int *

i

)

Definition at line 348 of file analyse.c.

{
  analyse_stack_int(*i);
}

anstcki_()

void anstcki_

(

int *

i

)

Definition at line 353 of file analyse.c.

{
  analyse_stack_int(*i);
}

manage_Core()

void manage_Core ( int s )

static

Definition at line 255 of file analyse.c.

{
  int nb_int;
  int *tab_int=NULL;
 
  char stop_message[]="\n\n %s STOPPED due to CORE DUMPED";
  char *message;
 
/*  setIgnoreCore (0); */
  
  /* Create Message */
  message = (char *)analyse_malloc((strlen(analyse_tree->info.calling_name)+strlen(stop_message)+1)*sizeof(char));
  sprintf(message,stop_message,analyse_tree->info.calling_name);
 
 
  /* Print Message On SCREEN and IN L00 FILE */
  analyse_convert_string_to_int(message, &nb_int, &tab_int);
 
  wistdo(&nb_int, tab_int);
  wiout(&nb_int, tab_int);
  
  analyse_free(tab_int);
 
  /* start GUI */
  analyse_GUI_add_error_message(message);
  analyse_free(message);
 
  analyse_GUI_start_loop();
 
  /* quit Program */
  analyse_quit();
 
}

MY_EXIT()

void _FCALL MY_EXIT

(

int *

i

)

Definition at line 1050 of file analyse.c.

{ my_exit(i); }

my_exit()

void my_exit

(

int *

i

)

Definition at line 1038 of file analyse.c.

{ 
  qaclose_();
  exit(*i); 
}

my_exit_()

void my_exit_

(

int *

i

)

Definition at line 1044 of file analyse.c.

{ my_exit(i); }

my_exit__()

void my_exit__

(

int *

i

)

Definition at line 1047 of file analyse.c.

{ my_exit(i); }

qaclose_()

void qaclose_

(

)

remove_all_in_node_recursiv()

void remove_all_in_node_recursiv ( analyse_node_t * node_scan )

static

Definition at line 224 of file analyse.c.

{
  if (node_scan == NULL)
    return;
 
  remove_all_in_node_recursiv(node_scan->next);
  node_scan->next=NULL;
 
  remove_all_in_node_recursiv(node_scan->child);
  node_scan->child = NULL;
 
  remove_node_data(node_scan);
  remove_node_structure(node_scan);
 
  if (node_scan->prev != NULL)
    node_scan->prev->next=NULL;
}

remove_data_in_node_recursiv()

void remove_data_in_node_recursiv ( analyse_node_t * node_scan )

static

Definition at line 242 of file analyse.c.

{
  if (node_scan == NULL)
    return;
 
  remove_data_in_node_recursiv(node_scan->next);
  remove_data_in_node_recursiv(node_scan->child);
 
  remove_node_data(node_scan);
}

remove_node_data()

void remove_node_data ( analyse_node_t * node_scan )

static

Definition at line 159 of file analyse.c.

{
  int nb_to_move, i;
 
  /* Free float datas */
  if (node_scan->info.nb_float_data != 0)
    {
      nb_to_move = float_stack_scan - (node_scan->info.float_data_offset_start + node_scan->info.nb_float_data);
      
      for(i=0; i <nb_to_move; i++)
    {
      float_stack[node_scan->info.float_data_offset_start+i] = float_stack[node_scan->info.float_data_offset_start + node_scan->info.nb_float_data+i];
    }
      
      float_stack_current = float_stack_current - node_scan->info.nb_float_data;
      float_stack_scan = float_stack_scan - node_scan->info.nb_float_data;
 
      node_scan->info.nb_float_data=0;
    }
  
  /* Free int datas */
  if (node_scan->info.nb_int_data != 0)
    {
      nb_to_move = int_stack_scan - (node_scan->info.int_data_offset_start + node_scan->info.nb_int_data);
      
      for(i=0; i <nb_to_move; i++)
    {
      int_stack[node_scan->info.int_data_offset_start+i] = int_stack[node_scan->info.int_data_offset_start + node_scan->info.nb_int_data+i];
    }
            
      int_stack_current = int_stack_current - node_scan->info.nb_int_data;
      int_stack_scan = int_stack_scan - node_scan->info.nb_int_data;
 
      node_scan->info.nb_int_data=0;
    }
 
}

remove_node_structure()

void remove_node_structure ( analyse_node_t * node_scan )

static

Definition at line 198 of file analyse.c.

{
  /* Free structure in list */
  if (node_scan == last_node_in_list)
    {
      last_node_in_list = last_node_in_list->list_prev;     
    }
  else
    {
      if (node_scan->list_prev != NULL)
    node_scan->list_prev->list_next = node_scan->list_next;
      
      if (node_scan->list_next != NULL)
    node_scan->list_next->list_prev = node_scan->list_prev;
      
      node_scan->list_prev = last_node_in_list;
      node_scan->list_next = last_node_in_list->list_next;
 
      last_node_in_list->list_next = node_scan;  
    }
 
  first_free_in_list = node_scan;
 
}

search_for_node_with_id()

analyse_node_t * search_for_node_with_id ( int name_id )

static

Definition at line 114 of file analyse.c.

{
  analyse_node_t *node_scan;
 
  node_scan = current_node;
 
  while ( node_scan->info.calling_id != name_id)
    {
      if (node_scan->parent == NULL)
    return NULL;
 
      node_scan = node_scan->parent;
    }
 
  return node_scan;
}

store_info_in_node_list()

void store_info_in_node_list ( analyse_info_t * analyse_info )

static

Definition at line 131 of file analyse.c.

{   
  if ( first_free_in_list != NULL)
    {
      first_free_in_list->info = *analyse_info;
      
      first_free_in_list->parent = NULL;
      first_free_in_list->child = NULL;
      first_free_in_list->next = NULL;
      first_free_in_list->prev = NULL;
 
      last_node_in_list = first_free_in_list;
      first_free_in_list = first_free_in_list->list_next;
    }
  else
    {
      last_node_in_list->list_next = (analyse_node_t *)analyse_malloc(sizeof(analyse_node_t));
      
      analyse_node_init(last_node_in_list->list_next);
 
      last_node_in_list->list_next->list_prev = last_node_in_list;      
      last_node_in_list->list_next->info = *analyse_info;
      
      last_node_in_list=last_node_in_list->list_next;
    }
}

Variable Documentation

analyse_check_group_list

analyse_check_group_t* analyse_check_group_list =NULL

static

Definition at line 77 of file analyse.c.

analyse_check_list

analyse_check_t* analyse_check_list =NULL

static

Definition at line 78 of file analyse.c.

analyse_error_list

analyse_error_info_t* analyse_error_list =NULL

static

Definition at line 75 of file analyse.c.

analyse_tree

analyse_node_t* analyse_tree =NULL

Definition at line 69 of file analyse.c.

current_node

analyse_node_t* current_node =NULL

static

Definition at line 71 of file analyse.c.

current_node_child_sav

analyse_node_t* current_node_child_sav = NULL

static

Definition at line 81 of file analyse.c.

first_free_in_list

analyse_node_t* first_free_in_list =NULL

static

Definition at line 73 of file analyse.c.

float_stack

float* float_stack =NULL

static

Definition at line 64 of file analyse.c.

float_stack_current

int float_stack_current =0

static

Definition at line 66 of file analyse.c.

float_stack_scan

int float_stack_scan =0

static

Definition at line 67 of file analyse.c.

float_stack_size

int float_stack_size =0

static

Definition at line 65 of file analyse.c.

int_stack

int* int_stack =NULL

static

Definition at line 59 of file analyse.c.

int_stack_current

int int_stack_current =0

static

Definition at line 61 of file analyse.c.

int_stack_scan

int int_stack_scan =0

static

Definition at line 62 of file analyse.c.

int_stack_size

int int_stack_size =0

static

Definition at line 60 of file analyse.c.

LANGUAGE

int LANGUAGE

static

Definition at line 57 of file analyse.c.

last_node_in_list

analyse_node_t* last_node_in_list =NULL

static

Definition at line 72 of file analyse.c.

node_scan_sav

analyse_node_t* node_scan_sav = NULL

static

Definition at line 82 of file analyse.c.