source: SH_SHM/trunk/source/globalparams.c @ 64

Revision 64, 41.8 KB checked in by marcus, 14 years ago (diff)

r49 | svn | 2008-10-14 22:36:40 +0200 (Di, 14 Okt 2008) | 1 line

autoevt: filter depending on distance; appropriate variables in globalparams.h

Line 
1
2/* file globalparams.c
3 *      ==============
4 *
5 * $Revision: 49 $, $Date: 2008-10-14 22:36:40 +0200 (Di, 14 Okt 2008) $
6 *
7 * Management of global parameters
8 * K. Stammler, 9-May-2006
9 */
10
11
12/*
13 *
14 *  SeismicHandler, seismic analysis software
15 *  Copyright (C) 1992,  Klaus Stammler, Federal Institute for Geosciences
16 *                                       and Natural Resources (BGR), Germany
17 *
18 *  This program is free software; you can redistribute it and/or modify
19 *  it under the terms of the GNU General Public License as published by
20 *  the Free Software Foundation; either version 2 of the License, or
21 *  (at your option) any later version.
22 *
23 *  This program is distributed in the hope that it will be useful,
24 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
25 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
26 *  GNU General Public License for more details.
27 *
28 *  You should have received a copy of the GNU General Public License
29 *  along with this program; if not, write to the Free Software
30 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
31 *
32 */
33
34
35#include <stdio.h>
36#include <string.h>
37#include "basecnst.h"
38#ifdef BC_INC_STDLIB
39#include BC_INC_STDLIB
40#endif
41#include "utusrdef.h"
42#include "globalparams.h"
43
44
45/* local types */
46typedef struct _string_elem {
47        struct _string_elem   *next;  /* pointer to next string element */
48        char             *string;     /* string values */
49        int              strlth;      /* string length excl. term null */
50} TGpStringElem;
51
52
53
54/* integer variables
55 * -----------------
56 */
57
58static char *gpv_i_name[] = {
59        "debug_level",
60        "parfile_version",
61        "parfile_subversion",
62        "min_drag_box_width",
63        "double_click_time",
64        "x_max_drawlth",
65        "drag_box_rubber_val",
66        "default_quality",
67        "default_event_type",
68        "default_phase_flags",
69        "default_depth_type",
70        "default_loc_quality",
71        "max_cursor_form",
72        "top_margin",
73        "parameter_box_x",
74        "parameter_box_y",
75        "parameter_box_w",
76        "parameter_box_h",
77        "phase_box_x",
78        "phase_box_y",
79        "phase_box_w",
80        "phase_box_h",
81        "window_main_x",
82        "window_main_y",
83        "window_main_w",
84        "window_main_h",
85        "single_trace_box_x",
86        "single_trace_box_y",
87        "single_trace_box_w",
88        "single_trace_box_h",
89        "window_border",
90        "draw_area_width",
91        "draw_area_height",
92        "trace_normalisation",
93        "spectrogram_width",
94        "spectrogram_step",
95        "keysym_arrow_up",
96        "keysym_arrow_down",
97        "keysym_arrow_left",
98        "keysym_arrow_right",
99        "i_last_parameter"
100};
101
102/* default values if no parameter file is found */
103static int gpv_i_glob[cGpI_last+1] = {
104        0,    /* debug_level */
105        0,    /* parfile_version */
106        0,    /* parfile_subversion */
107        7,    /* min_drag_box_width */
108        200,  /* double_click_time */
109        4096, /* x_max_drawlth */
110        10,   /* drag_box_rubber_val */
111        2,    /* default_quality */
112        0,    /* default_phase_type */
113        0,    /* default_phase_flags */
114        0,    /* default_depth_type */
115        0,    /* default_loc_quality */
116        5,    /* max_cursor_form */
117        20,   /* top margin */
118        93,   /* parameter_box_x */
119        0,    /* parameter_box_y */
120        125,  /* parameter_box_w */
121        700,  /* parameter_box_h */
122        -38,  /* phase_box_x */
123        0,    /* phase_box_y */
124        155,  /* phase_box_w */
125        720,  /* phase_box_h */
126        224,  /* window_main_x */
127        220,  /* window_main_y */
128        1039, /* window_main_w */
129        516,  /* window_main_h */
130        224,  /* single_trace_box_x */
131        0,    /* single_trace_box_y */
132        1039, /* single_trace_box_w */
133        203,  /* single_trace_box_h */
134        3,    /* window_border */
135        1035, /* draw_area_width */
136        485,  /* draw_area_height */
137        0,    /* trace_normalisation */
138        1024, /* spectrogram_width */
139        4,    /* spectrogram_step */
140        268762962, /* keysym_arrow_up */
141        268762964, /* keysym_arrow_down */
142        268762961, /* keysym_arrow_left */
143        268762963, /* keysym_arrow_right */
144        0     /* last parameter */
145};
146
147
148/* float variables
149 * -----------------
150 */
151
152static char *gpv_f_name[] = {
153        "close_phase_resol",
154        "phase_ampl_diff",
155        "trace_zoom_base",
156        "trace_zoom_exp",
157        "area_zoom_base",
158        "area_zoom_exp",
159        "move_wdw_step",
160        "default_depth",
161        "colour_fg_red",
162        "colour_fg_green",
163        "colour_fg_blue",
164        "colour_bg_red",
165        "colour_bg_green",
166        "colour_bg_blue",
167        "colour_dialog_fg_red",
168        "colour_dialog_fg_green",
169        "colour_dialog_fg_blue",
170        "colour_dialog_bg0_red",
171        "colour_dialog_bg0_green",
172        "colour_dialog_bg0_blue",
173        "colour_dialog_bg1_red",
174        "colour_dialog_bg1_green",
175        "colour_dialog_bg1_blue",
176        "colour_dialog_bg2_red",
177        "colour_dialog_bg2_green",
178        "colour_dialog_bg2_blue",
179        "colour_mark_red",
180        "colour_mark_green",
181        "colour_mark_blue",
182        "colour_mark0_red",
183        "colour_mark0_green",
184        "colour_mark0_blue",
185        "colour_theo_red",
186        "colour_theo_green",
187        "colour_theo_blue",
188        "colour_auto_red",
189        "colour_auto_green",
190        "colour_auto_blue",
191        "colour_crsr_red",
192        "colour_crsr_green",
193        "colour_crsr_blue",
194        "colour_alert_red",
195        "colour_alert_green",
196        "colour_alert_blue",
197        "colour_addfil_red",
198        "colour_addfil_green",
199        "colour_addfil_blue",
200        "calib_wdw_width",
201        "calib_wdw_height",
202        "calib_azimuth_grid",
203        "calib_slowness_grid",
204        "sn_noise_start",
205        "sn_noise_end",
206        "sn_signal_start",
207        "sn_signal_end",
208        "idphases_tol_trav",
209        "idphases_tol_travsurf",
210        "idphases_tol_slow",
211        "idphases_tol_azim",
212        "axis_label_rounding",
213        "autofilter_sepdist",
214        "f_last_parameter"
215};
216
217static float gpv_f_glob[cGpF_last+1] = {
218        8.0,       /* close_phase_resol */
219        60.0,      /* phase_ampl_diff */
220        10.0,      /* trace_zoom_base */
221        3.3333333, /* trace_zoom_exp */
222        10.0,      /* area_zoom_base */
223        25.0,      /* area_zoom_exp */
224        1.0,       /* move_wdw_step */
225        33.0,      /* default_depth */
226        0.0,       /* colour_fg_red */
227        0.0,       /* colour_fg_green */
228        0.0,       /* colour_fg_blue */
229        1.0,       /* colour_bg_red */
230        1.0,       /* colour_bg_green */
231        1.0,       /* colour_bg_blue */
232        0.3882,    /* colour_dialog_fg_red */
233        0.1569,    /* colour_dialog_fg_green */
234        0.1647,    /* colour_dialog_fg_blue */
235        0.9686,    /* colour_dialog_bg0_red */
236        0.8706,    /* colour_dialog_bg0_green */
237        0.7412,    /* colour_dialog_bg0_blue */
238        0.9490,    /* colour_dialog_bg1_red */
239        0.6941,    /* colour_dialog_bg1_green */
240        0.4314,    /* colour_dialog_bg1_blue */
241        0.3882,    /* colour_dialog_bg2_red */
242        0.1569,    /* colour_dialog_bg2_green */
243        0.1647,    /* colour_dialog_bg2_blue */
244        1.0,       /* colour_mark_red */
245        0.0,       /* colour_mark_green */
246        0.0,       /* colour_mark_blue */
247        1.0,       /* colour_mark0_red */
248        0.7,       /* colour_mark0_green */
249        0.7,       /* colour_mark0_blue */
250        0.0,       /* colour_theo_red */
251        1.0,       /* colour_theo_green */
252        0.0,       /* colour_theo_blue */
253        1.0,       /* colour_auto_red */
254        0.5,       /* colour_auto_green */
255        0.5,       /* colour_auto_blue */
256        0.0,       /* colour_crsr_red */
257        0.0,       /* colour_crsr_green */
258        1.0,       /* colour_crsr_blue */
259        0.9,       /* colour_alert_red */
260        0.0,       /* colour_alert_green */
261        0.0,       /* colour_alert_blue */
262        0.6,       /* colour_addfil_red */
263        0.0,       /* colour_addfil_green */
264        0.25,      /* colour_addfil_blue */
265        2.5,       /* calib_wdw_width */
266        2.5,       /* calib_wdw_height */
267        10.0,      /* calib_azimuth_grid */
268        0.5,       /* calib_slowness_grid */
269        -13.0,     /* sn_noise_start */
270        -3.0,      /* sn_noise_end */
271        -1.0,      /* sn_signal_start */
272        9.0,       /* sn_signal_end */
273        20.0,      /* idphases_tol_trav */
274        1200.0,    /* idphases_tol_travsurf */
275        1.5,       /* idphases_tol_slow */
276        20.0,      /* idphases_tol_azim */
277        0.01,      /* axis_label_rounding */
278        5.0,       /* autofilter_sepdist */
279        0.0        /* last parameter */
280};
281
282
283/* char variables
284 * -----------------
285 */
286
287static char *gpv_c_name[] = {
288        "filter_type",
289        "c_last_parameter"
290};
291
292static char gpv_c_glob[cGpC_last+1] = {
293        ' ',       /* filter_type */
294        ' '        /* last parameter */
295};
296
297
298/* string variables
299 * -----------------
300 */
301
302static char *gpv_s_name[] = {
303        "defpath_events",
304        "defpath_gse",
305        "defpath_ah",
306        "defpath_q",
307        "defpath_evid",
308        "defpath_evtout",
309        "defpath_data",
310        "defpath_help",
311        "defpath_errors",
312        "defpath_userdir",
313        "defpath_extprog",
314        "analyst",
315        "list_of_analysts",
316        "texteditor",
317        "refstation",
318        "list_of_refstations",
319        "default_filter",
320        "minmax_format",
321        "default_source",
322        "auto_phase",
323        "depth_phase_list",
324        "theo_phase_list",
325        "diff_phase_list",
326        "event_check_proc",
327        "screendump_proc",
328        "evtview_proc",
329        "reformat_proc",
330        "final_proc",
331        "motif_log",
332        "ftp_address",
333        "ftp_path",
334        "exclusive_agency",
335        "sfdb_command",
336        "sfdb_exec_qual",
337        "sfdb_trailer",
338        "autofilter_local",
339        "autofilter_tele",
340        "s_last_parameter"
341};
342
343static char gpv_s_glob[cGpS_last+1][cGp_TEXTVARLTH+1] = {
344        "default",                       /* defpath_events */
345        "default",                       /* defpath_gse */
346        "default",                       /* defpath_ah */
347        "default",                       /* defpath_q */
348        "default",                       /* defpath_evid */
349        "default",                       /* defpath_evtout */
350        "default",                       /* defpath_data */
351        "default",                       /* defpath_help */
352        "default",                       /* defpath_errors */
353        "default",                       /* defpath_userdir */
354        "default",                       /* defpath_extprog */
355        "",                              /* analyst */
356        "",                              /* list_of_analysts */
357        "xedit",                         /* texteditor */
358        "CENTRE",                        /* refstation */
359        "GRA1,MOX,GRFO,GEC2,CENTRE,---", /* list_of_refstations */
360        "",                              /* default_filter*/
361        "",                              /* minmax_format */
362        "UNDEF",                         /* default_source */
363        "beam",                          /* auto_phase */
364        "pP,sP,pS,sS",                   /* depth_phase_list */
365        "P,S,pP,pS,sP,sS,ScS,PcP,PP,SS", /* theo_phase_list */
366        "S-P,PP-P,Pg-Pn",                /* diff_phase_list */
367        "",                              /* event_check_proc */
368        "screendump.csh",                /* screendump_proc */
369        "ev2view",                       /* evtview_proc */
370        "undefined",                     /* reformat_proc */
371        "",                              /* final_proc */
372        "",                              /* motif_log */
373        "ftp.szgrf.bgr.de",              /* ftp_address */
374        "pub/software/shm",              /* ftp_path */
375        "",                              /* exclusive_agency */
376        "mysql sfdb",                    /* sfdb_command */
377        "-B -e",                         /* sfdb_exec_qual */
378        "",                              /* sfdb_trailer */
379        "SHM_BP_1HZ_8HZ_4",              /* autofilter_local */
380        "S+G_WWSSN_SP",                  /* autofilter_tele */
381        "s_last_parameter"               /* last parameter */
382};
383
384
385/* boolean variables
386 * -----------------
387 */
388
389static char *gpv_b_name[] = {
390        "top_down_order",
391        "auto_pick_first",
392        "auto_scaling",
393        "prompt_analyst",
394        "reverse_xors",
395        "full_phase_names",
396        "own_accelerators",
397        "small_menu_font",
398        "recover_evid",
399        "overwrite_string_lists",
400        "ignore_data_lock",
401        "reads_swap",
402        "reads_invhdr",
403        "autosort_by_distance",
404        "autofilter_by_distance",
405        "b_last_parameter"
406};
407
408static long gpv_b_glob =
409        (1 << cGpB_autopick_first)         |
410        (1 << cGpB_auto_scaling)           |
411        (1 << cGpB_overwrite_string_lists) |
412        (1 << cGpB_own_accelerators)       |
413        (1 << cGpB_autosort_by_distance)   |
414        (1 << cGpB_autofilter_by_distance) |
415        (1 << cGpB_reads_swap)
416;
417
418
419/* string list variables
420 * ---------------------
421 */
422
423static char *gpv_l_name[] = {
424        "station_info_file",
425        "filter_lookup_table",
426        "sensitivity_file",
427        "defpath_filter",
428        "defpath_command",
429        "defpath_globals",
430        "l_last_parameter"
431};
432
433static TGpStringElem gpv_l_glob[cGpL_last+1] = {
434        {NULL,"default",7},            /* station_info_file */
435        {NULL,"default",7},            /* filter_lookup_table */
436        {NULL,"default",7},            /* sensitivity_file */
437        {NULL,"default",7},            /* defpath_filter */
438        {NULL,"default",7},            /* defpath_command */
439        {NULL,"default",7},            /* defpath_globals */
440        {NULL,"",0}                    /* last parameter */
441};
442
443
444/* prototypes of local routines */
445static void GpReadParametersFromFile( char fname[] );
446static void GpEvaluateVar( char val[] );
447
448
449/*----------------------------------------------------------------------------*/
450
451
452
453void GpReadParfile( void )
454
455/* Reads parameters from file
456 *
457 * no parameters passed
458 */
459{
460        /* local variables */
461        char     *env;               /* pointer to environment */
462        char     parfile[cBcFileLth+1]; /* name of parameter file */
463        char     *cptr;              /* char pointer */
464        int      i;                  /* counter */
465
466        /* executable code */
467
468        /* get parameter file */
469        env = (char *)getenv( "SH_USER_PARAM" );
470        if  (env == NULL)  {
471                env = (char *)getenv( "SH_INPUTS" );
472                if  (strlen(env) < cBcFileLth-15)  {
473                        strcpy( parfile, env );
474                        strcat( parfile, "/shm-config.txt" );
475                } else {
476                        fprintf( stderr, "configuration filename too long.  Abort.\n" );
477                        exit( 1 );
478                } /*endif*/
479        } else {
480                if  (strlen(env) < cBcFileLth)  {
481                        strcpy( parfile, env );
482                } else {
483                        fprintf( stderr, "environment SH_USER_PARAM too long.  Abort.\n" );
484                        exit( 1 );
485                } /*endif*/
486        } /*endif*/
487
488        GpReadParametersFromFile( parfile );
489
490        /* set 'default' strings */
491        if  (strcmp(gpv_s_glob[cGpS_defpath_events],"default") == 0)  {
492                cptr = (char *)getenv( "HOME" );
493                if  (cptr == NULL)  {printf("HOME not defined\n"); exit(1);}
494                if  (strlen(cptr) < cGp_TEXTVARLTH)
495                        strcpy( gpv_s_glob[cGpS_defpath_events], cptr );
496        } /*endif*/
497        if  (strcmp(gpv_s_glob[cGpS_defpath_gse],"default") == 0)  {
498                cptr = (char *)getenv( "SH_ROOT" );
499                if  (cptr == NULL)  {printf("SH_ROOT not defined\n"); exit(1);}
500                if  (strlen(cptr) < cGp_TEXTVARLTH-21)  {
501                        strcpy( gpv_s_glob[cGpS_defpath_gse], cptr );
502                        strcat( gpv_s_glob[cGpS_defpath_gse], "/data-examples/gse" );
503                } /*endif*/
504        } /*endif*/
505        if  (strcmp(gpv_s_glob[cGpS_defpath_ah],"default") == 0)  {
506                cptr = (char *)getenv( "HOME" );
507                if  (cptr == NULL)  {printf("HOME not defined\n"); exit(1);}
508                if  (strlen(cptr) < cGp_TEXTVARLTH)
509                        strcpy( gpv_s_glob[cGpS_defpath_ah], cptr );
510        } /*endif*/
511        if  (strcmp(gpv_s_glob[cGpS_defpath_q],"default") == 0)  {
512                cptr = (char *)getenv( "HOME" );
513                if  (cptr == NULL)  {printf("HOME not defined\n"); exit(1);}
514                if  (strlen(cptr) < cGp_TEXTVARLTH)
515                        strcpy( gpv_s_glob[cGpS_defpath_q], cptr );
516        } /*endif*/
517        if  (strcmp(gpv_s_glob[cGpS_defpath_evid],"default") == 0)  {
518                cptr = (char *)getenv( "SH_PRIVATE" );
519                if  (cptr == NULL)  cptr = (char *)getenv( "HOME" );
520                if  (cptr == NULL)  {printf("HOME not defined\n"); exit(1);}
521                if  (strlen(cptr) < cGp_TEXTVARLTH-6)  {
522                        strcpy( gpv_s_glob[cGpS_defpath_evid], cptr );
523                        strcat( gpv_s_glob[cGpS_defpath_evid], "/evid/" );
524                } /*endif*/
525        } /*endif*/
526        if  (strcmp(gpv_s_glob[cGpS_defpath_evtout],"default") == 0)  {
527                cptr = (char *)getenv( "SH_PRIVATE" );
528                if  (cptr == NULL)  cptr = (char *)getenv( "HOME" );
529                if  (cptr == NULL)  {printf("HOME not defined\n"); exit(1);}
530                if  (strlen(cptr) < cGp_TEXTVARLTH-8)  {
531                        strcpy( gpv_s_glob[cGpS_defpath_evtout], cptr );
532                        strcat( gpv_s_glob[cGpS_defpath_evtout], "/evtout/" );
533                } /*endif*/
534        } /*endif*/
535        if  (strcmp(gpv_s_glob[cGpS_defpath_help],"default") == 0)  {
536                cptr = (char *)getenv( "SH_ROOT" );
537                if  (cptr == NULL)  cptr = (char *)getenv( "HOME" );
538                if  (cptr == NULL)  {printf("HOME not defined\n"); exit(1);}
539                if  (strlen(cptr) < cGp_TEXTVARLTH-6)  {
540                        strcpy( gpv_s_glob[cGpS_defpath_help], cptr );
541                        strcat( gpv_s_glob[cGpS_defpath_help], "/help/" );
542                } /*endif*/
543        } /*endif*/
544        if  (strcmp(gpv_s_glob[cGpS_defpath_errors],"default") == 0)  {
545                cptr = (char *)getenv( "SH_ROOT" );
546                if  (cptr == NULL)  cptr = (char *)getenv( "HOME" );
547                if  (cptr == NULL)  {printf("HOME not defined\n"); exit(1);}
548                if  (strlen(cptr) < cGp_TEXTVARLTH-8)  {
549                        strcpy( gpv_s_glob[cGpS_defpath_errors], cptr );
550                        strcat( gpv_s_glob[cGpS_defpath_errors], "/errors/" );
551                } /*endif*/
552        } /*endif*/
553        if  (strcmp(gpv_s_glob[cGpS_defpath_userdir],"default") == 0)  {
554                /* the usage of SH_USERDIR is for backward compatibility */
555                cptr = (char *)getenv( "SH_USERDIR" );
556                if  (cptr == NULL)  {
557                        cptr = (char *)getenv( "HOME" );
558                        if  (cptr == NULL)  {printf("HOME not defined\n"); exit(1);}
559                        if  (strlen(cptr) < cGp_TEXTVARLTH-17)  {
560                                strcpy( gpv_s_glob[cGpS_defpath_userdir], cptr );
561                                strcat( gpv_s_glob[cGpS_defpath_userdir], "/shfiles/private/" );
562                        } /*endif*/
563                } else {
564                        if  (strlen(cptr) < cGp_TEXTVARLTH)
565                                strcpy( gpv_s_glob[cGpS_defpath_userdir], cptr );
566                } /*endif*/
567        } /*endif*/
568        if  (strcmp(gpv_s_glob[cGpS_defpath_extprog],"default") == 0)  {
569                /* the usage of SH_UTIL is for backward compatibility */
570                cptr = (char *)getenv( "SH_UTIL" );
571                if  (cptr == NULL)  {
572                        cptr = (char *)getenv( "HOME" );
573                        if  (cptr == NULL)  {printf("HOME not defined\n"); exit(1);}
574                        if  (strlen(cptr) < cGp_TEXTVARLTH-17)  {
575                                strcpy( gpv_s_glob[cGpS_defpath_extprog], cptr );
576                                strcat( gpv_s_glob[cGpS_defpath_extprog], "/util/" );
577                        } /*endif*/
578                } else {
579                        if  (strlen(cptr) < cGp_TEXTVARLTH)
580                                strcpy( gpv_s_glob[cGpS_defpath_extprog], cptr );
581                } /*endif*/
582        } /*endif*/
583
584        /* 'default' in string lists */
585        if  (strcmp(gpv_l_glob[cGpL_station_info_file].string,"default") == 0)  {
586                cptr = (char *)getenv( "SH_INPUTS" );
587                if  (cptr != NULL)  {
588                        i = strlen( cptr );
589                        /* "default" value is set by variable initialisation, can't free it */
590                        /*free( gpv_l_glob[cGpL_station_info_file].string );*/
591                        gpv_l_glob[cGpL_station_info_file].string =
592                                (char *)malloc( (int)sizeof(char)*(i+12) );
593                        strcpy( gpv_l_glob[cGpL_station_info_file].string, cptr );
594                        strcat( gpv_l_glob[cGpL_station_info_file].string, "STATINF.DAT" );
595                        gpv_l_glob[cGpL_station_info_file].strlth = i+11;
596                } /*endif*/
597        } /*endif*/
598        if  (strcmp(gpv_l_glob[cGpL_filter_lookup_table].string,"default") == 0)  {
599                cptr = (char *)getenv( "SH_INPUTS" );
600                if  (cptr != NULL)  {
601                        i = strlen( cptr );
602                        /*free( gpv_l_glob[cGpL_filter_lookup_table].string );*/
603                        gpv_l_glob[cGpL_filter_lookup_table].string =
604                                (char *)malloc( (int)sizeof(char)*(i+18) );
605                        strcpy( gpv_l_glob[cGpL_filter_lookup_table].string, cptr );
606                        strcat( gpv_l_glob[cGpL_filter_lookup_table].string, "filter_lookup.txt" );
607                        gpv_l_glob[cGpL_filter_lookup_table].strlth = i+17;
608                } /*endif*/
609        } /*endif*/
610        if  (strcmp(gpv_l_glob[cGpL_sensitivity_file].string,"default") == 0)  {
611                cptr = (char *)getenv( "SH_INPUTS" );
612                if  (cptr != NULL)  {
613                        i = strlen( cptr );
614                        /*free( gpv_l_glob[cGpL_sensitivity_file].string );*/
615                        gpv_l_glob[cGpL_sensitivity_file].string =
616                                (char *)malloc( (int)sizeof(char)*(i+18) );
617                        strcpy( gpv_l_glob[cGpL_sensitivity_file].string, cptr );
618                        strcat( gpv_l_glob[cGpL_sensitivity_file].string, "sensitivities.txt" );
619                        gpv_l_glob[cGpL_sensitivity_file].strlth = i+17;
620                } /*endif*/
621        } /*endif*/
622        if  (strcmp(gpv_l_glob[cGpL_defpath_filter].string,"default") == 0)
623                GpParseStringList( cGpL_defpath_filter, ".,$SH_ROOT/filter" );
624        if  (strcmp(gpv_l_glob[cGpL_defpath_command].string,"default") == 0)
625                GpParseStringList( cGpL_defpath_command, ".,$SH_ROOT/command" );
626        if  (strcmp(gpv_l_glob[cGpL_defpath_globals].string,"default") == 0)
627                GpParseStringList( cGpL_defpath_globals, ".,$SH_ROOT/globals/" );
628
629        /* make some strings uppercase */
630        ut_cap( gpv_s_glob[cGpS_refstation] );
631        ut_cap( gpv_s_glob[cGpS_list_of_refstations] );
632
633        /* check for setting of normalisation */
634        if  (gpv_i_glob[cGpI_trace_normalisation] == cGp_NORM_UNDEF)  {
635                /* trace_normalisation not set take it from 'old' auto_scaling */
636                printf( "--globalparams: warning: auto_scaling obsolete, please set trace_normalisation\n" );
637                gpv_i_glob[cGpI_trace_normalisation] =
638                        (gpv_b_glob & cGpB_auto_scaling) ? cGp_NORM_SW : cGp_NORM_AW;
639        } else {
640                switch  (gpv_i_glob[cGpI_trace_normalisation])  {
641                case cGp_NORM_CONST:  GpSetBoolean( cGpB_auto_scaling, 0 ); break;
642                case cGp_NORM_AW:     GpSetBoolean( cGpB_auto_scaling, 0 ); break;
643                case cGp_NORM_SW:     GpSetBoolean( cGpB_auto_scaling, 1 ); break;
644                default:
645                        printf( "--globalparams: illegal value of trace_normalisation, please correct\n" );
646                        GpSetBoolean( cGpB_auto_scaling, 0 );
647                        gpv_i_glob[cGpI_trace_normalisation] = cGp_NORM_AW;
648                } /*endswitch*/
649        } /*endif*/
650
651        if  (gpv_i_glob[cGpI_parfile_version] == 0)
652                printf( "--globalparams: warning: no version of parameter file found\n" );
653
654} /* end of GpReadParfile */
655
656
657
658/*----------------------------------------------------------------------------*/
659
660
661
662static void GpReadParametersFromFile( char fname[] )
663
664/* reads parametes from file, calls itself on 'include' statement
665 *
666 * parameters of routine
667 * char       fname[];    input; name of file to read
668 */
669{
670        /* local variables */
671        FILE     *fp;                /* pointer to input file */
672        char     line[cBcVeryLongStrLth+1]; /* current line of file */
673        char     name[cBcLineLth+1]; /* variable name */
674        int      namelth;            /* length of name */
675        int      itmp;               /* integer scratch */
676        float    ftmp;               /* float scratch */
677        char     ctmp;               /* char scratch */
678        char     stmp[cBcVeryLongStrLth+1]; /* string scratch */
679        TGpIntIndex  icnt;           /* integer counter */
680        TGpFloatIndex  fcnt;         /* float counter */
681        TGpCharIndex  ccnt;          /* char counter */
682        TGpStringIndex  scnt;        /* string counter */
683        TGpBooleanIndex  bcnt;       /* boolean counter */
684        TGpStringListIndex lcnt;     /* string list counter */
685        int      found;              /* (boolean) parameter found */
686        char     *cptr;              /* char pointer */
687        char     *env;               /* pointer to environment */
688
689        /* executable code */
690
691        if  (GpGetInt(cGpI_debug_level) > 3)
692                printf( "SHM-dbg3: reading parameters from parfile %s\n", fname );
693
694        fp = fopen( fname, "r" );
695        if  (fp == NULL)  {
696                if  (GpGetInt(cGpI_debug_level) > 2)
697                        printf( "SHM-dbg3: parfile %s not found\n", fname );
698                return;
699        } /*endif*/
700
701        while  (fgets(line,cBcVeryLongStrLth,fp) != NULL)  {
702
703                if  (*line == '!' || *line == '#' || *line == '\n')  continue;
704                if  (line[1] == '$')  continue;
705                if  (sscanf(line,"%s",name) != 1)  continue;
706                namelth = strlen( name );
707                if  (strlen(line) < namelth)  {
708                        printf( "--globalparams: empty entry %s, ignore\n", name );
709                        continue;
710                } /*endif*/
711                found = 0;
712
713                /* check for include statement */
714                if  (strcmp(name,"include") == 0)  {
715                        if  (GpGetInt(cGpI_debug_level) > 3)
716                                printf( "SHM-dbg4: include statement found\n", fname );
717                        if  (sscanf(line+namelth,"%s",stmp) != 1)  {
718                                printf( "--globalparams: error reading include in parameter file %s\n",
719                                        fname );
720                        } else {
721                                if  (strlen(stmp) > cGp_TEXTVARLTH)  {
722                                        printf( "--globalparams: include filename %s too long\n", name );
723                                } else {
724                                        /* reentrant call, read from $SH_INPUTS if not absolute */
725                                        if  (*stmp == '/')  {
726                                                /* absolute name, dont't change */
727                                                strcpy( line, stmp );
728                                        } else {
729                                                env = (char *)getenv( "SH_INPUTS" );
730                                                if  (strlen(env)+strlen(stmp)+1 > cBcVeryLongStrLth)  {
731                                                        printf( "--globalparams: string overflow in include statement\n" );
732                                                        continue;
733                                                } /*endif*/
734                                                sprintf( line, "%s/%s", env, stmp );
735                                        } /*endif*/
736                                        GpReadParametersFromFile( line );
737                                } /*endif*/
738                        } /*endif*/
739                        continue;
740                } /*endif*/
741
742                /* check for version number */
743                if  (strcmp(name,"file_version") == 0)  {
744                        if  (sscanf(line+namelth,"%s",stmp) != 1)  {
745                                printf( "--globalparams: error reading version in parameter file %s\n",
746                                        fname );
747                        } else {
748                                if  (strlen(stmp) > cGp_TEXTVARLTH)  {
749                                        printf( "--globalparams: include filename %s too long\n", name );
750                                } else {
751                                        if  (sscanf(stmp,"%d.%d",&itmp,&icnt) == 2)  {
752                                                gpv_i_glob[cGpI_parfile_version] = itmp;
753                                                gpv_i_glob[cGpI_parfile_subversion] = icnt;
754                                                if  (gpv_i_glob[cGpI_parfile_version] > cGp_VERSION
755                                                        || gpv_i_glob[cGpI_parfile_subversion] > cGp_SUBVERSION)  {
756                                                        printf( "--globalparams: warning: file version too new; ");
757                                                        printf( "expect problems while reading\n" );
758                                                        printf( "--globalparams: version %d.%d is expected here\n",
759                                                                cGp_VERSION, cGp_SUBVERSION );
760                                                } else if (gpv_i_glob[cGpI_parfile_version] < cGp_VERSION) {
761                                                        printf( "--globalparams: warning: old parameter file version; ");
762                                                        printf( "consider creating a new one\n" );
763                                                        printf( "--globalparams: version %d.%d is expected here\n",
764                                                                cGp_VERSION, cGp_SUBVERSION );
765                                                } /*endif*/
766                                        } else {
767                                                printf( "--globalparams: error reading parameter version\n" );
768                                        } /*endif*/
769                                } /*endif*/
770                        } /*endif*/
771                        continue;
772                } /*endif*/
773
774                /* integer variables */
775                for  (icnt=0; icnt<cGpI_last; icnt++)
776                        if  (strcmp(gpv_i_name[icnt],name) == 0)  {
777                                if  (sscanf(line+namelth,"%d",&itmp) != 1)  {
778                                        printf( "--globalparams: error reading parameter %s\n", name );
779                                } else {
780                                        gpv_i_glob[icnt] = itmp;
781                                        found = 1;
782                                } /*endif*/
783                                break;
784                        } /*endif*/
785                if  (found)  continue;
786
787                /* float variables */
788                for  (fcnt=0; fcnt<cGpF_last; fcnt++)
789                        if  (strcmp(gpv_f_name[fcnt],name) == 0)  {
790                                if  (sscanf(line+namelth,"%f",&ftmp) != 1)  {
791                                        printf( "--globalparams: error reading parameter %s\n", name );
792                                } else {
793                                        gpv_f_glob[fcnt] = ftmp;
794                                        found = 1;
795                                } /*endif*/
796                                break;
797                        } /*endif*/
798                if  (found)  continue;
799
800                /* char variables */
801                for  (ccnt=0; ccnt<cGpC_last; ccnt++)
802                        if  (strcmp(gpv_c_name[ccnt],name) == 0)  {
803                                /* read first character after blanks and tabs */
804                                cptr = line + namelth;
805                                while  (*cptr == ' ' || *cptr == '\t')  cptr++;
806                                if  (*cptr != '\n' && *cptr != '\0')  {
807                                        gpv_c_glob[ccnt] = *cptr;
808                                        found = 1;
809                                } /*endif*/
810                                break;
811                        } /*endif*/
812                if  (found)  continue;
813
814                /* string variables */
815                for  (scnt=0; scnt<cGpS_last; scnt++)
816                        if  (strcmp(gpv_s_name[scnt],name) == 0)  {
817                                /* skip blanks after keyword and take remaining line as value */
818                                cptr = line + namelth;
819                                while  (*cptr == ' ' || *cptr == '\t')  cptr++;
820                                strcpy( stmp, cptr );
821                                /* drop the linefeed */
822                                itmp = strlen( stmp );
823                                if  (itmp > 0 && stmp[itmp-1] == '\n')  stmp[itmp-1] = '\0';
824                                if  (*stmp == '\0')  {
825                                        printf( "--globalparams: error reading parameter %s\n", name );
826                                } else {
827                                        if  (strlen(stmp) > cGp_TEXTVARLTH)  {
828                                                printf( "--globalparams: string parameter %s too long\n", name );
829                                        } else {
830                                                if  (strcmp(stmp,"<NULL>") == 0 || strcmp(stmp,"NULL") == 0
831                                                        || strcmp(stmp,"<null>") == 0 || strcmp(stmp,"null") == 0)  {
832                                                        gpv_s_glob[scnt][0] = '\0';
833                                                } else {
834                                                        while  (stmp[0] == '$')
835                                                                GpEvaluateVar( stmp );
836                                                        strcpy( gpv_s_glob[scnt], stmp );
837                                                } /*endif*/
838                                                found = 1;
839                                        } /*endif*/
840                                } /*endif*/
841                                break;
842                        } /*endif*/
843
844                /* boolean variables */
845                for  (bcnt=0; bcnt<cGpB_last; bcnt++)
846                        if  (strcmp(gpv_b_name[bcnt],name) == 0)  {
847                                if  (sscanf(line+namelth,"%s",&stmp) != 1)  {
848                                        printf( "--globalparams: error reading parameter %s\n", name );
849                                } else {
850                                        if  (strcmp(stmp,"TRUE") == 0 || strcmp(stmp,"true") == 0
851                                                || strcmp(stmp,"True") == 0 || strcmp(stmp,"1") == 0)  {
852                                                gpv_b_glob |= (1 << bcnt);
853                                                found = 1;
854                                        } else if  (strcmp(stmp,"FALSE") == 0 || strcmp(stmp,"false") == 0
855                                                || strcmp(stmp,"False") == 0 || strcmp(stmp,"0") == 0)  {
856                                                gpv_b_glob &= ~(1 << bcnt);
857                                                found = 1;
858                                        } else {
859                                                printf( "--globalparams: illegal boolean value at %s\n", name );
860                                        } /*endif*/
861                                } /*endif*/
862                                break;
863                        } /*endif*/
864                if  (found)  continue;
865
866                /* string list variables */
867                for  (lcnt=0; lcnt<cGpL_last; lcnt++)
868                        if  (strcmp(gpv_l_name[lcnt],name) == 0)  {
869                                GpParseStringList( lcnt, line+namelth );
870                                found = 1;
871                        } /*endif*/
872
873                if  (!found)
874                        printf( "--globalparams: illegal parameter %s in parameter file\n", name );
875
876        } /*endwhile*/
877
878        fclose( fp );
879
880} /* end of GpReadParametersFromFile */
881
882
883
884/*----------------------------------------------------------------------------*/
885
886
887
888int GpGetInt( TGpIntIndex idx )
889
890/* Returns integer valued global
891 *
892 * parameters of routine
893 * TGpIntIndex   idx;       input; index of variable
894 *                          returns value of variable
895 */
896{
897        /* executable code */
898
899        if  (idx >= 0 && idx < cGpI_last)  {
900                return gpv_i_glob[idx];
901        } else {
902                printf( "--globalparams: illegal index %d in GpGetInt\n", idx );
903                return 0;
904        } /*endif*/
905
906} /* end of GpGetInt */
907
908
909
910/*----------------------------------------------------------------------------*/
911
912
913
914float GpGetFloat( TGpFloatIndex idx )
915
916/* Returns float valued global
917 *
918 * parameters of routine
919 * TGpFloatIndex   idx;     input; index of variable
920 *                          returns value of variable
921 */
922{
923        /* executable code */
924
925        if  (idx >= 0 && idx < cGpF_last)  {
926                return gpv_f_glob[idx];
927        } else {
928                printf( "--globalparams: illegal index %d in GpGetFloat\n", idx );
929                return 0;
930        } /*endif*/
931
932} /* end of GpGetFloat */
933
934
935
936/*----------------------------------------------------------------------------*/
937
938
939
940char GpGetChar( TGpCharIndex idx )
941
942/* Returns char valued global
943 *
944 * parameters of routine
945 * TGpCharIndex   idx;      input; index of variable
946 *                          returns value of variable
947 */
948{
949        /* executable code */
950
951        if  (idx >= 0 && idx < cGpC_last)  {
952                return gpv_c_glob[idx];
953        } else {
954                printf( "globalparams: illegal index %d in GpGetChar\n", idx );
955                return 0;
956        } /*endif*/
957
958} /* end of GpGetChar */
959
960
961
962/*----------------------------------------------------------------------------*/
963
964
965
966char *GpGetString( TGpStringIndex idx )
967
968/* Returns pointer to string valued global
969 *
970 * parameters of routine
971 * TGpStringIndex   idx;    input; index of variable
972 *                          returns value of variable
973 */
974{
975        /* executable code */
976
977        if  (idx >= 0 && idx < cGpS_last)  {
978                return gpv_s_glob[idx];
979        } else {
980                printf( "--globalparams: illegal index %d in GpGetString\n", idx );
981                return 0;
982        } /*endif*/
983
984} /* end of GpGetString */
985
986
987
988/*----------------------------------------------------------------------------*/
989
990
991
992int GpGetBoolean( TGpBooleanIndex idx )
993
994/* Returns boolean valued global
995 *
996 * parameters of routine
997 * TGpBooleanIndex   idx;   input; index of variable
998 *                          returns value of variable
999 */
1000{
1001        /* executable code */
1002
1003        if  (idx >= 0 && idx < cGpB_last)  {
1004                if  ((gpv_b_glob & (1 << idx)) == 0)  {
1005                        return 0;
1006                } else {
1007                        return 1;
1008                } /*endif*/
1009        } else {
1010                printf( "--globalparams: illegal index %d in GpGetBoolean\n", idx );
1011                return 0;
1012        } /*endif*/
1013
1014} /* end of GpGetBoolean */
1015
1016
1017
1018/*----------------------------------------------------------------------------*/
1019
1020
1021
1022char *GpGetStringElem( TGpStringListIndex idx, int elemnum )
1023
1024/* returns string element number elemnum from string list idx
1025 *
1026 * parameters of routine
1027 * TGpStringListIndex idx;     input; index numer of string list
1028 * int                elemnum; input; number of string in list (start with 0)
1029 *                             returns string address or NULL
1030 */
1031{
1032        /* local variables */
1033        TGpStringElem *sel;     /* pointer to string element */
1034
1035        /* executable code */
1036
1037        if  (idx < 0 || idx >= cGpL_last)  return NULL;
1038
1039        sel = gpv_l_glob+idx;
1040
1041        while  (elemnum-- > 0)  {
1042                if  (sel->next == NULL)  return NULL;
1043                sel = sel->next;
1044        } /*endwhile*/
1045
1046        return sel->string;
1047
1048} /* end of GpGetStringElem */
1049
1050
1051
1052/*----------------------------------------------------------------------------*/
1053
1054
1055
1056void GpSetInt( TGpIntIndex idx, int value )
1057
1058/* Sets integer valued global
1059 *
1060 * parameters of routine
1061 * TGpIntIndex   idx;       input; index of variable
1062 * int           value;     input; new value of variable
1063 */
1064{
1065        /* executable code */
1066
1067        if  (idx >= 0 && idx < cGpI_last)  {
1068                gpv_i_glob[idx] = value;
1069        } else {
1070                printf( "--globalparams: illegal index %d in GpSetInt\n", idx );
1071        } /*endif*/
1072
1073} /* end of GpSetInt */
1074
1075
1076
1077/*----------------------------------------------------------------------------*/
1078
1079
1080
1081void GpSetFloat( TGpFloatIndex idx, float value )
1082
1083/* Sets float valued global
1084 *
1085 * parameters of routine
1086 * TGpFloatIndex   idx;     input; index of variable
1087 * float           value;   input; new value of variable
1088 */
1089{
1090        /* executable code */
1091
1092        if  (idx >= 0 && idx < cGpF_last)  {
1093                gpv_f_glob[idx] = value;
1094        } else {
1095                printf( "--globalparams: illegal index %d in GpSetFloat\n", idx );
1096        } /*endif*/
1097
1098} /* end of GpSetFloat */
1099
1100
1101
1102/*----------------------------------------------------------------------------*/
1103
1104
1105
1106void GpSetChar( TGpCharIndex idx, char value )
1107
1108/* Sets char valued global
1109 *
1110 * parameters of routine
1111 * TGpCharIndex   idx;      input; index of variable
1112 * char           value;    input; new value of variable
1113 */
1114{
1115        /* executable code */
1116
1117        if  (idx >= 0 && idx < cGpC_last)  {
1118                gpv_c_glob[idx] = value;
1119        } else {
1120                printf( "--globalparams: illegal index %d in GpSetChar\n", idx );
1121        } /*endif*/
1122
1123} /* end of GpSetChar */
1124
1125
1126
1127/*----------------------------------------------------------------------------*/
1128
1129
1130
1131void GpSetString( TGpStringIndex idx, char str[], int *ok )
1132
1133/* Sets value of string valued global variable
1134 *
1135 * parameters of routine
1136 * TGpStringIndex   idx;    input; index of variable
1137 * char             str[];  input; new value of variable
1138 * int              *ok;    output (if not NULL); 1 = ok, 0 = failure
1139 */
1140{
1141        /* executable code */
1142
1143        if  (strlen(str) > cGp_TEXTVARLTH)  {
1144                if  (ok != NULL)  *ok = 0;
1145                return;
1146        } /*endif*/
1147
1148        if  (idx >= 0 && idx < cGpS_last)  {
1149                strcpy( gpv_s_glob[idx], str );
1150                if  (ok != NULL)  *ok = 1;
1151        } else {
1152                if  (ok != NULL)  *ok = 0;
1153        } /*endif*/
1154
1155} /* end of GpSetString */
1156
1157
1158
1159/*----------------------------------------------------------------------------*/
1160
1161
1162
1163void GpSetBoolean( TGpBooleanIndex idx, int value )
1164
1165/* Sets boolean valued global
1166 *
1167 * parameters of routine
1168 * TGpBooleanIndex   idx;   input; index of variable
1169 * int               value; input; new value of variable
1170 */
1171{
1172        /* executable code */
1173
1174        if  (idx >= 0 && idx < cGpB_last)  {
1175                if  (value)  {
1176                        gpv_b_glob |= (1 << idx);
1177                } else {
1178                        gpv_b_glob &= ~(1 << idx);
1179                } /*endif*/
1180        } else {
1181                printf( "--globalparams: illegal index %d in GpSetBoolean\n", idx );
1182        } /*endif*/
1183
1184} /* end of GpSetBoolean */
1185
1186
1187
1188/*----------------------------------------------------------------------------*/
1189
1190
1191
1192void GpReadParameter( char parname[], int maxlth, char value[], int *ok )
1193
1194/* Reads parameter of name parname from parameter file.
1195 *
1196 * parameters of routine
1197 * char       parname[]; input, name of parameter
1198 * int        maxlth; input; maximum length of output string
1199 * char       value[]; output; value of parameter
1200 * int        *ok; output; 1=ok, 0=not found or string too short
1201 */
1202{
1203        /* local variables */
1204        char     *env;                   /* pointer to environment */
1205        char     parfile[cBcFileLth+1];  /* name of parameter file */
1206        FILE     *fp;                    /* pointer to parameter file */
1207        char     line[cBcVeryLongStrLth+1];  /* current line of file */
1208        int      namelth;                /* length of parameter name */
1209        char     *vptr;                  /* pointer to parameter value */
1210        int      slth;                   /* string length */
1211
1212        /* executable code */
1213
1214        /* get parameter file */
1215        env = (char *)getenv( "SH_USER_PARAM" );
1216        if  (env == NULL)  {
1217                env = (char *)getenv( "SH_INPUTS" );
1218                if  (strlen(env) < cBcFileLth-15)  {
1219                        strcpy( parfile, env );
1220                        strcat( parfile, "/shm-config.txt" );
1221                } else {
1222                        fprintf( stderr, "configuration filename too long.  Abort.\n" );
1223                        exit( 1 );
1224                } /*endif*/
1225        } else {
1226                if  (strlen(env) < cBcFileLth)  {
1227                        strcpy( parfile, env );
1228                } else {
1229                        fprintf( stderr, "environment SH_USER_PARAM too long.  Abort.\n" );
1230                        exit( 1 );
1231                } /*endif*/
1232        } /*endif*/
1233
1234        namelth = strlen( parname );
1235
1236        *ok = 0;
1237        fp = fopen( parfile, "r" );
1238        if  (fp == NULL)  return;
1239
1240        while  (fgets(line,cBcVeryLongStrLth,fp) != NULL)  {
1241
1242                if  (*line == '!' || *line == '#' || *line == '\n')  continue;
1243                if  (strncasecmp(line,parname,namelth) == 0
1244                        && (line[namelth] == ' ' || line[namelth] == '\t'))  {
1245                        vptr = line + namelth;
1246                        while  (*vptr == ' ')  vptr++;
1247                        slth = strlen( vptr );
1248                        if  (vptr[slth-1] == '\n')  vptr[--slth] = '\0';
1249                        *ok = (strlen(vptr) < maxlth);
1250                        if  (*ok)  strcpy( value, vptr );
1251                        break;
1252                } /*endif*/
1253
1254        } /*endwhile*/
1255
1256        fclose( fp );
1257
1258} /* end of GpReadParameter */
1259
1260
1261
1262/*----------------------------------------------------------------------------*/
1263
1264
1265
1266void GpParseTextList( char str[], TGpTextList *tl )
1267
1268/* Parses comma separated text string and returns pointers to elements of list.
1269 * Data structure returned must be freed after use (GpFreeTextList).
1270 *
1271 * parameters of routine
1272 * char       str[];    input; input string to be parsed
1273 * GpTextList *tl;      output; elements of list
1274 */
1275{
1276        /* local variables */
1277        int      strlth;       /* length of input string */
1278        int      i, j;         /* counters */
1279
1280        /* executable code */
1281
1282        strlth = strlen( str );
1283        if  (strlth == 0)  {
1284                tl->numelem = 0;
1285                tl->elem = NULL;
1286                tl->mem = NULL;
1287                return;
1288        } /*endif*/
1289
1290        tl->mem = (char *)malloc( strlth+1 );
1291        if  (tl->mem == NULL)  {
1292                fprintf( stderr, "GpParseTextList: error allocating memory.  Abort.\n" );
1293                exit( 1 );
1294        } /*endif*/
1295        strcpy( tl->mem, str );
1296
1297        /* count elements */
1298        tl->numelem = (*str == '\0') ? 0 : 1;
1299        for  (i=0; i<strlth; i++)
1300                if  (str[i] == ',')  (tl->numelem)++;
1301
1302        tl->elem = (char **)malloc( (int)sizeof(char *)*(tl->numelem) );
1303        if  (tl->elem == NULL)  {
1304                fprintf( stderr, "GpParseTextList: error allocating memory.  Abort.\n" );
1305                exit( 1 );
1306        } /*endif*/
1307
1308        j = 1;
1309        tl->elem[0] = tl->mem;
1310        for  (i=0; i<strlth; i++)  {
1311                if  (tl->mem[i] == ',')  {
1312                        tl->mem[i] = '\0';
1313                        tl->elem[j++] = tl->mem+i+1;
1314                } /*endif*/
1315        } /*endfor*/
1316
1317        /* debug output */
1318        /*
1319        for  (j=0; j<tl->numelem; j++)
1320                printf( "debug-textlist: %2d >%s<\n", j+1, tl->elem[j] );
1321        */
1322
1323} /* end of GpParseTextList */
1324
1325
1326
1327/*----------------------------------------------------------------------------*/
1328
1329
1330
1331void GpFreeTextList( TGpTextList *tl )
1332
1333/* Frees memory of textlist
1334 *
1335 * parameters of routine
1336 * TGpTextList         modify; text list to be freed
1337 */
1338{
1339        /* executable code */
1340
1341        if  (tl->numelem == 0)  return;
1342
1343        if  (tl->elem != NULL)  free( tl->elem );
1344        if  (tl->mem != NULL)  free( tl->mem );
1345
1346} /* end of GpFreeTextList */
1347
1348
1349
1350/*----------------------------------------------------------------------------*/
1351
1352
1353
1354void GpDumpParams( void )
1355
1356/* write all parameters out to stdout
1357 *
1358 * no parameters passed
1359 *
1360 */
1361{
1362        /* local variables */
1363        int    i;    /* counter */
1364        int    j;    /* string counter */
1365        char   *s;   /* string pointer */
1366
1367        /* executable code */
1368
1369        for  (i=0; i<cGpI_last; i++)
1370                printf( "%s: %d\n", gpv_i_name[i], gpv_i_glob[i] );
1371        for  (i=0; i<cGpF_last; i++)
1372                printf( "%s: %g\n", gpv_f_name[i], gpv_f_glob[i] );
1373        for  (i=0; i<cGpC_last; i++)
1374                printf( "%s: %c\n", gpv_c_name[i], gpv_c_glob[i] );
1375        for  (i=0; i<cGpS_last; i++)
1376                printf( "%s: %s\n", gpv_s_name[i], gpv_s_glob[i] );
1377        for  (i=0; i<cGpB_last; i++)
1378                printf( "%s: %d\n", gpv_b_name[i], ((1<<i) & gpv_b_glob) );
1379        for  (i=0; i<cGpL_last; i++)  {
1380                for  (j=0;;j++)  {
1381                        s = GpGetStringElem( i, j );
1382                        if  (s == NULL)  break;
1383                        printf( "%s (%d): %s\n", gpv_l_name[i], j, s );
1384                } /*endfor*/
1385        } /*endfor*/
1386
1387} /* end of GpDumpParams */
1388
1389
1390
1391/*----------------------------------------------------------------------------*/
1392
1393
1394
1395void GpParseStringList( TGpStringListIndex idx, char line[] )
1396
1397/* parses string list and puts result to list number idx
1398 *
1399 * parameters of routine
1400 * TGpStringListIndex idx;    input; string list variable index
1401 * char               line[]; input; line to be parsed
1402 */
1403{
1404        /* local variables */
1405        int      i, j;                /* counters */
1406        TGpStringElem *sel;           /* pointer to string element */
1407        char     val[cBcLineLth+1];   /* string value */
1408
1409        /* excutable code */
1410
1411        sel = gpv_l_glob+idx;
1412
1413        /* !!! should free list before (if not "default") */
1414
1415        sel->next = NULL;
1416        sel->string = '\0';
1417        sel->strlth = 0;
1418
1419        while  (*line != '\0')  {
1420
1421                /* skip blanks */
1422                while  (*line == ' ' || *line == '\t')  line++;
1423                if  (*line == '\0' || *line == '\n')  break;
1424
1425                /* allocate next StringElem if necessary */
1426                if  (sel->string != '\0')  {
1427                        sel->next = (TGpStringElem *)malloc( (int)sizeof(TGpStringElem) );
1428                        if  (sel->next == NULL)  {
1429                                printf( "--globalparams: error allocating memory (1). Abort\n" );
1430                                exit( 1 );
1431                        } /*endif*/
1432                        sel = sel->next;
1433                        sel->next = NULL;
1434                        sel->string = '\0';
1435                        sel->strlth = 0;
1436                } /*endif*/
1437
1438                /* get next string length */
1439                i = 0;
1440                while  (line[i] != '\0' && line[i] != ' ' && line[i] != '\n'
1441                        && line[i] != '\t' && line[i] != ',' && line[i] != ';')
1442                        i++;
1443                if  (i >= cBcLineLth-1)  {
1444                        printf( "--globalparams: string element (idx: %d) too long\n", idx );
1445                        return;
1446                } /*endif*/
1447
1448                /* copy string to StringElem structure */
1449                if  (i > 0)  {
1450
1451                        /* copy string and translate if necessary */
1452                        strncpy( val, line, i );
1453                        val[i] = '\0';
1454
1455                        while  (*val == '$')
1456                                GpEvaluateVar( val );
1457
1458                        j = strlen( val );
1459                        sel->string = (char *)malloc( (int)sizeof(char)*(j+1) );
1460                        if  (sel->string == NULL)  {
1461                                printf( "--globalparams: error allocating memory (2). Abort\n" );
1462                                exit( 1 );
1463                        } /*endif*/
1464                        strcpy( sel->string, val );
1465                        sel->strlth = j;
1466
1467                } /*endif*/
1468
1469                if  (line[i] == '\0' || *line == '\n')  break;
1470                line += i+1;
1471
1472        } /*endwhile*/
1473
1474} /* end of GpParseStringList */
1475
1476
1477
1478/*----------------------------------------------------------------------------*/
1479
1480
1481
1482static void GpEvaluateVar( char val[] )
1483
1484/* Evaluates value of variable
1485 *
1486 * parameters of routine
1487 * char       val[];     modify; input: variable name, output: value
1488 */
1489{
1490        /* local variable */
1491        char     vname[cBcLineLth+1];     /* variable name */
1492        char     appdx[cBcLineLth+1];     /* appendix (after '/') */
1493        int      j;                       /* counter */
1494        int      ok;                      /* string value found */
1495        char     *env;                    /* pointer to environment */
1496
1497        /* executable code */
1498
1499        if  (*val != '$')  return;  /* leave unchanged */
1500
1501        /* try 'v$'-variable in configuration file */
1502        vname[0] = 'v';
1503        j = 0;
1504        while  (val[j] != '/' && val[j] != '\0')  {
1505                vname[j+1] = val[j];
1506                j++;
1507        } /*endwhile*/
1508        vname[j+1] = '\0';
1509        *appdx = '\0';
1510        if  (val[j] == '/')  strcpy( appdx, val+j );
1511        GpReadParameter( vname, cBcLineLth, val, &ok );
1512
1513        if  (!ok)  {
1514                /* try to find environment variable */
1515                env = (char *)getenv( vname+2 );  /* skip v$ */
1516                if  (env == NULL)  {
1517                        strcpy( val, vname+2 );  /* take away '$', results in an error later */
1518                } else if  (strlen(env) < cBcLineLth)  {
1519                        strcpy( val, env );
1520                } else {
1521                        strcpy( val, vname+2 );  /* results in an error later */
1522                } /*endif*/
1523        } /*endif*/
1524
1525        if  (*appdx != '\0')
1526                if  (strlen(val)+strlen(appdx) < cBcLineLth)
1527                        strcat( val, appdx );
1528
1529} /* end of GpEvaluateVar */
1530
1531
1532
1533/*----------------------------------------------------------------------------*/
Note: See TracBrowser for help on using the repository browser.