main(int argc, char *argv[])
{
int istat, narg, nchar;
char process[MAXLINE];
// set program name
strcpy(prog_name, PNAME);
// check command line for correct usage
fprintf(stdout, "\n%s Arguments: ", prog_name);
for (narg = 0; narg < argc; narg++)
fprintf(stdout, "<%s> ", argv[narg]);
fprintf(stdout, "\n");
if (argc > 1)
sscanf(argv[1], "%s", process);
else
strcpy(process, "");
nchar = 0;
while ( nchar < MAXLINE && (process[nchar] = toupper(process[nchar])) )
nchar++;
if (strcmp(process, "90CW") == 0) {
if (argc < 4) {
puterr("ERROR wrong number of command line arguments.");
disp_usage(PNAME, "90CW <input_gridfile> <output_gridfile>");
exit(-1);
}
if ((istat = Rotate90CW(argc, argv)) < 0) {
puterr("ERROR doing Rotate 90CW process.");
exit(-1);
}
} else {
sprintf(MsgStr,
"ERROR unrcognized process - <%s>.", process);
puterr(MsgStr);
disp_usage(PNAME, "90CW/... <arguments>");
exit(-1);
}
exit(0);
}
char *read_all(int fd, fd_set *readf,
t_buffs *buffs, char **chan_nick)
{
t_list *tmp_cmd;
int ret;
buffs->cmds ? free_content(buffs->cmds) : 0;
buffs->cmds ? buffs->cmds->destroy(buffs->cmds) : 0;
buffs->cmds = NULL;
if (FD_ISSET(fd, readf))
{
if ((ret = get_cmd_buff(fd, buffs)) == -1)
return (NULL);
else if (ret == -3)
return (NULL);
else if (ret == -2)
puterr("Reply too long\n", 0);
}
tmp_cmd = buffs->cmds;
while (tmp_cmd)
{
fprintf(stderr, "%s\n", (char *)tmp_cmd->struc);
change_channel((char *)tmp_cmd->struc, chan_nick[0], chan_nick[1]);
tmp_cmd = tmp_cmd->next;
}
if (FD_ISSET(0, readf))
return (get_next_line(0));
return ("");
}
t_list *create_list(void *struc, t_list *old)
{
t_list *list;
if (!(list = malloc(sizeof(*list))) ||
!(list->first = old ? old->first : malloc(sizeof(t_list *))) ||
!(list->last = old ? old->last : malloc(sizeof(t_list *))) ||
!(list->size = old ? old->size : malloc(sizeof(unsigned int))))
return (puterr(ERR_MALLOC, NULL));
!old ? *list->first = list : 0;
!old ? *list->last = list : 0;
!old ? *list->size = 1 : 0;
list->struc = struc;
list->next = NULL;
list->prev = NULL;
list->push_back = &push_back_list;
list->push_front = &push_front_list;
list->pop_back = &pop_back_list;
list->pop_front = &pop_front_list;
list->insert_at = &insert_at_list;
list->make_circular = &make_circular_list;
list->destroy = &destroy_list;
list->get_nth = &get_nth_list;
list->delete_nth = &delete_nth_list;
list->get_size = &get_size_list;
return (list);
}
/* sed: perform a basic sed substitution command on input */
int sed(char *s, size_t max, const char *input, const char *sedcmd)
{
char cmd[MAX_MSG];
struct sedinfo sedbuf;
std::regex pattern;
auto type = std::regex_constants::format_sed;
strncpy(cmd, sedcmd, MAX_MSG);
if (!parsecmd(&sedbuf, cmd)) {
puterr(s, max, &sedbuf);
return 0;
}
try {
if (!sedbuf.ignore)
pattern = std::regex(sedbuf.regex);
else
pattern = std::regex(sedbuf.regex, std::regex::icase);
} catch (std::regex_error) {
snprintf(s, max, "sed: invalid regex");
return 0;
}
if (!sedbuf.global)
type |= std::regex_constants::format_first_only;
snprintf(s, max, "%s", std::regex_replace(input, pattern,
sedbuf.replace, type).c_str());
return 1;
}
void reterr(char *fmt,...)
{
va_list args;
va_start(args, fmt);
vsprintf(errmsg, fmt, args);
va_end(args);
puts(errmsg);
puterr();
}
int main(int argc, char** argv)
{
int narg;
int nPhases;
/* set program name */
strcpy(prog_name, PNAME);
/* check command line for correct usage */
fprintf(stdout, "%s Arguments: ", prog_name);
for (narg = 0; narg < argc; narg++)
fprintf(stdout, "<%s> ", argv[narg]);
fprintf(stdout, "\n");
if (argc < 5) {
puterr("ERROR wrong number of command line arguments.");
disp_usage(PNAME,
"<nll_hyp_target> <nll_hyp_phs_source> <nll_hyp_out> dist_max_fract");
exit(0);
}
SetConstants();
message_flag = 1;
DispProgInfo();
message_flag = 0;
if ((nPhases = doFindEquivPhases(argc, argv)) < 0) {
puterr("ERROR doing Phase Equivalence process.");
exit(0);
}
exit(nPhases);
}
int main(int argc, char** argv)
{
int istat, narg;
/* set program name */
strcpy(prog_name, PNAME);
/* check command line for correct usage */
fprintf(stdout, "%s Arguments: ", prog_name);
for (narg = 0; narg < argc; narg++)
fprintf(stdout, "<%s> ", argv[narg]);
fprintf(stdout, "\n");
if (argc < 5) {
puterr("ERROR wrong number of command line arguments.");
disp_usage(PNAME,
"hypfile1 hypfile2 time_tolerance nobs_tolerance");
exit(-1);
}
SetConstants();
message_flag = 1;
DispProgInfo();
message_flag = 0;
if ((istat = DiffHypocenters(argc, argv)) < 0) {
puterr("ERROR doing difference process.");
exit(-1);
}
exit(0);
}
int Rotate90CW(int argc, char *argv[])
{
int istat, narg;
char fn_grid_in[FILENAME_MAX];
char fn_grid_out[FILENAME_MAX];
FILE *fp_grid_in;
FILE *fp_grid_in_hdr;
GridDesc grid_in, grid_out;
int ix, iy, iz;
float val;
// open input grid file
strcpy(fn_grid_in, argv[2]);
if ((istat = OpenGrid3dFile(fn_grid_in, &fp_grid_in, &fp_grid_in_hdr,
&grid_in, "", NULL)) < 0)
{
puterr("ERROR opening input grid file.");
return(-1);
}
// cread and initialize output grid
// output file name
strcpy(fn_grid_out, argv[3]);
// create output grid description
grid_out = grid_in;
grid_out.numx = grid_in.numy;
grid_out.numy = grid_in.numx;
// allocate grid
grid_out.buffer = AllocateGrid(&grid_out);
if (grid_out.buffer == NULL) {
puterr("ERROR: allocating memory for output grid buffer.\n");
return(-1);
}
// create grid array access pointers
grid_out.array = CreateGridArray(&grid_out);
if (grid_out.array == NULL) {
puterr("ERROR: creating array for accessing output grid buffer.\n");
return(-1);
}
// rotate input grid file into output grid
for (ix = 0; ix < grid_in.numx; ix++) {
printf("ix = %d/%d\r", ix, grid_in.numx);
for (iy = 0; iy < grid_in.numy; iy++) {
for (iz = 0; iz < grid_in.numz; iz++) {
val = ReadGrid3dValue(fp_grid_in, ix, iy, iz, &grid_in);
grid_out.array[iy][grid_out.numy - ix - 1][iz] = val;
}
}
}
printf("\n");
// save sum grid to disk
if ((istat = WriteGrid3dBuf(&grid_out, NULL, fn_grid_out, "rot90CW")) < 0) {
puterr("ERROR: writing rotated grid to disk.\n");
return(-1);
}
close(fp_grid_in);
close(fp_grid_in_hdr);
return(0);
}
main(int argc, char *argv[])
{
int istat, narg;
char fngrid_control[MAXLINE], fn_input[MAXLINE], fn_outroot[MAXLINE];
FILE *fp_grid_control, *fp_outroot, *fp_gmt;
char filename[MAXLINE], fn_xy_out[MAXLINE];
// set program name
strcpy(prog_name, PNAME);
// check command line for correct usage
fprintf(stdout, "\n%s Arguments: ", prog_name);
for (narg = 0; narg < argc; narg++)
fprintf(stdout, "<%s> ", argv[narg]);
fprintf(stdout, "\n");
if (argc != 4)
{
puterr("ERROR wrong number of command line arguments.");
disp_usage(PNAME,
"<controlfile> <punfile> <outroot>");
exit(-1);
}
// read command line arguments
strcpy(fngrid_control, argv[1]);
strcpy(fn_input, argv[2]);
strcpy(fn_outroot, argv[3]);
// set constants
SetConstants();
// read control file
if ((fp_grid_control = fopen(fngrid_control, "r")) == NULL) {
puterr("ERROR opening control file.");
exit(EXIT_ERROR_FILEIO);
}
if ((istat = ReadPun2GMT_Input(fp_grid_control)) < 0) {
puterr("ERROR reading control file.");
exit(EXIT_ERROR_FILEIO);
}
// open GMT command file
sprintf(filename, "%s.gmt", fn_outroot);
if ((fp_gmt = fopen(filename, "w")) == NULL) {
puterr("ERROR opening output GMT script file.");
exit(EXIT_ERROR_FILEIO);
}
// convert .pun to xy
ConvertPun2GMT(fn_input, "XZ", fn_outroot, fn_xy_out);
fprintf(fp_gmt,
"psxy %s $JVAL $RVAL -W1/0/0/0 -M -K -O >> %s.ps\n\n",
fn_xy_out, "${POSTSCRIPT_NAME}");
ConvertPun2GMT(fn_input, "XY", fn_outroot, fn_xy_out);
fprintf(fp_gmt,
"psxy %s $JVAL $RVAL -W1/0/0/0 -M -K -O >> %s.ps\n\n",
fn_xy_out, "${POSTSCRIPT_NAME}");
ConvertPun2GMT(fn_input, "ZY", fn_outroot, fn_xy_out);
fprintf(fp_gmt,
"psxy %s $JVAL $RVAL -W1/0/0/0 -M -K -O >> %s.ps\n\n",
fn_xy_out, "${POSTSCRIPT_NAME}");
exit(0);
}
int ReadPun2GMT_Input(FILE* fp_input)
{
int istat, iscan;
char param[MAXLINE];
char line[MAXLINE];
int flag_control = 0, flag_trans = 0;
// read each input line
while (fgets(line, MAXLINE, fp_input) != NULL) {
istat = -1;
//read parameter line
if ((iscan = sscanf(line, "%s", param)) < 0 )
continue;
// skip comment line or white space
if (strncmp(param, "#", 1) == 0 || isspace(param[0]))
istat = 0;
// read control params
if (strncmp(param, "CONTROL", 6) == 0)
if ((istat = get_control(strchr(line, ' '))) < 0)
puterr("Error reading control params.");
else
flag_control = 1;
//read transform params
if (strncmp(param, "TRANS", 5) == 0)
if ((istat = get_transform(strchr(line, ' '))) < 0)
puterr("ERROR reading transformation parameters.");
else
flag_trans = 1;
// unrecognized input
if (istat < 0 && message_flag > 1) {
fprintf(stdout, "Skipping input: %s", line);
}
}
// check for missing input
if (!flag_control)
puterr("ERROR no control (CONTROL) params read.");
if (!flag_trans)
puterr("ERROR no transformation (TRANS) params read.");
return (flag_control + flag_trans - 1);
}
int ConvertPun2GMT(char* fn_input, char* orientation, char* fn_outroot,
char* fn_xy_out)
{
int istat;
FILE *fp_input, *fp_xy_out, *fp_lonlat_out;
char line_in[2*MAXLINE], fn_lonlat_out[MAXLINE];
int or_xy, or_xz, or_yz, or_zy;
double vlat, vlong, dlat, dlong, vdepth;
int ilat, ilong;
double xgrid, ygrid;
double errx, erry, errz;
double barlen = 0.75;
if ((fp_input = fopen(fn_input, "r")) == NULL) {
fprintf(stderr, "ERROR: Cannot open .pun file <%s>.\n",
fn_input);
return(-1);
}
sprintf(fn_xy_out, "%s.%s", fn_outroot, orientation);
if ((fp_xy_out = fopen(fn_xy_out, "w")) == NULL) {
fprintf(stderr,
"ERROR: Cannot open xy output file <%s>.\n",
fn_xy_out);
return(-1);
}
sprintf(fn_lonlat_out, "%s.lonlat.%s", fn_outroot, orientation);
if ((fp_lonlat_out = fopen(fn_lonlat_out, "w")) == NULL) {
fprintf(stderr,
"ERROR: Cannot open lonlat output file <%s>.\n",
fn_lonlat_out);
return(-1);
}
or_xy = or_xz = or_yz = or_zy = 0;
if (strcmp(orientation, "XY") == 0)
or_xy = 1;
else if (strcmp(orientation, "XZ") == 0)
or_xz = 1;
else if (strcmp(orientation, "YZ") == 0)
or_yz = 1;
else if (strcmp(orientation, "ZY") == 0)
or_zy = 1;
// skip header line
if (fgets(line_in, 2*MAXLINE, fp_input) == NULL)
puterr("ERROR: reading header line in .pun file");
// convert each hypocenter
fprintf(fp_xy_out, ">\n");
fprintf(fp_lonlat_out, ">\n");
while(fgets(line_in, 2*MAXLINE, fp_input) != NULL) {
dlat = dlong = vdepth = errx = erry = errz = 2.0e2;
ilat = ilong = 0;
if ((istat = sscanf(line_in,
"%*d %*d %*f %d-%lf %d-%lf %lf %*d %*d %*f %*f %*f %*f %*s %lf %lf %lf",
&ilat, &dlat, &ilong, &dlong, &vdepth,
&errx, &erry, &errz)) != 8) {
puterr("WARNING: Error reading line in .pun file:");
puterr(line_in);
}
vlat = (double) ilat + dlat / 60.0;
vlong = ilong + dlong / 60.0;
latlon2rect(vlat, vlong, &xgrid, &ygrid);
if (or_xy) {
Err2GMT(fp_xy_out, xgrid, ygrid,
errx, barlen, erry, barlen);
Err2GMT(fp_lonlat_out, vlong, vlat,
errx / (c111 * cos(rpd * vlat)),
barlen / (c111 * cos(rpd * vlat)),
erry / c111, barlen / c111);
} else if (or_xz) {
Err2GMT(fp_xy_out, xgrid, vdepth,
errx, barlen, errz, barlen);
Err2GMT(fp_lonlat_out, vlong, vdepth,
errx / (c111 * cos(rpd * vlat)),
barlen / (c111 * cos(rpd * vlat)),
errz, barlen);
} else if (or_yz) {
Err2GMT(fp_xy_out, ygrid, vdepth,
erry, barlen, errz, barlen);
Err2GMT(fp_lonlat_out, vlat, vdepth,
erry / c111, barlen / c111, errz, barlen);
} else if (or_zy) {
Err2GMT(fp_xy_out, vdepth, ygrid,
errz, barlen, erry, barlen);
Err2GMT(fp_lonlat_out, vdepth, vlat,
errz, barlen, erry / c111, barlen / c111);
}
}
fclose(fp_input);
fclose(fp_xy_out);
fclose(fp_lonlat_out);
return(0);
}
int read_mdm( int nchars, int timeout, uchar *buf ) {
int n, i, ungot = 0;
#ifdef DIAG
fprintf(stderr,"read_mdm(%d, %d, buffer)\r\n",nchars, timeout);
#endif
if ( ungot_char != 0xffff ) { /* Process unget buffer first */
--nchars;
*buf++ = (uchar) ungot_char;
ungot_char = 0xffff;
ungot = 1;
}
if ( timeout == -1 ) timeout = 0;
n = 0;
#ifndef __QNXNTO__
if ( !socket ) {
while ( nchars && ( i = dev_read( mdm, buf, nchars, nchars, 0, timeout, 0, 0 ) ) ) {
if ( i == -1 ) puterr( "read_mdm(): %s\n", strerror(errno) );
buf += i; nchars -= i; n += i;
}
}
else
#endif
{
int s=0;
struct timeval tv;
fd_set rfd;
FD_ZERO( &rfd );
FD_SET( mdm, &rfd );
memset(&tv,0,sizeof(tv));
tv.tv_sec = timeout / onesec;
#ifdef DIAG
fprintf(stderr,"select tv.tv_src = %d\r\n",tv.tv_sec);
#endif
while( nchars && (s = select( 1 + mdm, &rfd, 0, 0, &tv )) == 1 ) {
#ifdef DIAG
fprintf(stderr,"select returned - chars waiting. Set timeout for %d seconds\r\n",timeout/onesec);
#endif
alarm( timeout / onesec );
#ifdef DIAG
fprintf(stderr,"reading...\r\n");
#endif
while ( nchars && ( i = read( mdm, buf, nchars ) ) ) {
if ( i == -1 ) {
if( errno == EINTR ) {
#ifdef DIAG
fprintf(stderr,"read_mdm(): alarm timeout\n");
#endif
goto timeout;
}
if( errno != EAGAIN )
puterr( "read_mdm(): %s\n", strerror(errno) );
break;
}
else {
#ifdef DIAG
fprintf(stderr,"read_mdm got %d chars [0x%02x 0x%02x 0x%02x...]\r\n",i,buf[0],buf[1],buf[2]);
#endif
buf += i; nchars -= i; n += i;
}
}
alarm( 0 );
}
timeout:
if ( s == -1 ) puterr( "read_mdm() / select(): %s\n", strerror(errno));
}
#ifdef DIAG
fprintf(stderr,"read_mdm returning %d(+%d ungot) chars\r\n",n,ungot);
#endif
return( n + ungot );
}
int exec_cmd(int under_glob, int under_until)
{
register int status;
register char *p;
int n;
if((status = getrange()) <= ERROR)
return( status );
status = ERROR9;
switch( *lp++ ) {
case 'i':
laddr2 = prevln(laddr2);
case 'a':
status = append(laddr2, under_glob);
break;
case 'b':
if(!under_glob && !under_until)
status = branch();
break;
case 'c':
if((status = delete(laddr1, laddr2, SAVE)) == OK)
status = append(prevln(laddr1), under_glob);
break;
case 'd':
if((status = delete(laddr1, laddr2, SAVE)) == OK && nextln(curln) != 0)
curln = nextln(curln);
break;
case 'e':
if(lastln && dirty && *lp != 'e') {
status = ERROR4;
break;
}
if(*lp == 'e')
++lp;
if(nladdrs == 0 && !under_glob && !under_until &&
(status = getfn()) == OK) {
set_fn(curfile, lp);
if(lastln != 0)
delete(1, lastln, NOSAVE);
num_delete_lines = 0;
if((status = _read( lp, 0, 0)) == OK) {
dirty = 0;
if(lastln)
curln = 1;
}
}
lp = "\n";
break;
case 'f':
if(nladdrs == 0 && (status = getfn()) == OK) {
set_fn(curfile, lp);
putmsg(curfile);
lp = "\n";
}
change_state(CMD);
break;
case 'g':
if(!under_glob) {
if(*lp == '^') {
++lp;
n = 0;
}
else
n = 1;
status = exec_glob(n, under_until);
}
break;
case 'h':
n = getint();
#ifndef __STDC__
while(n--)
for(n1 = 0; n1 < 10; ++n1)
time_slice();
#endif
status = OK;
break;
case 'j':
status = join(laddr2);
break;
case 'k':
if((status = get_laddr_expr(&n)) == OK)
status = kopy(n);
break;
case 'l':
if(nladdrs == 0)
status = learn();
break;
case 'm':
if((status = get_laddr_expr(&n)) == OK)
status = move(n);
break;
case 'o':
status = option();
break;
case 'p':
case 'P':
status = prnt(laddr1, laddr2);
break;
case 'q':
if(nladdrs==0 && !under_glob) {
if((*lp=='\n' && !dirty) || *lp=='q' || lastln == 0)
status = EOF;
else
status = ERROR4;
}
break;
case 'r':
if(!under_glob && !under_until && (status = getfn()) == OK)
status = _read(lp, laddr2, 0);
lp = "\n";
break;
case 's':
n = getint(); /* read occurance if present */
if((status=getpat()) == OK && (status=getsubst_str(tbuff)) == OK)
status = substitute(tbuff, under_glob, n);
break;
case 't':
case 'T':
if(nladdrs == 0)
status = translate(*(lp - 1) == 't');
break;
case 'u':
status = until(laddr1, laddr2, under_glob);
break;
case 'v':
if(nladdrs <= 1)
status = view(laddr1);
break;
case 'w':
n = 0;
if(*lp == 'w') {
n |= 2;
++lp;
}
if(*lp == 'a') {
n |= 1;
++lp;
}
if((status = getfn()) == OK) {
if(nladdrs == 0) {
if(curfile[0] == '\0')
set_fn(curfile, lp);
else {
if((n & 2) == 0 && strcmp(curfile, lp) != 0) {
for(p = lp ; *p ; ++p)
if(*p == '$')
goto ok;
puterr(-19);
lp = "\n";
break;
}
}
ok:
if((status = _write(lp, 1, lastln, n & 1, 0)) == OK)
dirty = 0;
}
} else {
status = _write(lp, laddr1, laddr2, n & 1, 0);
}
lp = "\n";
break;
case 'x':
if(!under_glob && !under_until && (status = getfn()) == OK)
if(nladdrs == 0)
status = exec_file(lp, under_glob, under_until);
lp = "\n";
break;
case 'y':
status = yut();
break;
case 'z':
status = zap();
break;
case '\n':
--lp; /* put back newline for main */
if(laddr2 < 0 || laddr2 > lastln)
status = lastln ? ERROR5 : OK;
else {
curln = laddr2;
status = OK;
}
break;
case ' ':
case '\t':
case CMD_CHAR:
status = OK;
break;
case '=':
dtoc(rbuff, laddr2);
if(under_glob)
prnt_screen(rbuff, 1);
else
putmsg(rbuff);
status = OK;
break;
case '"':
lp = "\n"; /* Ignore rest of line */
status = OK;
break;
case '!':
if(escape_char == 0 || restrict_flag) {
putmsg("Escape from ED inhibited");
status = NOTHING;
}
else
status = exec_sys_cmd(under_glob, under_until);
break;
default:
status = ERROR2;
}
return(status);
}
