github.com/open-simh.simtools
1
0
Fork 0
mirror of https://github.com/open-simh/simtools.git synced 2026-01-13 15:27:18 +00:00
Code Issues Projects Releases Wiki Activity
open-simh.simtools/extracters/ods2/createcmd.c
Timothe Litt 66e00b9900 Backlog of work since 2016 
Too much to list all, but includes (in no particular order):
 - Cleanup for 64-bit builds, MSVC warnings.
 - Structured help
 - Help file compiler.
 - Supports volsets, writes/create work.
 - Support for I18n in messages, help.
 - Makefiles.
 - Initialize volume/volset
 - Command line editing/history

Builds and works on Linux and Windows (VS).
Not recently built or tested on other platforms, but
not intentinonally broken.
2022-10-10 11:00:20 -04:00

674 lines
21 KiB
C
Raw Blame History

/* This is part of ODS2 written by Paul Nankervis,
* email address: Paulnank@au1.ibm.com
*
* ODS2 is distributed freely for all members of the
* VMS community to use. However all derived works
* must maintain comments in their source to acknowledge
* the contributions of the original author and
* subsequent contributors. This is free software; no
* warranty is offered, and while we believe it to be useful,
* you use it at your own risk.
*/
#if !defined( DEBUG ) && defined( DEBUG_CREATECMD )
#define DEBUG DEBUG_CREATECMD
#else
#ifndef DEBUG
#define DEBUG 0
#endif
#endif
#include "cmddef.h"
static vmscond_t create_directory( options_t options, int argc, char** argv );
static vmscond_t create_file( options_t options, int argc, char** argv );
/******************************************************************* docreate() */
#define create_log OPT_GENERIC_1
#define create_dir OPT_GENERIC_2
#define create_owner OPT_GENERIC_3
#define create_protect OPT_GENERIC_4
#define create_volume OPT_GENERIC_5
#define create_verlim OPT_GENERIC_6
#define create_recfmt (OPT_GENERIC_10|OPT_GENERIC_9|OPT_GENERIC_8)
#define create_v_recfmt (OPT_V_GENERIC + 7)
#define create_b4 (OPT_SHARED_2|OPT_SHARED_1)
#define create_v_b4 0
#define create_after (OPT_SHARED_4|OPT_SHARED_3)
#define create_v_after 2
#define create_prn_none 0
#define create_prn_nl 1
#define create_prn_c0 2
#define create_prn_vfu 3
#define create_prn OPT_SHARED_17
#define create_ftn OPT_SHARED_18
#define create_cr OPT_SHARED_19
#define create_span OPT_SHARED_20
static uint32_t b4n, aftn;
static uint32_t vfclen;
static uint32_t reclen;
static uint32_t verlimit;
static uint32_t volume;
static uint32_t protection;
static uint32_t ownuic;
static qual_t
prnb4[] = { {"none", create_prn_none << create_v_b4,
create_b4, NV, "commands create qual_cc print b4 none"},
{"nl", create_prn_nl << create_v_b4,
create_b4, DV(&b4n), "commands create qual_cc print b4 nl"},
{"ctl", create_prn_c0, create_b4, DV(&b4n), "commands create qual_cc print b4 ctl"},
{"vfu", create_prn_vfu << create_v_b4,
create_b4, DV(&b4n), "commands create qual_cc print b4 vfu"},
{NULL, 0, 0, NV, NULL}
};
static qual_t
prnafter[] = { {"none", create_prn_none << create_v_after,
create_after, NV, "commands create qual_cc print b4 none"},
{"nl", create_prn_nl << create_v_after,
create_after, DV(&aftn), "commands create qual_cc print b4 nl"},
{"ctl", create_prn_c0, create_b4, DV(&aftn), "commands create qual_cc print b4 ctl"},
{"vfu", create_prn_vfu << create_v_after,
create_after, DV(&aftn), "commands create qual_cc print b4 vfu"},
{NULL, 0, 0, NV, NULL}
};
static qual_t
prnkwds[] = { {"before", 0, create_b4, KV(prnb4), "commands create qual_cc print b4"},
{"after", 0, create_after, KV(prnafter), "commands create qual_cc print after"},
{NULL, OPT_NOSORT, 0, NV, NULL}
};
static qual_t
cckwds[] = { {"fortran", create_ftn, create_cr|create_prn, NV,
"commands create qual_cc fortran"},
{"carriage_return", create_cr, create_ftn|create_prn, NV,
"commands create qual_cc cr"},
{"print", create_prn|(FAB$C_VFC<<create_v_recfmt),
create_ftn|create_cr|create_recfmt, KV(prnkwds),
"commands create qual_cc print"},
{"none", 0, create_ftn|create_cr|create_prn, NV,
"commands create qual_cc none"},
{NULL, 0, 0, NV, NULL}
};
static qual_t
fmtkwds[] = { {"fixed", (FAB$C_FIX +1) << create_v_recfmt,
create_recfmt, DV(&reclen),
"commands create qual_recfmt fixed"},
{"variable", (FAB$C_VAR +1) << create_v_recfmt,
create_recfmt, NV,
"commands create qual_recfmt variable"},
{"vfc", (FAB$C_VFC +1) << create_v_recfmt,
create_recfmt, VOPT(DV(&vfclen)),
"commands create qual_recfmt vfc"},
{"stream", (FAB$C_STM +1) << create_v_recfmt,
create_recfmt, NV,
"commands create qual_recfmt stream"},
{"streamlf", (FAB$C_STMLF +1) << create_v_recfmt,
create_recfmt, NV,
"commands create qual_recfmt streamlf"},
{"streamcr", (FAB$C_STMCR +1) << create_v_recfmt,
create_recfmt, NV,
"commands create qual_recfmt streamcr"},
{"undefined", (FAB$C_UDF +1) << create_v_recfmt,
create_recfmt, NV,
"commands create qual_recfmt undefined"},
{NULL, 0, 0, NV, NULL}
};
qual_t
createquals[] = { {"log", create_log, 0, NV,
"-commands create qual_log"},
{"nolog", 0, create_log, NV, NULL },
{"directory", create_dir, 0, NV,
"commands create qual_directory"},
{"version_limit", create_verlim, 0, DV(&verlimit),
"commands create qual_verlim"},
#if 0
{"volume", create_volume, 0, DV(&volume),
"commands create qual_volume"},
#endif
{"owner_uic", create_owner, 0, UV(&ownuic),
"commands create qual_owner" },
{"protection", create_protect, 0, PV(&protection),
"commands create qual_protection"},
{"record_format", 0, 0, KV(fmtkwds),
"commands create qual_recfmt"},
{"carriage_control", 0, 0, KV(cckwds),
"commands create qual_cc"},
{"span", create_span, 0, NV, "commands create qual_span"},
{"nospan", 0, create_span,NV, NULL},
{ NULL, 0, 0, NV, NULL }
};
param_t
createpars[] = { {"parameter", REQ, STRING, NOPA, "commands create filespec"},
{ NULL, 0, 0, NOPA, NULL }
};
DECL_CMD(create) {
vmscond_t sts;
options_t options;
vfclen = 0;
reclen = 0;
if( $FAILS(sts = checkquals( &options, create_span, createquals, qualc, qualv )) ) {
return sts;
}
if( options & create_dir )
return create_directory( options, argc, argv );
return create_file( options, argc, argv );
}
/******************************************************************* create_directory() */
static vmscond_t create_directory( options_t options, int argc, char **argv ) {
vmscond_t sts;
char tdir[NAM$C_MAXRSS+1],
rsname[NAM$C_MAXRSS+1];
struct FAB fab = cc$rms_fab;
struct NAM nam = cc$rms_nam;
UNUSED(argc);
do {
int level;
char newdir[NAM$C_MAXRSS + 1], *p;
uint8_t newlen, devlen, newdirlen, tmplen, sfdlen;
struct XABPRO parpro;
struct XABFHC parfhc;
parpro = cc$rms_xabpro;
parfhc = cc$rms_xabfhc;
nam.nam$b_ess = sizeof( newdir ) -1;
nam.nam$l_esa = newdir;
nam.nam$b_rss = sizeof( rsname ) -1;
nam.nam$l_rsa = rsname;
fab.fab$l_nam = &nam;
fab.fab$b_fac = 0;
fab.fab$l_fop = FAB$M_OFP;
fab.fab$l_fna = argv[1];
fab.fab$b_fns = (uint8_t)strlen(fab.fab$l_fna);
/* Check syntax & see if specified directory exists */
sts = sys_parse( &fab );
tdir[nam.nam$b_rsl] = '\0';
newdir[nam.nam$b_esl] = '\0';
devlen = nam.nam$b_dev;
newdirlen = nam.nam$b_dir;
newlen = devlen + newdirlen;
if( $SUCCESSFUL(sts) &&
!(nam.nam$l_fnb & (NAM$M_EXP_NAME | NAM$M_EXP_TYPE |
NAM$M_EXP_VER | NAM$M_WILDCARD)) ) {
rsname[newlen] = '\0';
sts = printmsg( CREATE_EXISTS, 0, rsname );
break;
}
if( $FAILED(sts) && !$MATCHCOND(sts, RMS$_DNF) ) {
sts = printmsg( sts, 0 );
break;
}
if( nam.nam$l_fnb & (NAM$M_EXP_NAME | NAM$M_EXP_TYPE |
NAM$M_EXP_VER | NAM$M_WILDCARD) ) {
sts = printmsg( RMS$_DIR, 0 );
break;
}
/* Scan from MFD down to apply defaults and fill in missing
* SFDs.
*/
p = newdir+devlen+1;
memcpy( tdir, newdir, devlen );
memcpy( tdir+devlen, "[000000]000000.DIR;1",
sizeof( "[000000]000000.DIR;1" ) -1 );
tmplen = sizeof( "[000000]" ) -1;
sfdlen = sizeof( "000000" ) -1;
level = 0;
fab.fab$b_fns =
nam.nam$b_ess =
fab.fab$b_dns = 0;
nam.nam$l_rlf = NULL;
nam.nam$b_nop = NAM$M_SYNCHK;
(void) sys_parse( &fab ); /* Release context */
fab.fab$l_nam = NULL;
fab.fab$l_fna = tdir;
sts = SS$_NORMAL;
while( TRUE ) {
uint32_t directory;
uint16_t retlen;
struct XABFHC fhc;
struct XABPRO pro;
struct XABITM itm;
struct item_list xitems[] = {
{ XAB$_UCHAR_DIRECTORY, sizeof(int), NULL, 0 },
{ 0, 0, NULL, 0 }
};
fhc = cc$rms_xabfhc;
pro = cc$rms_xabpro;
itm = cc$rms_xabitm;
itm.xab$l_nxt = &fhc;
xitems[0].buffer = &directory; xitems[0].retlen = &retlen;
itm.xab$b_mode = XAB$K_SENSEMODE;
itm.xab$l_itemlist = xitems;
pro.xab$l_nxt = &itm;
fab.fab$l_xab = &pro;
fab.fab$b_fns = devlen+tmplen+sfdlen+6;
tdir[fab.fab$b_fns] = '\0';
if( $SUCCESSFUL(sys_open(&fab)) ) {
fab.fab$l_xab = NULL;
sys_close( &fab );
if( !directory ) {
sts = printmsg( CREATE_NOTDIR, 0, tdir );
break;
}
parpro = pro;
parfhc = fhc;
} else {
struct FAB nfab = cc$rms_fab;
struct NAM nam = cc$rms_nam;
struct XABALL all = cc$rms_xaball;
all.xab$l_alq = 1;
if( options & create_volume )
all.xab$w_vol = (uint16_t)volume;
fhc = parfhc;
if( options & create_verlim )
fhc.xab$w_verlimit = verlimit;
fhc.xab$l_nxt = &all;
pro = parpro;
pro.xab$w_pro |= ( ((xab$m_nodel) << xab$v_system) |
((xab$m_nodel) << xab$v_owner) |
((xab$m_nodel) << xab$v_group) |
((xab$m_nodel) << xab$v_world) );
if( options & create_protect ) {
pro.xab$w_pro = (uint16_t)
((pro.xab$w_pro & ~(protection >> 16)) |
(uint16_t)protection);
}
if( options & create_owner ) {
pro.xab$l_uic = ownuic;
}
itm.xab$l_nxt = &fhc;
directory = 1;
itm.xab$b_mode = XAB$K_SETMODE;
pro.xab$l_nxt = &itm;
nfab.fab$l_xab = &pro;
nam.nam$b_rss = sizeof( rsname ) -1;
nam.nam$l_rsa = rsname;
nfab.fab$l_nam = &nam;
nfab.fab$b_fac = 0;
nfab.fab$l_fop = FAB$M_OFP;
nfab.fab$b_org = FAB$C_SEQ;
nfab.fab$b_rat = FAB$M_BLK;
nfab.fab$b_rfm = FAB$C_VAR;
fhc.xab$w_lrl =
nfab.fab$w_mrs = 512;
nfab.fab$b_fns = fab.fab$b_fns;
nfab.fab$l_fna = fab.fab$l_fna;
sts = sys_create( &nfab );
rsname[nam.nam$b_rsl] = '\0';
if( $FAILED(sts) ) {
printmsg( CREATE_CREDIRFAIL, 0, rsname );
sts = printmsg( sts, MSG_CONTINUE, CREATE_CREDIRFAIL );
} else {
if( $FAILS(sts = sys_close(&nfab)) ) {
printmsg(CREATE_CLOSEOUT, 0, rsname);
sts = printmsg(sts, MSG_CONTINUE, CREATE_CLOSEOUT);
}
}
nfab.fab$b_fns =
nam.nam$b_ess = 0;
nfab.fab$b_dns = 0;
nam.nam$b_nop = NAM$M_SYNCHK;
(void) sys_parse( &nfab );
if( $FAILED(sts) )
break;
if( options & create_log )
sts = printmsg( CREATE_CREATED, 0, rsname );
}
if( *p == ']' )
break;
switch( level++ ) {
case 0:
break;
case 1:
memmove( tdir+devlen+1, tdir+devlen+tmplen, sfdlen );
tmplen = 1+ sfdlen +1;
tdir[devlen+tmplen-1] = ']';
break;
default:
tdir[devlen+tmplen -1] = '.';
tmplen += 1 + sfdlen;
tdir[devlen+tmplen -1] = ']';
break;
}
for( sfdlen = 0; *p != '.' && *p != ']'; sfdlen++ )
tdir[devlen+tmplen+sfdlen] = *p++;
memcpy( tdir+devlen+tmplen+sfdlen, ".DIR;1", 6 );
if( *p == '.' )
++p;
}
} while( 0 );
if( nam.nam$l_fnb & (NAM$M_EXP_NAME | NAM$M_EXP_TYPE |
NAM$M_EXP_VER | NAM$M_WILDCARD) ) {
sts = printmsg( RMS$_DIR, 0 );
}
fab.fab$b_fns =
nam.nam$b_ess =
fab.fab$b_dns = 0;
nam.nam$b_nop = NAM$M_SYNCHK;
(void) sys_parse( &fab );
return sts;
}
/******************************************************************* create_file() */
static vmscond_t create_file( options_t options, int argc, char** argv ) {
vmscond_t sts;
char *buf = NULL;
size_t bufsize = 80;
char vfc[2], rsbuf[NAM$C_MAXRSS + 1];
struct NAM nam;
struct FAB fab;
struct RAB rab;
struct XABPRO pro;
UNUSED( argc );
nam = cc$rms_nam;
fab = cc$rms_fab;
rab = cc$rms_rab;
pro = cc$rms_xabpro;
nam.nam$l_esa = NULL;
nam.nam$b_ess = 0;
nam.nam$b_rss = sizeof( rsbuf ) -1;
nam.nam$l_rsa = rsbuf;
if( options & (create_protect|create_owner) ) {
fab.fab$l_xab = &pro;
if( options & create_protect ) {
pro.xab$w_pro = (uint16_t)
((pro.xab$w_pro & ~(protection >> 16)) |
(uint16_t)protection);
}
if( options & create_owner ) {
pro.xab$l_uic = ownuic;
}
}
fab.fab$l_nam = &nam;
fab.fab$b_fac = FAB$M_PUT;
fab.fab$l_fop = FAB$M_OFP | FAB$M_TEF;
fab.fab$b_org = FAB$C_SEQ;
if( !(options & create_recfmt) ) {
options |= (FAB$C_VAR +1) << create_v_recfmt;
if( !(options & (create_prn|create_ftn|create_cr)) )
options |= create_cr;
}
fab.fab$b_rfm = ((options & create_recfmt) >> create_v_recfmt) -1;
switch( fab.fab$b_rfm ) {
case FAB$C_STM:
case FAB$C_STMLF:
case FAB$C_STMCR:
fab.fab$b_rat |= FAB$M_CR;
break;
case FAB$C_VFC:
fab.fab$b_fsz = vfclen;
break;
}
if( !(options & create_span) )
fab.fab$b_rat |= FAB$M_BLK;
if( options & create_ftn )
fab.fab$b_rat |= FAB$M_FTN;
if( options & create_cr )
fab.fab$b_rat |= FAB$M_CR;
if( options & create_prn ) {
fab.fab$b_rat |= FAB$M_PRN;
fab.fab$b_fsz = 2;
fab.fab$b_rfm = FAB$C_VFC;
switch( (options & create_b4) >> create_v_b4 ) {
case create_prn_none:
vfc[0] = 0;
break;
case create_prn_nl:
if( b4n < 1 || b4n > 127 )
return printmsg( CREATE_INVALIDNL, 0 );
vfc[0] = b4n & 0x7f;
break;
case create_prn_c0:
if( b4n > 31 )
return printmsg( CREATE_INVALIDC0, 0 );
vfc[0] = 0x80 | b4n;
break;
case create_prn_vfu:
if( b4n < 1 || b4n > 16 )
return printmsg( CREATE_INVALIDVFU, 0 );
vfc[0] = (0xC0 | (b4n -1)) & 0xff;
}
switch( (options & create_after) >> create_v_after ) {
case create_prn_none:
vfc[1] = 0;
break;
case create_prn_nl:
if( aftn < 1 || aftn > 127 )
return printmsg( CREATE_INVALIDNL, 0 );
vfc[1] = aftn & 0x7f;
break;
case create_prn_c0:
if( aftn > 31 )
return printmsg( CREATE_INVALIDC0, 0 );
vfc[1] = 0x80 | aftn;
break;
case create_prn_vfu:
if( aftn < 1 || aftn > 16 )
return printmsg( CREATE_INVALIDVFU, 0 );
vfc[1] = (0xC0 | (aftn -1)) & 0xff;
}
} /* prn */
/*
fab.fab$w_deq = 5;
fab.fab$l_alq = 100;
*/
fab.fab$w_mrs = (uint16_t)reclen;
fab.fab$l_fna = argv[1];
fab.fab$b_fns = (uint8_t)strlen(fab.fab$l_fna);
do {
char *input;
sts = sys_create( &fab );
rsbuf[nam.nam$b_rsl] = '\0';
if( $FAILED(sts) )
break;
rab.rab$l_fab = &fab;
if( $FAILS(sts = sys_connect( &rab )) )
break;
if( options & create_prn )
rab.rab$l_rhb = vfc;
if( options & create_log ) {
printmsg( CREATE_READY, 0, rsbuf );
printmsg( CREATE_TERMEOF, MSG_CONTINUE, CREATE_READY,
#if defined( VMS ) || defined( _WIN32 )
"Control-Z"
#ifdef _WIN32
" Enter"
#endif
#else
"Control-D"
#endif
);
}
while( (input = fgetline( stdin, FALSE, &buf, &bufsize )) != NULL ) {
size_t len;
len = strlen( input );
sts = SS$_NORMAL;
#if 0
if( len && input[len -1] == '\r' )
len--;
#endif
rab.rab$l_rbf = input;
switch( fab.fab$b_rfm ) {
case FAB$C_FIX:
if( len > (size_t)fab.fab$w_mrs )
len = fab.fab$w_mrs;
else if( len < (size_t)fab.fab$w_mrs ) {
char *p = input;
if( bufsize < fab.fab$w_mrs ) {
p = realloc( buf, fab.fab$w_mrs );
if( p == NULL ) {
sts = SS$_INSFMEM;
break;
}
bufsize = fab.fab$w_mrs;
rab.rab$l_rbf =
buf =
input = p;
}
p += len;
len = fab.fab$w_mrs - len;
while( len-- )
*p++ = ' ';
len = fab.fab$w_mrs;
}
break;
case FAB$C_VFC:
if( !(options & create_prn) ) {
if( len < fab.fab$b_fsz ) {
sts = RMS$_RFM;
break;
}
rab.rab$l_rhb = input;
rab.rab$l_rbf = input + fab.fab$b_fsz;
len -= fab.fab$b_fsz;
}
break;
}
if( $SUCCESSFUL(sts) ) {
rab.rab$w_rsz = (uint16_t)len;
sts = sys_put(&rab);
}
if( $FAILED(sts) )
break;
}
break;
} while( 0 );
if( buf != NULL ) free( buf );
if( $FAILED(sts) ) {
vmscond_t rsts;
int err;
err = errno;
rsts = printmsg( sts, 0, nam.nam$b_rsl? rsbuf: argv[1] );
if( err )
printmsg( ODS2_OSERROR, MSG_CONTINUE, sts, strerror( err ) );
sts = rsts;
}
sys_disconnect( &rab );
if( $SUCCESSFUL( sts ) ) {
if( $FAILS(sts = sys_close( &fab )) ) {
vmscond_t rsts;
int err;
err = errno;
rsts = printmsg( CREATE_CLOSEOUT, 0,
nam.nam$b_rsl? rsbuf: argv[1] );
printmsg( sts, MSG_CONTINUE, rsts, nam.nam$b_rsl? rsbuf: argv[1] );
if( err )
printmsg( ODS2_OSERROR, MSG_CONTINUE, sts, strerror( err ) );
sts = rsts;
}
} else {
sys_close( &fab );
}
if( $SUCCESSFUL( sts ) && (options & create_log) )
sts = printmsg( CREATE_CREATED, 0, rsbuf );
return sts;
}
Reference in New Issue View Git Blame Copy Permalink