Changeset 101


Ignore:
Timestamp:
02/19/2009 03:17:19 PM (14 years ago)
Author:
marcus
Message:
  • removed all VAX/VMS code from SH code (hopefully)
Location:
SH_SHM/branches/marcus/source
Files:
3 deleted
14 edited

Legend:

Unmodified
Added
Removed
  • SH_SHM/branches/marcus/source/basecnst.h

    r16 r101  
    7070 * SH_SETUP_HPUX 
    7171 * SH_SETUP_ATARITOS 
    72  * SH_SETUP_VMS 
    7372 * default is SH_SETUP_SUNOS 
    7473 */ 
     
    8685#define cBc_OS_UNIX 
    8786#define cBc_OS_HPUX 
    88 #elif defined(SH_SETUP_VMS) 
    89 #define cBc_OS_VMS 
    90 #define BC_VAX            /* for compatibility */ 
    9187#elif defined(SH_SETUP_ATARITOS) 
    9288#define cBc_OS_ATARITOS 
     
    139135 
    140136/* special settings */ 
    141 /* #define BC_GRFVAX */ 
    142         /* special GRF version, only valid on VAX/VMS version */ 
    143137/* #define BC_USE_READK */ 
    144138        /* enables readk command, only valid on Sun/UNIX version at SZGRF */ 
     
    238232 
    239233/****************************************************************** 
    240  ***                         VAX version                        *** 
    241  ******************************************************************/ 
    242  
    243  
    244  
    245 #ifdef BC_VAX 
    246  
    247  
    248 #define BC_SYSBASE "SHC_MAIN:SYSBASE.H" 
    249 #define BC_SYERRORS "SHC_MAIN:SYERRORS.H" 
    250 #define BC_GCUSRDEF "SHC_newgraph:GCUSRDEF.H" 
    251 #define BC_FOREIGN "SHC_FOREIGN:SHFRGN.H" 
    252 #define BC_SHDIRS "SHC_MAIN:SHDIRS.H" 
    253 #define BC_ASCII "SHC_MAIN:ASCII.H" 
    254 #define BC_GRAPHBAS "shc_newgraph:GRAPHBAS.H" 
    255 #define BC_SHCONST "SHC_MAIN:SHCONST.H" 
    256 #define BC_CPAR "shc_main:cpar.h" 
    257 #define BC_EARTHLOC "shc_main:earthloc.h" 
    258 #define BC_UTUSRDEF "shc_main:utusrdef.h" 
    259 #define BC_GLUSRDEF "shc_main:glusrdef.h" 
    260 #define BC_INPFILES "shc_utilsrc:inpfiles.h" 
    261 #define BC_TCUSRDEF "shc_main:tcusrdef.h" 
    262 #define BC_QFUSRDEF "shc_main:qfusrdef.h" 
    263 #define BC_QFERRORS "shc_main:qferrors.h" 
    264 #define BC_DFQENTRY "shc_main:dfqentry.h" 
    265 #define BC_ERUSRDEF "shc_main:erusrdef.h" 
    266 #define BC_FLERRORS "shc_main:flerrors.h" 
    267 #define BC_READGRN "shc_main:readgrn.h" 
    268 #define BC_PTUSRDEF "shc_main:ptusrdef.h" 
    269  
    270  
    271 #endif /* BC_VAX */ 
    272  
    273  
    274 /****************************************************************** 
    275234 ***                         SUN version                        *** 
    276235 ******************************************************************/ 
  • SH_SHM/branches/marcus/source/errmsg.c

    r16 r101  
    102102        /* check error path */ 
    103103        if  (*emv_errdir == '\0')  { 
    104 #               ifdef BC_VAX 
    105                 strcpy( emv_errdir, "shc_errors:" ); 
    106 #               endif 
    107104#               ifdef BC_SUN 
    108105                eptr = GpGetString( cGpS_defpath_errors ); 
  • SH_SHM/branches/marcus/source/newgraph/ccch.c

    r16 r101  
    1414#include <string.h> 
    1515#include BASECNST 
    16 #ifdef BC_VAX 
    17 #include <descrip.h> 
    18 #endif 
    1916#include BC_SYSBASE 
    2017#include "graphbas.h" 
     
    4441        /* number of default style */ 
    4542#define STRLTH 80 
    46 #ifdef BC_VAX 
    47 #define CC_CLOSE_LOG "SYS$LOGIN:CC$CLOSE_LOG.LOG" 
    48 #endif 
    49 #define TMP_CALCOMP "HC_CC.PFL"  
     43#define TMP_CALCOMP "HC_CC.PFL" 
    5044#define TOSCREEN 0 
    5145#define TOFILE 1 
     
    110104        /* local variables */ 
    111105        char     str[BC_FILELTH+1];     /* scratch string */ 
    112 #       ifdef BC_VAX 
    113         $DESCRIPTOR( dirname, " " ); 
    114         $DESCRIPTOR( calcomp, "CALCOMP_PFL" ); 
    115 #       endif 
    116106        int      i;      /* counter */ 
    117107 
     
    135125 
    136126        /* open calcomp file SYS$LOGIN:HC$CC.PFL */ 
    137 #       ifdef BC_VAX 
    138         strcpy( str, ccv_outputdir ); 
    139         strcat( str, TMP_CALCOMP ); 
    140         dirname.dsc$w_length = strlen( str ); 
    141         dirname.dsc$a_pointer = str; 
    142         lib$set_logical( &calcomp, &dirname ); 
    143 #       endif 
    144127        ccv_channel = TOFILE; 
    145128        cch_init(); 
     
    164147{ 
    165148        /* local variables */ 
    166 #       ifdef BC_VAX 
    167         $DESCRIPTOR( calcomp, "CALCOMP_PFL" ); 
    168 #       endif 
    169149 
    170150        /* executable code */ 
     
    174154        cch_close( TRUE ); 
    175155        ccv_isinit = FALSE; 
    176 #       ifdef BC_VAX 
    177         lib$delete_logical( &calcomp ); 
    178 #       endif 
    179156 
    180157} /* end of cc_exit */ 
     
    800777        int      code;           /* plot subfunction code */ 
    801778        char     str[BC_FILELTH+1];  /* scratch */ 
    802 #       ifdef BC_VAX 
    803         $DESCRIPTOR( outstream, "SYS$OUTPUT" ); 
    804         $DESCRIPTOR( logfile, CC_CLOSE_LOG ); 
    805 #       endif 
    806  
    807         /* executable code */ 
    808  
    809 #       ifdef BC_VAX 
    810         lib$set_logical( &outstream, &logfile ); 
    811 #       endif 
     779 
     780        /* executable code */ 
     781 
    812782        x = y = 0.0; 
    813783        code = CCC_PLOTEND; 
    814784        plot( &x, &y, &code ); 
    815 #       ifdef BC_VAX 
    816         lib$delete_logical( &outstream ); 
    817785        /* delete log file */ 
    818786        sy_fdelete( CC_CLOSE_LOG ); 
  • SH_SHM/branches/marcus/source/newgraph/xwch.c

    r48 r101  
    1313#include <ctype.h> 
    1414#include BASECNST 
    15 #ifdef BC_VAX 
    16 #include <decw$include:xlib.h> 
    17 #include <decw$include:xutil.h> 
    18 #include <decw$include:xatom.h> 
    19 #include <decw$include:cursorfont.h> 
    20 #endif 
    2115#ifdef BC_SUN 
    2216#include <X11/Xlib.h> 
     
    155149        int                  i;        /* counter */ 
    156150        XSetWindowAttributes xswa;     /* set attribute block */ 
    157         XSizeHints           xsh;      /* size hints */  
     151        XSizeHints           xsh;      /* size hints */ 
    158152        XWMHints             xwmh;     /* window manager hints */ 
    159153        char                 str[MAXSTRLTH+1]; /* scratch string */ 
  • SH_SHM/branches/marcus/source/readgrn.c

    r16 r101  
    5050 
    5151/* separation character between root path and GRN subdirectories: */ 
    52 #ifdef BC_VAX 
    53 #define EODEV ':' 
    54 #else 
    55 #ifdef BC_ATARI 
    56 #define EODEV '\\' 
    57 #else 
    5852#define EODEV '/' 
    59 #endif 
    60 #endif 
    61  
    6253 
    6354 
     
    770761        NTIME    nt2;                  /* time values of test record */ 
    771762        long     testlth;              /* number of records for test span */ 
    772 #       ifdef BC_VAX                   /* need this on VAX only: */ 
    773         char     str[BC_FILELTH+1];    /* file name to re-open file */ 
    774 #       endif 
    775763 
    776764        /* executable code */ 
     
    841829#       endif                          /*                                   */ 
    842830        if  (fstat != 0)  { 
    843 #               ifdef BC_VAX                /* VAX-routine does not recover from */ 
    844                 fgetname( grn, str );       /* this status.  Therefore close and */ 
    845                 fclose( grn );              /* reopen GRN file                   */ 
    846                 grn = sy_fopen( str, "r" ); /*                                   */ 
    847 #               endif                       /*                                   */ 
    848831                testlth = 20; 
    849832                grn_readlog( "t" ); 
     
    854837                if  (fstat != 0)  {          /* very short file, just rewind it   */ 
    855838                        grn_readlog( "s" ); 
    856 #                       ifdef BC_VAX                 /* Again close and reopen on VAX   */ 
    857                         sy_fclose( grn );            /* Silly routine !                 */ 
    858                         grn = sy_fopen( str, "r" );  /*                                 */ 
    859 #                       else                         /*                                 */ 
    860839                        fseek( grn, 0, 0 );          /* on other machines a simple      */ 
    861 #                       endif                        /* rewind should be ok             */ 
    862840                        return; 
    863841                } /*endif*/ 
    864842        } /*endif*/ 
    865843        if  (fstat != 0)  { 
    866 #               ifdef BC_VAX                 /* No more comment on VAX          */ 
    867                 fgetname( grn, str );        /* routine ...                     */ 
    868                 sy_fclose( grn );            /*                                 */ 
    869                 grn = sy_fopen( str, "r" );  /*                                 */ 
    870 #               endif                        /*                                 */ 
    871844                meansmp = GRN_MEANSMPREC; 
    872845                grn_readlog( "m" ); 
     
    915888        /* if  (fstat != 0)  {*status = GRNE_TOOSHORT; return;} */ 
    916889        if  (fstat != 0)  { 
    917 #               ifdef BC_VAX                 /* No more comment on VAX          */ 
    918                 fgetname( grn, str );        /* routine ...                     */ 
    919                 sy_fclose( grn );            /*                                 */ 
    920                 grn = sy_fopen( str, "r" );  /*                                 */ 
    921 #               endif                        /*                                 */ 
    922890                setpos = (long)((tmp*0.8)-1)*GRN_RECLTH; 
    923891                grn_readlog( "_" ); 
     
    13921360 *   If the label is an empty string, device is assumed to hold the complete 
    13931361 * path of the data directory.  In this case the list file is searched on 
    1394  * "grnv_glsdir" with the name "device"_dirfile.gls (VAX) or on the data 
    1395  * directory with the name dirfile.gls (all others). 
     1362 * on the data directory with the name dirfile.gls. 
    13961363 *   The syntax of the list file is explained in the following example 
    13971364 * (please remind that the first three characters in each line " * " are 
     
    14661433 
    14671434        if  (*label == '\0')  { 
    1468 #               ifdef BC_VAX                                   /* on the VAX, the list */ 
    1469                 strcpy( glsname, grnv_glsdir );                /* file is on the same  */ 
    1470                 strcat( glsname, device );                     /* directory as all     */ 
    1471                 i = (int)strlen( glsname ) - 1;                /* other list files     */ 
    1472                 if  (glsname[i] == EODEV)  glsname[i] = '\0';  /*                      */ 
    1473                 strcat( glsname, "_dirfile" );                 /*                      */ 
    1474 #               else 
    14751435                strcpy( glsname, device );               /* this is different on other */ 
    14761436                i = (int)strlen( glsname ) - 1;          /* machines.  Here the list   */ 
    14771437                if  (glsname[i] != EODEV &&              /* file is on the data        */ 
    1478                         glsname[i] != ':')  {            /* directory                  */           
     1438                        glsname[i] != ':')  {            /* directory                  */ 
    14791439                        glsname[i+1] = EODEV;            /*                            */ 
    14801440                        glsname[i+2] = '\0';             /*                            */ 
    14811441                } /*endif*/                              /*                            */ 
    14821442                strcat( glsname, "dirfile" );            /*                            */ 
    1483 #               endif 
    14841443                strcat( glsname, GRN_LISTFILEEXT ); 
    14851444        } else { 
     
    15561515        strcpy( glsname, device ); 
    15571516        if  (*label != '\0')  {  /* on WORM disk the path must be generated */ 
    1558 #               ifdef BC_VAX 
    1559                 if  (*chan == 'H')  strcat( glsname, "[GRN_80." ); 
    1560                 else if  (*chan == 'B')  strcat( glsname, "[GRN_20." ); 
    1561                 else  strcat( glsname, "[GRN_01." ); 
    1562                 strcat( glsname, station ); 
    1563                 strcat( glsname, "]" ); 
    1564 #               else    /* different file syntax in UNIX */ 
    15651517                if  (*chan == 'H')  strcat( glsname, "grn_80/" ); 
    15661518                else if  (*chan == 'B')  strcat( glsname, "grn_20/" ); 
     
    15681520                strcat( glsname, station ); 
    15691521                strcat( glsname, "/" ); 
    1570 #               endif   /* no need for ATARI here */ 
    15711522        } /*endif*/ 
    15721523        for  (i=0; i<filenum; i++)  { 
     
    22422193 
    22432194/*----------------------------------------------------------------------------*/ 
    2244  
    2245  
    2246  
    2247 void grn_set_vax_label_file( char fname[] ) 
    2248  
    2249 /* changes VAX name of VAX label file 
    2250  * 
    2251  * parameters of routine 
    2252  * char       fname[];         input; name of label file 
    2253  */ 
    2254 { 
    2255         /* execitable code */ 
    2256  
    2257         if  (strlen(fname) < BC_FILELTH) 
    2258                 strcpy( grnv_labelfile, fname ); 
    2259  
    2260 } /* end of grn_set_vax_label_file */ 
    2261  
    2262  
    2263  
    2264 /*----------------------------------------------------------------------------*/ 
  • SH_SHM/branches/marcus/source/readgrn.h

    r16 r101  
    251251 * subsequent files on the volume. 
    252252 *   If the label is an empty string, device is assumed to hold the complete 
    253  * path of the data directory.  In this case the list file is searched on 
    254  * "grnv_glsdir" with the name "device"_dirfile.gls (VAX) or on the data 
    255  * directory with the name dirfile.gls (all others). 
     253 * path of the data directory.  In this case the list file is searched on the data 
     254 * directory with the name dirfile.gls. 
    256255 *   The syntax of the list file is explained in the following example 
    257256 * (please remind that the first three characters in each line " * " are 
     
    408407 
    409408/*----------------------------------------------------------------------------*/ 
    410  
    411  
    412 void grn_set_vax_label_file( char fname[] ); 
    413  
    414 /* changes VAX name of VAX label file 
    415  * 
    416  * parameters of routine 
    417  * char       fname[];         input; name of label file 
    418  */ 
    419  
    420  
    421 /*----------------------------------------------------------------------------*/ 
  • SH_SHM/branches/marcus/source/seed_io/Makefile

    r21 r101  
    4040                                        pcname \ 
    4141                                        copy_recs \ 
    42                                         swap_vax_recs \ 
    4342                                        split_seed \ 
    4443                                        edit_rectime \ 
     
    110109                $(LINK.c) -o $@ $@.o $(LDFLAGS) $(LIBS) 
    111110 
    112 swap_vax_recs: swap_vax_recs.o $(LIB_SOURCE) $(LIB_SEED) 
    113                 $(LINK.c) -o $@ $@.o $(LDFLAGS) $(LIBS) 
    114  
    115111split_seed: split_seed.o $(LIB_SOURCE) $(LIB_SEED) 
    116112                $(LINK.c) -o $@ $@.o $(LDFLAGS) $(LIBS) 
  • SH_SHM/branches/marcus/source/seed_io/seed_lib.c

    r68 r101  
    4747 * v 82, 13-Feb-07, K. Stammler, swap blockette 1000 in SwapHeader 
    4848 * v 83, 28-Nov-07, K. Stammler, accept also Q and R as data record identifier 
     49 * v 84, 19-Feb-08, M. Walther, removed VAX support 
    4950 */ 
    5051 
     
    6566/* #include <sys/uio.h> */ 
    6667#endif 
    67 #ifdef BC_VAX 
    68 #include <file.h> 
    69 #endif 
    7068#include "sysbase.h" 
    7169#include "tcusrdef.h" 
     
    7977#include "steim1.h" 
    8078#undef ANSI_EXTENSIONS 
    81  
    82 #ifdef BC_VAX 
    83 #define SEEK_SET 0 
    84 #endif 
    85  
    8679 
    8780 
     
    773766                if  (Severe(status))  {fclose(sfd); return;} 
    774767                if  (strcmp(curr.stream,lstream_str) != 0)  continue; 
    775                 if  (strcmp(xaddinf,Seed_C_EmptyAddinfStr) != 0  
     768                if  (strcmp(xaddinf,Seed_C_EmptyAddinfStr) != 0 
    776769                        && strcmp(xaddinf,curr.addinf) != 0)  continue; 
    777770                tdiff = tc_tdiff( start, curr.t_start, status ); 
     
    981974                if  (strlen(station)+strlen(chan)+3 > cBcShortStrLth)  { 
    982975                        *status = SeedERR_STROVFL; 
    983                         return;          
     976                        return; 
    984977                } /*endif*/ 
    985978                /* database list may contain files which do not match the requested time */ 
     
    12871280                if  (strlen(station)+strlen(chan)+3 > cBcShortStrLth)  { 
    12881281                        *status = SeedERR_STROVFL; 
    1289                         return;          
     1282                        return; 
    12901283                } /*endif*/ 
    12911284                /* if priority is lower than the one we have, ignore entry */ 
     
    22352228        /* !!! set record number !!! */ 
    22362229        /* !!! apply time correction !!! */ 
    2237          
     2230 
    22382231        idx = 0; 
    22392232        quit = FALSE; 
     
    26632656                                        if  (*smplth == getlth)  { 
    26642657                                                sy_deallocmem( recsmp ); 
    2665                                                 fprintf( stderr,  
     2658                                                fprintf( stderr, 
    26662659                                                        "   padding aborted, %ld zeroes remaining\n", padcnt ); 
    26672660                                                return; 
  • SH_SHM/branches/marcus/source/seismhan.c

    r30 r101  
    5959#endif 
    6060 
    61 /* VAX specific routines (usually FORTRAN subroutines) */ 
    62 #ifdef BC_GRFVAX 
    63 #include "[-.local]fctxmngrf.h" 
    64 #endif /* BC_GRFVAX */ 
    65  
    6661/* machine dependent path strings */ 
    6762#include BC_SHDIRS 
     
    231226        SqlDeleteScratchFile(); 
    232227 
    233 #       ifndef BC_VAX 
    234         return 0; 
    235 #       endif /* BC_VAX */ 
    236228 
    237229} /* end of main */ 
  • SH_SHM/branches/marcus/source/shdirs.h

    r16 r101  
    5454#endif /* BC_ATARI */ 
    5555/*=================================================================*/ 
    56 #ifdef BC_VAX 
    57  
    58  
    59  
    60 #define DD_SCRATCH "SYS$LOGIN:" 
    61 #define DD_HELP "SHC_HELP:" 
    62 #define DD_CMD  "SHC_COMMAND:" 
    63 #define DD_FILTER "SHC_FILTER:" 
    64 #define DD_GLOBALS "SHC_GLOBALS:" 
    65 #define DD_ERRORS "SHC_ERRORS:" 
    66 #define DD_INPUTS "SHC_MAIN:" 
    67 #define DD_EXTPROG "SHC_EXTPROG:" 
    68  
    69  
    70  
    71 #endif /* BC_VAX */ 
    72 /*=================================================================*/ 
    7356#ifdef BC_SUN 
    7457 
  • SH_SHM/branches/marcus/source/shexec.c

    r30 r101  
    110110        /* get session ID string */ 
    111111        strcpy( id_shv, SHC_FILE_PREFIX ); 
    112 #       ifdef BC_VAX 
    113         mt_randomstr( 4, id_shv+SHC_FILE_PREFIX_LENGTH ); 
    114         strcat( id_shv, "_" ); 
    115 #       endif  /* BC_VAX */ 
    116112#       ifdef BC_SUN 
    117113        mt_randomstr( 4, id_shv+SHC_FILE_PREFIX_LENGTH ); 
     
    372368                        mn3_fold( cmd, status ); 
    373369                        *redraw = TRUE; 
    374 #               ifdef BC_GRFVAX 
    375                 } else if  (cp_cmdverb(cmd,"FOLDN"))  { 
    376                         mngrf_fold( cmd, status ); 
    377                         *redraw = TRUE; 
    378 #               endif /* BC_GRFVAX */ 
    379370                } else { 
    380371                        mn0_callproc( cmd, status ); 
     
    536527                        mni_reads( cmd, status ); 
    537528                        *redraw = TRUE; 
    538 #               ifdef BC_GRFVAX 
    539                 } else if  (cp_cmdverb(cmd,"READV"))  { 
    540                         mngrf_readv( cmd, status ); 
    541                         *redraw = TRUE; 
    542                 } else if  (cp_cmdverb(cmd,"READO"))  { 
    543                         mngrf_reado( cmd, status ); 
    544                         *redraw = TRUE; 
    545 #               endif /* BC_GRFVAX */ 
    546529                } else if  (cp_cmdverb(cmd,"REPLACE"))  { 
    547530                        mn5_replace( cmd, status ); 
  • SH_SHM/branches/marcus/source/shmenu0.c

    r16 r101  
    273273                        printf( 
    274274                                "*SH: obsolete command PATH COMMAND2, consider using string list in COMMAND path\n" ); 
    275                         printf(  
     275                        printf( 
    276276                                "*SH: translated in FCT PATH COMMAND |.|,|$SH_COMMAND|,|%s|\n", s_par ); 
    277277                        if  (strlen(s_par) > cBcLongStrLth-14)  { 
     
    513513                if  (*status != SHE_NOERROR)  return; 
    514514                strcpy( str, "UNKNOWN" ); 
    515 #               ifdef BC_VAX 
    516                 strcpy( str, "VAX-VMS" ); 
    517 #               endif 
    518515#               ifdef BC_SUN 
    519516                strcpy( str, "UNIX" ); 
  • SH_SHM/branches/marcus/source/sysbase.h

    r16 r101  
    648648 
    649649#endif /* BC_IBM */ 
    650  
    651  
    652  
    653 /****************************************************************** 
    654  ***                         VAX version                        *** 
    655  ******************************************************************/ 
    656  
    657  
    658  
    659 #ifdef BC_VAX 
    660  
    661  
    662  
    663 /* short integer */ 
    664 #define BYTE char 
    665  
    666 /* boolean type */ 
    667 #define BOOLEAN int 
    668  
    669 /* boolean values TRUE & FALSE */ 
    670 #ifdef BC_DEFINE_TRUE_FALSE 
    671 #define TRUE (1) 
    672 #define FALSE (0) 
    673 #endif 
    674  
    675 /* infinite loop declaration */ 
    676 #define FOREVER for(;;) 
    677  
    678 /* status type */ 
    679 #ifndef STATUS 
    680 #define STATUS int 
    681 #define Severe(s) (*(s) != 0) 
    682 #endif /* STATUS */ 
    683  
    684 /* nearest integer number to floating number */ 
    685 #define Nint(x) ((x)>0 ? (int)((x)+0.5) : (int)((x)-0.5)) 
    686 #define Nint32(x) ((x)>0 ? (int)((x)+0.5) : (int)((x)-0.5)) 
    687  
    688 /* nearest long number to floating number */ 
    689 #define Nlong(x) ((x)>0 ? (long)((x)+0.5) : (long)((x)-0.5)) 
    690  
    691 /* capitalize character */ 
    692 #define Cap(c) (((c)>='a' && (c)<='z') ? ((c)-32) : (c)) 
    693 #define Uncap(c) (((c)>='A' && (c)<='Z') ? ((c)+32) : (c)) 
    694  
    695 /* absolute value of number */ 
    696 #define Abs(x) ((x)<0?-(x):(x)) 
    697  
    698 /* read logical name table, not implemented */ 
    699 #define sy_lognames(f,s) 
    700  
    701 /* open text file */ 
    702 #define sy_fopen(f,a) fopen(f,a) 
    703  
    704 /* close text file */ 
    705 #define sy_fclose(f) fclose(f) 
    706  
    707 /* binary file type, here the same as text file */ 
    708 typedef FILE *BFILE; 
    709  
    710 /* binary file operation failed */ 
    711 #define sy_fbfailed(f) ((f)==NULL) 
    712  
    713 /* sy_findfile parameter */ 
    714 #define SYC_FF_NAME 1 
    715 #define SYC_FF_DIR 2 
    716 #define SYC_FF_EXT 4 
    717  
    718  
    719  
    720 /* system constants */ 
    721 /* ---------------- */ 
    722  
    723 /* maximum unsigned */ 
    724 #define SYC_MAXUNSG 0xffffffffL 
    725  
    726 /* maximum integer */ 
    727 #define SYC_MAXINT 0x7fffffffL 
    728  
    729 /* minimum integer */ 
    730 #define SYC_MININT 0x80000000L 
    731  
    732 /* maximum long */ 
    733 #define SYC_MAXLONG 0x7fffffffL 
    734  
    735 /* minimum long */ 
    736 #define SYC_MINLONG 0x80000000L 
    737  
    738 /* open existing file to overwrite */ 
    739 #define SYC_OPEN_OVWR "r+" 
    740  
    741 /* system specific types */ 
    742 /* --------------------- */ 
    743  
    744 /* difference time */ 
    745 typedef float DIFFTIME; 
    746  
    747  
    748 /* not implemented routines */ 
    749 #define sy_initprocess() 
    750 #define sy_sharecpu() 
    751 #define sy_debuginfo(s) 
    752 #define sy_alert(t) printf( "\n%s\n", t ) 
    753 #define sy_getmessage() NULL 
    754 #define sy_gettime(s) strcpy(s,SHC_TIMEDEFAULT) 
    755  
    756  
    757  
    758 /*------------------------------------------------------------------------*/ 
    759 /*    prototypes of routines of module SYSCALL.C                          */ 
    760 /*------------------------------------------------------------------------*/ 
    761  
    762  
    763 void *sy_allocmem( long cnt, int size, STATUS *status ); 
    764  
    765 /* allocates memory ("cnt" objects of size "size) 
    766  * 
    767  * parameters of routine 
    768  * long     cnt;            input; number of objects 
    769  * int      size;           input; size of each object 
    770  * STATUS   *status;        output; return status 
    771  */ 
    772  
    773  
    774 /*------------------------------------------------------------------------*/ 
    775  
    776  
    777 void sy_deallocmem( void *ptr ); 
    778  
    779 /* deallocates memory 
    780  * 
    781  * parameter of routine 
    782  * void     *ptr;        input; pointer to be freed 
    783  */ 
    784  
    785  
    786 /*------------------------------------------------------------------------*/ 
    787  
    788  
    789 long sy_fread( void *strbuf, int size, long n, FILE *fp ); 
    790  
    791 /* reads "n" objects of size "size" from file "fp" 
    792  * 
    793  * parameters of routine 
    794  * void     *strbuf;        output; buffer to read to 
    795  * int      size;           input; size of each object 
    796  * long     n;              input; number of objects 
    797  * FILE     *fp;            input; file descriptor 
    798  */ 
    799  
    800  
    801 /*------------------------------------------------------------------------*/ 
    802  
    803  
    804 long sy_fwrite( void *strbuf, int size, long n, FILE *fp ); 
    805  
    806 /* writes "n" objects of size "size" to file "fp" 
    807  * 
    808  * parameters of routine 
    809  * void     *strbuf;        input; buffer to read to 
    810  * int      size;           input; size of each object 
    811  * long     n;              input; number of objects 
    812  * FILE     *fp;            input; file descriptor 
    813  */ 
    814  
    815  
    816 /*------------------------------------------------------------------------*/ 
    817  
    818  
    819 long sy_fbread( void *strbuf, int size, long n, BFILE fp ); 
    820  
    821 /* reads "n" objects of size "size" from binary file "fp" 
    822  * 
    823  * parameters of routine 
    824  * void     *strbuf;        output; buffer to read to 
    825  * int      size;           input; size of each object 
    826  * long     n;              input; number of objects 
    827  * BFILE    fp;             input; file descriptor 
    828  */ 
    829  
    830  
    831 /*------------------------------------------------------------------------*/ 
    832  
    833  
    834 long sy_fbwrite( void *strbuf, int size, long n, BFILE fp ); 
    835  
    836 /* writes "n" objects of size "size" to binary file "fp" 
    837  * 
    838  * parameters of routine 
    839  * void     *strbuf;        input; buffer to read to 
    840  * int      size;           input; size of each object 
    841  * long     n;              input; number of objects 
    842  * BFILE    fp;             input; file descriptor 
    843  */ 
    844  
    845  
    846 /*------------------------------------------------------------------------*/ 
    847  
    848  
    849 int sy_fbseek( BFILE fp, long pos, int mode ); 
    850  
    851 /* changes read/write position in binary file 
    852  * 
    853  * parameters of routine 
    854  * BFILE      fp;    input; file pointer 
    855  * long       pos;   input; new position 
    856  * int        mode;  input; search mode 
    857  */ 
    858  
    859  
    860 /*------------------------------------------------------------------------*/ 
    861  
    862  
    863 BFILE sy_fbopen( const char *file, const char *access ); 
    864  
    865 /* opens a binary file 
    866  * 
    867  * parameters of routine 
    868  * const char    *file;    input; filename 
    869  * const char    *access;  input; access mode 
    870  */ 
    871  
    872  
    873 /*------------------------------------------------------------------------*/ 
    874  
    875  
    876 int sy_fbclose( BFILE fp ); 
    877  
    878 /* closes binary file 
    879  * 
    880  * parameter of routine 
    881  * BFILE     fp;      input; file pointer 
    882  */ 
    883  
    884  
    885 /*------------------------------------------------------------------------*/ 
    886  
    887  
    888 void sy_findfile( int request, char wild[], char filename[] ); 
    889  
    890 /* looks for files matching wild card string "wild". Returns filename of 
    891  * file found or "\0" if not found.  "request" controls the returned 
    892  * elements.  For example the value (SYC_FF_DIR|SYC_FF_NAME|SYC_FF_EXT) 
    893  * means, that the returned string contains directory, file name and 
    894  * extension. 
    895  * 
    896  * parameters of routine 
    897  * int      request;        input; what elements (name,dir,extension) 
    898  * char     *wild;          input; wild card string 
    899  * char     *filename;      output; next file found 
    900  */ 
    901  
    902  
    903 /*------------------------------------------------------------------------*/ 
    904  
    905  
    906 void sy_system( char *cmd, STATUS *status ); 
    907  
    908 /* call to the operating system 
    909  * 
    910  * parameters of routine 
    911  * char     *cmd;           input; system command 
    912  * STATUS   *status;        output; return status 
    913  */ 
    914  
    915  
    916 /*------------------------------------------------------------------------*/ 
    917  
    918  
    919  
    920 double sy_random( double ampl ); 
    921  
    922 /* creates random number with absolute value less than (or equal to) 
    923  * "amp" 
    924  * 
    925  * parameters of routine 
    926  * double               ampl;           input; max. amplitude; if zero, a new random 
    927  *                                                                       series is started 
    928  */ 
    929  
    930  
    931 /*------------------------------------------------------------------------*/ 
    932  
    933  
    934 DIFFTIME sy_difftime( void ); 
    935  
    936 /* returns time since last sy_difftime call 
    937  */ 
    938  
    939  
    940 /*------------------------------------------------------------------------*/ 
    941  
    942  
    943 void sy_randomstr( int lth, char str[] ); 
    944  
    945 /* creates random string of length "lth" 
    946  * 
    947  * parameters of routine 
    948  * int        lth;      input; length of output string 
    949  * char       str[];    output; random string 
    950  */ 
    951  
    952  
    953 /*------------------------------------------------------------------------*/ 
    954  
    955  
    956 void sy_fdelete( char file[] ); 
    957  
    958 /* deletes file 
    959  * 
    960  * parameters of routine 
    961  * char       file[];    input; name of file to be deleted 
    962  */ 
    963  
    964  
    965 /*----------------------------------------------------------------------------*/ 
    966  
    967  
    968 void sy_frename( char from[], char to[] ); 
    969  
    970 /* renames filename from "from" to "to" 
    971  * 
    972  * parameters of routine 
    973  * char       from[];      input; old filename 
    974  * char       to[];        input; new filename 
    975  */ 
    976  
    977  
    978 /*------------------------------------------------------------------------*/ 
    979  
    980  
    981 void sy_localinf( char item[], char value[], STATUS *status ); 
    982  
    983 /* returns local info in "value" 
    984  * 
    985  * parameters of routine 
    986  * char       item[];     input; info item 
    987  * char       value[];    output; return value 
    988  * STATUS     *status;    output; return status 
    989  */ 
    990  
    991  
    992 /*------------------------------------------------------------------------*/ 
    993  
    994  
    995  
    996 #endif /* BC_VAX */ 
    997650 
    998651 
  • SH_SHM/branches/marcus/source/syscall.c

    r16 r101  
    265265void *sy_allocmem( long cnt, int size, STATUS *status ) 
    266266 
    267 /* allocates memory ("cnt" objects of size "size")  
     267/* allocates memory ("cnt" objects of size "size") 
    268268 * 
    269269 * parameters of routine 
     
    592592              if  (*filename == '.')  { 
    593593                 *filename = '\0'; 
    594                  return;  
     594                 return; 
    595595              } /*endif*/ 
    596596              filename++; 
     
    954954{ 
    955955        /* local constants */ 
    956 #       define MAXRAND 32767.0  
     956#       define MAXRAND 32767.0 
    957957 
    958958        /* local variables */ 
     
    10271027 
    10281028#endif /* BC_IBM */ 
    1029  
    1030  
    1031  
    1032 /****************************************************************** 
    1033  ***                         VAX version                        *** 
    1034  ******************************************************************/ 
    1035  
    1036  
    1037  
    1038 #ifdef BC_VAX 
    1039  
    1040  
    1041 #include <stdio.h> 
    1042 #include <string.h> 
    1043 #include <descrip.h> 
    1044 #include <rmsdef.h> 
    1045 #include <dvidef.h> 
    1046 #include <time.h> 
    1047 #include "basecnst.h" 
    1048 #ifdef BC_STDLIB_EX 
    1049 #include <stdlib.h> 
    1050 #endif 
    1051 #include "sysbase.h" 
    1052 #include "syerrors.h" 
    1053 #include "shc_main:shconst.h" 
    1054 #include "shc_main:shvars.h" 
    1055  
    1056  
    1057 /*------------------------------------------------------------------------*/ 
    1058  
    1059  
    1060  
    1061 void *sy_allocmem( long cnt, int size, STATUS *status ) 
    1062  
    1063 /* allocates memory ("cnt" objects of size "size) 
    1064  * 
    1065  * parameters of routine 
    1066  * long     cnt;            input; number of objects 
    1067  * int      size;           input; size of each object 
    1068  * STATUS   *status;        output; return status 
    1069  */ 
    1070 { 
    1071         /* local variables */ 
    1072         void     *ptr;     /* pointer to allocated memory */ 
    1073  
    1074         /* executable code */ 
    1075  
    1076         if  (cnt <= 0)  { 
    1077                 *status = SYE_ZEROALLOC; 
    1078                 return NULL; 
    1079         } /*endif*/ 
    1080         ptr = calloc( cnt, size ); 
    1081         if  (ptr == NULL)  *status = SYE_MEMOVFL; 
    1082         return ptr; 
    1083  
    1084 } /* end of sy_allocmem */ 
    1085  
    1086  
    1087  
    1088 /*------------------------------------------------------------------------*/ 
    1089  
    1090  
    1091  
    1092 void sy_deallocmem( void *ptr ) 
    1093  
    1094 /* deallocates memory 
    1095  * 
    1096  * parameter of routine 
    1097  * void     *ptr;        input; pointer to be freed 
    1098  */ 
    1099 { 
    1100         /* executable code */ 
    1101  
    1102         free( ptr ); 
    1103  
    1104 } /* end of sy_deallocmem */ 
    1105  
    1106  
    1107  
    1108 /*------------------------------------------------------------------------*/ 
    1109  
    1110  
    1111  
    1112 long sy_fread( void *strbuf, int size, long n, FILE *fp ) 
    1113  
    1114 /* reads "n" objects of size "size" from file "fp" 
    1115  * 
    1116  * parameters of routine 
    1117  * void     *strbuf;        output; buffer to read to 
    1118  * int      size;           input; size of each object 
    1119  * long     n;              input; number of objects 
    1120  * FILE     *fp;            input; file descriptor 
    1121  */ 
    1122 { 
    1123         /* executable code */ 
    1124  
    1125         return ((long)fread(strbuf,size,(int)n,fp)); 
    1126  
    1127 } /* end of sy_fread */ 
    1128  
    1129  
    1130  
    1131 /*------------------------------------------------------------------------*/ 
    1132  
    1133  
    1134  
    1135 long sy_fwrite( void *strbuf, int size, long n, FILE *fp ) 
    1136  
    1137 /* writes "n" objects of size "size" to file "fp" 
    1138  * 
    1139  * parameters of routine 
    1140  * void     *strbuf;        input; buffer to read to 
    1141  * int      size;           input; size of each object 
    1142  * long     n;              input; number of objects 
    1143  * FILE     *fp;            input; file descriptor 
    1144  */ 
    1145 { 
    1146         /* executable code */ 
    1147  
    1148         return ((long)fwrite(strbuf,size,(int)n,fp)); 
    1149  
    1150 } /* end of sy_fwrite */ 
    1151  
    1152  
    1153  
    1154 /*------------------------------------------------------------------------*/ 
    1155  
    1156  
    1157  
    1158 long sy_fbread( void *strbuf, int size, long n, BFILE fp ) 
    1159  
    1160 /* reads "n" objects of size "size" from binary file "fp" 
    1161  * 
    1162  * parameters of routine 
    1163  * void     *strbuf;        output; buffer to read to 
    1164  * int      size;           input; size of each object 
    1165  * long     n;              input; number of objects 
    1166  * BFILE    fp;             input; file descriptor 
    1167  */ 
    1168 { 
    1169         /* executable code */ 
    1170  
    1171         return fread(strbuf,size,n,fp); 
    1172  
    1173 } /* end of sy_fbread */ 
    1174  
    1175  
    1176  
    1177 /*------------------------------------------------------------------------*/ 
    1178  
    1179  
    1180  
    1181 long sy_fbwrite( void *strbuf, int size, long n, BFILE fp ) 
    1182  
    1183 /* writes "n" objects of size "size" to file "fp" 
    1184  * 
    1185  * parameters of routine 
    1186  * void     *strbuf;        input; buffer to read to 
    1187  * int      size;           input; size of each object 
    1188  * long     n;              input; number of objects 
    1189  * BFILE    fp;             input; file descriptor 
    1190  */ 
    1191 { 
    1192         /* executable code */ 
    1193  
    1194         return fwrite(strbuf,size,n,fp); 
    1195  
    1196 } /* end of sy_fbwrite */ 
    1197  
    1198  
    1199  
    1200 /*------------------------------------------------------------------------*/ 
    1201  
    1202  
    1203  
    1204 int sy_fbseek( BFILE fp, long pos, int mode ) 
    1205  
    1206 /* changes file position 
    1207  * 
    1208  * parameters of routine 
    1209  * BFILE      fp;    input; file pointer 
    1210  * long       pos;   input; new position 
    1211  * int        mode;  input; search mode 
    1212  */ 
    1213 { 
    1214  
    1215         return fseek( fp, pos, mode ); 
    1216  
    1217 } /* end of sy_fbseek */ 
    1218  
    1219  
    1220  
    1221 /*------------------------------------------------------------------------*/ 
    1222  
    1223  
    1224  
    1225 BFILE sy_fbopen( const char *file, const char *access ) 
    1226  
    1227 /* opens a binary file 
    1228  * 
    1229  * parameters of routine 
    1230  * const char    *file;    input; filename 
    1231  * const char    *access;  input; access mode 
    1232  */ 
    1233 { 
    1234         /* local variables */ 
    1235         int      handle; 
    1236  
    1237         /* executable code */ 
    1238  
    1239         return fopen( file, access ); 
    1240  
    1241 } /* end of sy_fbopen */ 
    1242  
    1243  
    1244  
    1245 /*------------------------------------------------------------------------*/ 
    1246  
    1247  
    1248  
    1249 int sy_fbclose( BFILE fp ) 
    1250  
    1251 /* closes binary file 
    1252  * 
    1253  * parameter of routine 
    1254  * BFILE     fp;      input; file pointer 
    1255  */ 
    1256 { 
    1257         return fclose( fp ); 
    1258  
    1259 } /* end of sy_fbclose */ 
    1260  
    1261  
    1262  
    1263 /*------------------------------------------------------------------------*/ 
    1264  
    1265 #ifdef XXX 
    1266  
    1267 void sy_findfile_vax( int request, char wild[], char filename[] ) 
    1268  
    1269 /* looks for files matching wild card string "wild". Returns filename of 
    1270  *   file found (no directory, no extension) or "\0" if not found. 
    1271  * 
    1272  * parameters of routine 
    1273  * int      request;        input; what elements (name,dir,ext) 
    1274  * char     *wild;          input; wild card string 
    1275  * char     *filename;      output; next file found 
    1276  */ 
    1277 { 
    1278         /* local variables */ 
    1279         static char   currwild[BC_FILELTH+1];  /* current wild card str */ 
    1280         static void   *fab;                    /* FAB address */ 
    1281         int           sy_status;               /* system service return status */ 
    1282         int           extpos;                  /* poistion of extension */ 
    1283         int           filpos;                  /* position of filename */ 
    1284         char          *c;                      /* moving pointer */ 
    1285         $DESCRIPTOR( in_f, " " ); 
    1286         $DESCRIPTOR( out_f, " " ); 
    1287  
    1288         /* executable code */ 
    1289  
    1290         if  (*wild == '\0')  { 
    1291                 *currwild = '\0'; 
    1292                 if  (fab != NULL)  { 
    1293                         lib$find_file_end( &fab ); 
    1294                         fab == NULL; 
    1295                 } /*endif*/ 
    1296                 return; 
    1297         } /*endif*/ 
    1298  
    1299         if  (strcmp(currwild,wild) != 0)  { 
    1300                 if  (fab != NULL)  { 
    1301                         lib$find_file_end( &fab ); 
    1302                         fab = NULL; 
    1303                 } /*endif*/ 
    1304                 strcpy( currwild, wild ); 
    1305         } /*endif*/ 
    1306  
    1307         in_f.dsc$w_length = strlen( currwild ); 
    1308         in_f.dsc$a_pointer = currwild; 
    1309         out_f.dsc$w_length = BC_FILELTH; 
    1310         out_f.dsc$a_pointer = filename; 
    1311         sy_status = lib$find_file( &in_f, &out_f, &fab ); 
    1312  
    1313         if  (sy_status != RMS$_NORMAL)  { 
    1314                 *filename = '\0'; 
    1315                 lib$find_file_end( &fab ); 
    1316                 fab == NULL; 
    1317         } /*endif*/ 
    1318  
    1319         /* delete blanks at end of string */ 
    1320         c = filename + strlen( filename ) - 1; 
    1321         while  (*c == ' '  &&  c >= filename) 
    1322                 *c-- = '\0'; 
    1323  
    1324         if  ((SYC_FF_NAME|SYC_FF_EXT|SYC_FF_DIR) == request)  return; 
    1325  
    1326         /* drop extension and/or directory */ 
    1327         filpos = 0; 
    1328         extpos = 0; 
    1329         c = filename; 
    1330         while  (*c != '\0')  { 
    1331                 if  (*c == '.')  { 
    1332                         extpos = c-filename; 
    1333                 } else if  ((*c == ']') || (*c == ':'))  { 
    1334                         filpos = c-filename; 
    1335                 } /*endif*/ 
    1336                 c++; 
    1337         } /*endwhile*/ 
    1338  
    1339         if  (!(SYC_FF_EXT & request)) 
    1340                 filename[extpos] = '\0'; 
    1341  
    1342         if  (!(SYC_FF_DIR & request) && filpos > 0) 
    1343                 strcpy( filename, filename+filpos+1 ); 
    1344  
    1345 } /* end of sy_findfile_vax */ 
    1346  
    1347 #endif  /* XXX */ 
    1348  
    1349 /*------------------------------------------------------------------------*/ 
    1350  
    1351 #define MAXFFCMDLTH 200 
    1352  
    1353 void sy_findfile( int request, char wild[], char filename[] ) 
    1354  
    1355 /* looks for files matching wild card string "wild". Returns filename of 
    1356  * file found (with/without directory and/or extension, depending on "request") or 
    1357  * "\0" if not found. 
    1358  * 
    1359  * parameters of routine 
    1360  * int      request;        input; what elements (name,dir,ext) 
    1361  * char     *wild;          input; wild card string 
    1362  * char     *filename;      output; next file found 
    1363  */ 
    1364 { 
    1365         /* local variables */ 
    1366         static char   currwild[BC_FILELTH+1];  /* current wild card string */ 
    1367         static char   dirfile[BC_FILELTH+1];   /* output filename */ 
    1368         static char   errfile[BC_FILELTH+1];   /* error output filename */ 
    1369         static FILE   *df;                     /* directory file */ 
    1370         char          cmd[MAXFFCMDLTH+1];      /* command string */ 
    1371         int           filpos;                  /* position of file name */ 
    1372         int           extpos;                  /* position of extension */ 
    1373         char          *c;                      /* moving pointer */ 
    1374         int           i;                       /* counter */ 
    1375         char          dirstr[BC_FILELTH+1];    /* directory string */ 
    1376  
    1377         /* executable code */ 
    1378  
    1379         if  (*dirfile == '\0')  { 
    1380                 strcpy( dirfile, shd_scratch ); 
    1381                 strcat( dirfile, id_shv ); 
    1382                 strcpy( errfile, dirfile ); 
    1383                 strcat( dirfile, "DIR.TMP" ); 
    1384                 strcat( errfile, "ERR.TMP" ); 
    1385         } /*endif*/ 
    1386  
    1387         if  (*wild == '\0')  { 
    1388                 *currwild = '\0'; 
    1389                 if  (df != NULL)  fclose( df ); 
    1390                 df = NULL; 
    1391                 return; 
    1392         } /*endif*/ 
    1393  
    1394         if  (strcmp(currwild,wild) != 0)  {  /* new wild card string */ 
    1395                 if  (df != NULL)  fclose( df ); 
    1396                 strcpy( currwild, wild ); 
    1397                 sy_fdelete( dirfile ); 
    1398                 strcpy( cmd, "$ dir/width=(file:70)/out=" ); 
    1399                 strcat( cmd, dirfile ); 
    1400                 strcat( cmd, " " ); 
    1401                 strcat( cmd, wild ); 
    1402                 system( cmd ); 
    1403                 printf( "                                               \r" ); 
    1404                 df = fopen( dirfile, "r" ); 
    1405                 if  (df == NULL)  { 
    1406                         *currwild = '\0'; 
    1407                         *filename = '\0'; 
    1408                         return; 
    1409                 } /*endif*/ 
    1410                 for  (i=0; i<3; i++)  fgets(filename,BC_FILELTH,df); 
    1411         } /*endif*/ 
    1412  
    1413         if  (fgets(filename,BC_FILELTH,df) == NULL) { 
    1414                 if  (df != NULL)  fclose( df ); 
    1415                 *currwild = '\0'; 
    1416                 *filename = '\0'; 
    1417                 return; 
    1418         } else if  (*filename == '\n')  { 
    1419                 if  (df != NULL)  fclose( df ); 
    1420                 *currwild = '\0'; 
    1421                 *filename = '\0'; 
    1422                 return; 
    1423         } /*endif*/ 
    1424  
    1425         filpos = 0; 
    1426         while  (filename[filpos] != ';') 
    1427                 filpos++; 
    1428         if  (filpos > BC_FILELTH)  { 
    1429                 printf( "*** this cannot happen (sy_findfile) ***\n" ); 
    1430                 exit( 0 ); 
    1431         } /*endif*/ 
    1432         filename[filpos] = '\0'; 
    1433  
    1434         if  (request == (SYC_FF_NAME|SYC_FF_EXT))  return; 
    1435  
    1436         if  (request & SYC_FF_DIR)  { 
    1437                 strcpy( dirstr, filename ); 
    1438                 filpos = strlen( wild ) - 1; 
    1439                 while  (filpos > 0  && 
    1440                         (wild[filpos] != ']' && wild[filpos] != ':'))  { 
    1441                         filpos--; 
    1442                 } /*endwhile*/ 
    1443                 if  (filpos > 0)  { 
    1444                         strncpy( filename, wild, filpos+1 ); 
    1445                         strcat( filename, dirstr ); 
    1446                 } /*endif*/ 
    1447         } /*endif*/ 
    1448  
    1449         if  (request & SYC_FF_EXT)  return; 
    1450  
    1451         extpos = 0; 
    1452         c = filename; 
    1453         while  (*c != '\0')  { 
    1454                 if  (*c == '.') 
    1455                         extpos = c-filename; 
    1456                 c++; 
    1457         } /*endwhile*/ 
    1458  
    1459         filename[extpos] = '\0'; 
    1460  
    1461 } /* end of sy_findfile */ 
    1462  
    1463  
    1464  
    1465 /*------------------------------------------------------------------------*/ 
    1466  
    1467  
    1468  
    1469 void sy_system( char *cmd, STATUS *status ) 
    1470  
    1471 /* call to operating system 
    1472  * 
    1473  * parameters of routine 
    1474  * char     *cmd;           input; system command 
    1475  * STATUS   *status;        output; return status 
    1476  */ 
    1477 { 
    1478         /* local variables */ 
    1479         int      sy_status;     /* system service return status */ 
    1480         $DESCRIPTOR( cmd_dscr, " " ); 
    1481  
    1482         /* executable code */ 
    1483  
    1484         cmd_dscr.dsc$w_length = strlen( cmd ); 
    1485         cmd_dscr.dsc$a_pointer = cmd; 
    1486         sy_status = lib$spawn( &cmd_dscr ); 
    1487         if  (!sy_status)  lib$signal( sy_status ); 
    1488  
    1489 } /* end of sy_system */ 
    1490  
    1491  
    1492  
    1493  
    1494 /*------------------------------------------------------------------------*/ 
    1495  
    1496  
    1497  
    1498 double sy_random( double ampl ) 
    1499  
    1500 /* creates random number with absolute value less than (or equal to) 
    1501  * "amp" 
    1502  * 
    1503  * parameters of routine 
    1504  * double      ampl;      input; max. amplitude; if zero, a new random 
    1505  *                               series is started 
    1506  */ 
    1507 { 
    1508         /* local constants */ 
    1509 #   define MAXRAND 32767.0 
    1510  
    1511         /* local variables */ 
    1512         int      rdm;         /* integer random result */ 
    1513  
    1514         /* executable code */ 
    1515  
    1516         if  (ampl == 0.0)  { 
    1517                 srand( (unsigned)clock() ); 
    1518                 return 0.0; 
    1519         } else { 
    1520                 rdm = rand(); 
    1521                 return  ( (((double)rdm * 2.0) / MAXRAND - 1.0) * ampl ); 
    1522         } /*endif*/ 
    1523  
    1524 } /* end of sy_random */ 
    1525  
    1526  
    1527  
    1528 /*------------------------------------------------------------------------*/ 
    1529  
    1530  
    1531  
    1532 DIFFTIME sy_difftime( void ) 
    1533  
    1534 /* returns time since last sy_difftime call 
    1535  */ 
    1536 { 
    1537 #ifdef BC_CLOCK_T_AVAILABE 
    1538         /* local variables */ 
    1539         static clock_t  diff;    /* time mark */ 
    1540         clock_t         curr;    /* current time */ 
    1541         clock_t         tmp;     /* scratch */ 
    1542  
    1543         /* executable code */ 
    1544  
    1545         curr = clock(); 
    1546         tmp = curr - diff; 
    1547         diff = curr; 
    1548         return ((DIFFTIME)tmp/200.0); 
    1549 #else 
    1550         return 0.0; 
    1551 #endif 
    1552 } /* end of sy_difftime */ 
    1553  
    1554  
    1555  
    1556 /*------------------------------------------------------------------------*/ 
    1557  
    1558  
    1559  
    1560 void sy_randomstr( int lth, char str[] ) 
    1561  
    1562 /* creates random string of length "lth" 
    1563  * 
    1564  * parameters of routine 
    1565  * int        lth;      input; length of output string 
    1566  * char       str[];    output; random string 
    1567  */ 
    1568 { 
    1569         /* local variables */ 
    1570 #       ifdef BC_CLOCK_T_AVAILABLE 
    1571         clock_t  currtime;  /* current time */ 
    1572 #       else 
    1573         long     currtime; 
    1574 #       endif 
    1575         char     minstr[6]; /* minimum length string */ 
    1576         int      i;         /* counter */ 
    1577  
    1578         /* executable code */ 
    1579  
    1580         if  (lth < 3)  { 
    1581                 *str = '\0'; 
    1582                 return; 
    1583         } /*endif*/ 
    1584         *str++ = '$'; 
    1585         lth -= 2; 
    1586  
    1587 #       ifdef BC_CLOCK_T_AVAILABLE 
    1588         currtime = clock(); 
    1589 #       else 
    1590         currtime = time( NULL ); 
    1591 #       endif 
    1592         currtime %= 10000L; 
    1593         sprintf( minstr, "%04d", time ); 
    1594         if  (lth < 4)  { 
    1595                 for  (i=0;i<lth;i++) 
    1596                         str[i] = minstr[i]; 
    1597         } else { 
    1598                 strcpy( str, minstr ); 
    1599                 for  (i=4; i<lth; i++) 
    1600                         str[i] = '0'; 
    1601         } /*endif*/ 
    1602         str[lth] = '_'; 
    1603         str[lth+1] = '\0'; 
    1604  
    1605 } /* end of sy_randomstr */ 
    1606  
    1607  
    1608  
    1609 /*------------------------------------------------------------------------*/ 
    1610  
    1611  
    1612  
    1613 void sy_fdelete( char file[] ) 
    1614  
    1615 /* deletes file 
    1616  * 
    1617  * parameters of routine 
    1618  * char       file[];    input; name of file to be deleted 
    1619  */ 
    1620 { 
    1621         /* local variables */ 
    1622         char     str[BC_FILELTH+2];   /* copy of file name */ 
    1623         $DESCRIPTOR( fd, " " ); 
    1624  
    1625         /* executable code */ 
    1626  
    1627         strncpy( str, file, BC_FILELTH ); 
    1628         strcat( str, ";*" ); 
    1629         fd.dsc$w_length = strlen( str ); 
    1630         fd.dsc$a_pointer = str; 
    1631         lib$delete_file( &fd ); 
    1632  
    1633 } /* end of sy_fdelete */ 
    1634  
    1635  
    1636  
    1637 /*----------------------------------------------------------------------------*/ 
    1638  
    1639  
    1640  
    1641 void sy_frename( char from[], char to[] ) 
    1642  
    1643 /* renames filename from "from" to "to" 
    1644  * 
    1645  * parameters of routine 
    1646  * char       from[];      input; old filename 
    1647  * char       to[];        input; new filename 
    1648  */ 
    1649 { 
    1650         /* local variables */ 
    1651         $DESCRIPTOR( src, " " ); 
    1652         $DESCRIPTOR( dst, " " ); 
    1653         int      systat; 
    1654  
    1655         /* executable code */ 
    1656  
    1657         src.dsc$w_length = strlen( from ); 
    1658         src.dsc$a_pointer = from; 
    1659         dst.dsc$w_length = strlen( to ); 
    1660         dst.dsc$a_pointer = to; 
    1661         systat = lib$rename_file( &src, &dst ); 
    1662         if  (systat != 1)  { 
    1663                 printf( "\n-> rename %s to %s failed\n", from, to ); 
    1664                 exit( 1 ); 
    1665         } /*endif*/ 
    1666  
    1667 } /* end of sy_frename */ 
    1668  
    1669  
    1670  
    1671 /*------------------------------------------------------------------------*/ 
    1672  
    1673  
    1674  
    1675 void sy_localinf( char item[], char value[], STATUS *status ) 
    1676  
    1677 /* returns local info in "value" 
    1678  * 
    1679  * parameters of routine 
    1680  * char       item[];     input; info item 
    1681  * char       value[];    output; return value 
    1682  * STATUS     *status;    output; return status 
    1683  */ 
    1684 { 
    1685         /* local variables */ 
    1686         char     str[BC_LINELTH+1]; 
    1687         $DESCRIPTOR( str_dsc, str ); 
    1688         char     volname[BC_LINELTH+1];     /* name of volume */ 
    1689         $DESCRIPTOR( volname_dsc, volname ); 
    1690         int      i;                         /* integer */ 
    1691  
    1692         /* executable code */ 
    1693  
    1694         if  (strncmp(item,"GET_VOLNAME:",12) == 0)  { 
    1695                 strcpy( str, item+12 );  /* get device name */ 
    1696                 i = strlen( str ) - 1; 
    1697                 if  (str[i] != ':')  strcat( str, ":" ); 
    1698                 i = DVI$_VOLNAM; 
    1699                 volname_dsc.dsc$w_length = BC_FILELTH; 
    1700                 lib$getdvi( &i, NULL, &str_dsc, NULL, &volname_dsc, NULL ); 
    1701                 /* printf( "--> lth: %d\n", strlen(volname) ); */ 
    1702                 /* printf( "--> str: >%s<\n", volname ); */ 
    1703                 if  (strlen(volname) == BC_LINELTH+1)  { 
    1704                         volname[BC_LINELTH] = '\0'; 
    1705                 } else if  (strlen(volname) > BC_LINELTH)  { 
    1706                         printf( "*** *** string overflow happened *** ***\n" ); 
    1707                         *status = SYE_STROVFL; 
    1708                         return; 
    1709                 } /*endif*/ 
    1710                 /* remove blanks */ 
    1711                 i = strlen( volname ) - 1; 
    1712                 if  (i >= BC_FILELTH) 
    1713                         i = BC_FILELTH-1; 
    1714                 while  (volname[i] == ' ') 
    1715                         i--; 
    1716                 if  (i >= -1 && i <= BC_LINELTH) 
    1717                         volname[i+1] = '\0'; 
    1718                 strcpy( value, volname ); 
    1719         } else { 
    1720                 *status = SYE_LOCALINF; 
    1721         } /*endif*/ 
    1722  
    1723 } /* end of sy_localinf */ 
    1724  
    1725  
    1726  
    1727 /*----------------------------------------------------------------------------*/ 
    1728  
    1729  
    1730 #endif /* BC_VAX */ 
    1731  
    17321029 
    17331030 
     
    19521249{ 
    19531250        /* local constants */ 
    1954 #       define MAXRAND 32767.0  
     1251#       define MAXRAND 32767.0 
    19551252 
    19561253        /* local variables */ 
Note: See TracChangeset for help on using the changeset viewer.