virtual ~request_handlers()
{
std::for_each(
boost::make_transform_iterator(request_handlers_.begin(), get_spec()),
boost::make_transform_iterator(request_handlers_.end(), get_spec()),
std::default_delete<request_spec>());
std::for_each(
boost::make_transform_iterator(request_handlers_.begin(), get_handler()),
boost::make_transform_iterator(request_handlers_.end(), get_handler()),
std::default_delete<request_handler>());
}
request_handler *find(std::string const &request)
{
auto end(boost::make_transform_iterator(request_handlers_.end(), get_spec()));
auto found_spec(
std::find_if(
boost::make_transform_iterator(request_handlers_.begin(), get_spec()),
end,
spec_conformed(request)));
if (found_spec == end) return 0;
auto found_pair(found_spec.base());
return found_pair->second;
}
void
options_c::merge_targets() {
std::map<uint64_t, track_target_c *> targets_by_track_uid;
std::vector<target_cptr> targets_to_keep;
for (auto &target : m_targets) {
auto track_target = dynamic_cast<track_target_c *>(target.get());
if (!track_target || dynamic_cast<segment_info_target_c *>(target.get())) {
targets_to_keep.push_back(target);
continue;
}
auto existing_target_it = targets_by_track_uid.find(track_target->get_track_uid());
auto track_uid = target->get_track_uid();
if (targets_by_track_uid.end() == existing_target_it) {
targets_to_keep.push_back(target);
targets_by_track_uid[track_uid] = track_target;
continue;
}
existing_target_it->second->merge_changes(*track_target);
mxwarn(boost::format(Y("The edit specifications '%1%' and '%2%' resolve to the same track with the UID %3%.\n"))
% existing_target_it->second->get_spec() % track_target->get_spec() % track_uid);
}
m_targets.swap(targets_to_keep);
}
t_color get_ambiant_light(t_scene scene, t_vector ray,
t_obj object, t_point inter)
{
t_llst *tmp;
t_point light_inter;
double norm;
tmp = scene.lst_light;
scene.color = new_color(0, 0, 0);
while (tmp)
{
light_inter = new_point(inter.x - tmp->light->body.center.x, inter.y -
tmp->light->body.center.y, inter.z - tmp->light->body.center.z);
norm = sqrt(pow(light_inter.x, 2) + pow(light_inter.y, 2) +
pow(light_inter.z, 2));
scene.normal = object.normal(object, inter, ray);
light_inter = new_point((double)light_inter.x / norm,
light_inter.y / norm, light_inter.z / norm);
scene.scal = scalar_prod(light_inter, scene.normal);
scene.ray = ray.dir;
if (norm_is_shit(scene, *(tmp->light), inter, norm) &&
scene.scal >= 0.000000000000000000001)
scene.color = calc_color(get_spec(scene, *(tmp->light),
light_inter, object), object.texturing(object, inter, ray),
*(tmp->light), scene.scal);
tmp = tmp->next;
}
return (scene.color);
}
MonoTraceSpec *
mono_trace_parse_options (const char *options)
{
char *p = (char*)options;
int size = 1;
int last_used;
int token;
trace_spec.enabled = TRUE;
if (*p == 0){
trace_spec.len = 1;
trace_spec.ops = g_new0 (MonoTraceOperation, 1);
trace_spec.ops [0].op = MONO_TRACEOP_ALL;
return &trace_spec;
}
for (p = (char*)options; *p != 0; p++)
if (*p == ',')
size++;
trace_spec.ops = g_new0 (MonoTraceOperation, size);
input = (char*)options;
last_used = 0;
while ((token = (get_spec (&last_used))) != TOKEN_END){
if (token == TOKEN_ERROR)
return NULL;
if (token == TOKEN_SEPARATOR)
continue;
}
trace_spec.len = last_used;
cleanup ();
return &trace_spec;
}
static int
get_spec (int *last)
{
int token = get_token ();
if (token == TOKEN_EXCLUDE){
token = get_spec (last);
if (token == TOKEN_EXCLUDE){
fprintf (stderr, "Expecting an expression");
return TOKEN_ERROR;
}
if (token == TOKEN_ERROR)
return token;
trace_spec.ops [(*last)-1].exclude = 1;
return TOKEN_SEPARATOR;
}
if (token == TOKEN_END || token == TOKEN_SEPARATOR || token == TOKEN_ERROR)
return token;
if (token == TOKEN_METHOD){
MonoMethodDesc *desc = mono_method_desc_new (value, TRUE);
if (desc == NULL){
fprintf (stderr, "Invalid method name: %s\n", value);
return TOKEN_ERROR;
}
trace_spec.ops [*last].op = MONO_TRACEOP_METHOD;
trace_spec.ops [*last].data = desc;
} else if (token == TOKEN_ALL)
trace_spec.ops [*last].op = MONO_TRACEOP_ALL;
else if (token == TOKEN_PROGRAM)
trace_spec.ops [*last].op = MONO_TRACEOP_PROGRAM;
else if (token == TOKEN_WRAPPER)
trace_spec.ops [*last].op = MONO_TRACEOP_WRAPPER;
else if (token == TOKEN_NAMESPACE){
trace_spec.ops [*last].op = MONO_TRACEOP_NAMESPACE;
trace_spec.ops [*last].data = g_strdup (value);
} else if (token == TOKEN_CLASS || token == TOKEN_EXCEPTION){
char *p = strrchr (value, '.');
if (p) {
*p++ = 0;
trace_spec.ops [*last].data = g_strdup (value);
trace_spec.ops [*last].data2 = g_strdup (p);
}
else {
trace_spec.ops [*last].data = g_strdup ("");
trace_spec.ops [*last].data2 = g_strdup (value);
}
trace_spec.ops [*last].op = token == TOKEN_CLASS ? MONO_TRACEOP_CLASS : MONO_TRACEOP_EXCEPTION;
} else if (token == TOKEN_STRING){
trace_spec.ops [*last].op = MONO_TRACEOP_ASSEMBLY;
trace_spec.ops [*last].data = g_strdup (value);
} else if (token == TOKEN_DISABLED) {
trace_spec.enabled = FALSE;
} else {
fprintf (stderr, "Syntax error in trace option specification\n");
return TOKEN_ERROR;
}
(*last)++;
return TOKEN_SEPARATOR;
}
void de_get_extra_cgrps(WRootWin *rootwin, DEStyle *style, ExtlTab tab)
{
uint i=0, nfailed=0, n=extl_table_get_n(tab);
char *name;
ExtlTab sub;
if(n==0)
return;
style->extra_cgrps=ALLOC_N(DEColourGroup, n);
if(style->extra_cgrps==NULL)
return;
for(i=0; i<n-nfailed; i++){
GrStyleSpec spec;
if(!extl_table_geti_t(tab, i+1, &sub))
goto err;
if(!get_spec(sub, "substyle_pattern", &spec, NULL)){
extl_unref_table(sub);
goto err;
}
style->extra_cgrps[i-nfailed].spec=spec;
de_get_colour_group(rootwin, style->extra_cgrps+i-nfailed, sub,
style);
extl_unref_table(sub);
continue;
err:
warn(TR("Corrupt substyle table %d."), i);
nfailed++;
}
if(n-nfailed==0){
free(style->extra_cgrps);
style->extra_cgrps=NULL;
}
style->n_extra_cgrps=n-nfailed;
}
void help_scr_control(void){
char c;
if ((c = get_spec()) != 0){
switch(c){
case 5:
scr_ch(prev_scr);
break;
/// @todo Rozhodnout o implementaci tlačítka START
case 21: // F11 - Strorno měření
kf_zrusit();
break;
case 22: //F12
// Odeslání dat.
send_data();
break;
default:
break;
}
}
}
void
change_c::execute_add_or_set() {
size_t idx;
unsigned int num_found = 0;
for (idx = 0; m_master->ListSize() > idx; ++idx) {
if (m_property.m_callbacks->GlobalId != (*m_master)[idx]->Generic().GlobalId)
continue;
if (change_c::ct_set == m_type)
set_element_at(idx);
++num_found;
}
if (0 == num_found) {
do_add_element();
if (1 < verbose)
mxinfo(boost::format(Y("Change for '%1%' executed. No property of this type found. One entry added.\n")) % get_spec());
return;
}
if (change_c::ct_set == m_type) {
if (1 < verbose)
mxinfo(boost::format(Y("Change for '%1%' executed. Number of entries set: %2%.\n")) % get_spec() % num_found);
return;
}
const EbmlSemantic *semantic = get_semantic();
if (semantic && semantic->Unique)
mxerror(boost::format(Y("This property is unique. More instances cannot be added in '%1%'. %2%\n")) % get_spec() % FILE_NOT_MODIFIED);
do_add_element();
if (1 < verbose)
mxinfo(boost::format(Y("Change for '%1%' executed. One entry added.\n")) % get_spec());
}
void super_blit(SuperBlitable *superb, SDL_Surface *dest,
int x, int y, int angle)
{
SDL_Surface *s_final;
Uint32 curr_spec = get_spec();
if ((superb->last_spec != curr_spec) || \
(superb->curr_flag != SB_CF_NORMAL)) {
SDL_Surface *s_n_spec;
Uint8 sr, sg, sb;
SDL_GetRGB(curr_spec, get_spec_fmt(), &sr, &sg, &sb);
SDL_FreeSurface(superb->curr);
superb->curr = SDL_DisplayFormatAlpha(superb->orig);
s_n_spec =
SDL_ConvertSurface(superb->spec, superb->spec->format, 0);
change_style(s_n_spec, SDL_MapRGB(s_n_spec->format, sr, sg, sb));
change_spec(superb->curr, s_n_spec);
set_alpha_channel(superb->curr, superb->alph);
SDL_FreeSurface(s_n_spec);
superb->curr_flag = SB_CF_NORMAL;
}
s_final = rotozoomSurface(superb->curr, angle, 1, 0);
center_blit(s_final, dest, x, y);
SDL_FreeSurface(s_final);
}
void
change_c::parse_date_time() {
// 1 2 3 4 5 6 7 8 9 10
boost::regex re{"^ (\\d{4}) - (\\d{2}) - (\\d{2}) (?: T | \\h) (\\d{2}) : (\\d{2}) : (\\d{2}) \\h* ( Z | ([+-]) (\\d{2}) : (\\d{2}) ) $", boost::regex::perl | boost::regex::mod_x};
boost::smatch matches;
int64_t year, month, day, hours, minutes, seconds;
int64_t offset_hours = 0, offset_minutes = 0, offset_mult = 1;
auto valid = boost::regex_match(m_value, matches, re);
if (valid)
valid = parse_number(matches[1].str(), year)
&& parse_number(matches[2].str(), month)
&& parse_number(matches[3].str(), day)
&& parse_number(matches[4].str(), hours)
&& parse_number(matches[5].str(), minutes)
&& parse_number(matches[6].str(), seconds);
if (valid && (matches[7].str() != "Z")) {
valid = parse_number(matches[9].str(), offset_hours)
&& parse_number(matches[10].str(), offset_minutes);
if (matches[8].str() == "-")
offset_mult = -1;
}
valid = valid
&& (year >= 1900)
&& (month >= 1)
&& (month <= 12)
&& (day >= 1)
&& (day <= 31)
&& (hours >= 0)
&& (hours <= 23)
&& (minutes >= 0)
&& (minutes <= 59)
&& (offset_hours >= 0)
&& (offset_hours <= 23)
&& (offset_minutes >= 0)
&& (offset_minutes <= 59);
if (valid) {
try {
auto date_time = boost::posix_time::ptime{ boost::gregorian::date(year, month, day), boost::posix_time::time_duration(hours, minutes, seconds) };
if (!date_time.is_not_a_date_time()) {
auto tz_offset = (offset_hours * 60 + offset_minutes) * offset_mult;
date_time -= boost::posix_time::minutes(tz_offset);
}
if (!date_time.is_not_a_date_time())
m_ui_value = mtx::date_time::to_time_t(date_time);
return;
} catch (std::out_of_range &) {
}
}
mxerror(boost::format("%1% %2% %3% %4%\n")
% (boost::format(Y("The property value is not a valid date & time string in '%1%'.")) % get_spec()).str()
% Y("The recognized format is 'YYYY-mm-ddTHH:MM:SS+zz:zz': the year, month, day, letter 'T', hours, minutes, seconds and the time zone's offset from UTC; example: 2017-03-28T17:28-02:00.")
% Y("The letter 'Z' can be used instead of the time zone's offset from UTC to indicate UTC aka Zulu time.")
% FILE_NOT_MODIFIED);
}
void gvcst_root_search(void)
{
srch_blk_status *h0;
uchar_ptr_t c, c1;
sm_uc_ptr_t rp;
unsigned short rlen, hdr_len;
uchar_ptr_t subrec_ptr;
enum cdb_sc status;
boolean_t gbl_target_was_set;
gv_namehead *save_targ;
mname_entry *gvent;
int altkeylen;
assert((dba_bg == gv_cur_region->dyn.addr->acc_meth) || (dba_mm == gv_cur_region->dyn.addr->acc_meth));
assert(gv_altkey->top == gv_currkey->top);
assert(gv_altkey->top == gv_keysize);
assert(gv_currkey->end < gv_currkey->top);
for (c = gv_altkey->base, c1 = gv_currkey->base; *c1;)
*c++ = *c1++;
*c++ = 0;
*c = 0;
gv_altkey->end = c - gv_altkey->base;
assert(gv_altkey->end < gv_altkey->top);
assert(gv_target != cs_addrs->dir_tree);
save_targ = gv_target;
/* Check if "gv_target->gvname" matches "gv_altkey->base". If not, there is a name mismatch (out-of-design situation).
* This check is temporary until we catch the situation that caused D9H02-002641 */
/* --- Check BEGIN --- */
gvent = &save_targ->gvname;
altkeylen = gv_altkey->end - 1;
if (!altkeylen || (altkeylen != gvent->var_name.len) || memcmp(gv_altkey->base, gvent->var_name.addr, gvent->var_name.len))
GTMASSERT;
/* --- Check END --- */
if (INVALID_GV_TARGET != reset_gv_target)
gbl_target_was_set = TRUE;
else
{
gbl_target_was_set = FALSE;
reset_gv_target = save_targ;
}
gv_target = cs_addrs->dir_tree;
if (is_standalone) /* *&& (0 != gv_target->clue.end) && (FALSE == is_valid_hist(&gv_target->hist))) */
gv_target->clue.end = 0;
T_BEGIN_READ_NONTP_OR_TP(ERR_GVGETFAIL);
assert(t_tries < CDB_STAGNATE || cs_addrs->now_crit); /* we better hold crit in the final retry (TP & non-TP) */
for (;;)
{
hdr_len = rlen = 0;
gv_target = cs_addrs->dir_tree;
if (dollar_trestart)
gv_target->clue.end = 0;
if (cdb_sc_normal == (status = gvcst_search(gv_altkey, 0)))
{
if (gv_altkey->end + 1 == gv_target->hist.h[0].curr_rec.match)
{
h0 = gv_target->hist.h;
rp = (h0->buffaddr + h0->curr_rec.offset);
hdr_len = sizeof(rec_hdr) + gv_altkey->end + 1 - ((rec_hdr_ptr_t)rp)->cmpc;
GET_USHORT(rlen, rp);
if (FALSE == (CHKRECLEN(rp, h0->buffaddr, rlen)) || (rlen < hdr_len + sizeof(block_id)))
{
gv_target->clue.end = 0;
RESET_GV_TARGET_LCL(save_targ);
t_retry(cdb_sc_rmisalign);
continue;
}
GET_LONG(save_targ->root, (rp + hdr_len));
if (rlen > hdr_len + sizeof(block_id))
{
assert(NULL != global_collation_mstr.addr || 0 == global_collation_mstr.len);
if (global_collation_mstr.len < rlen - (hdr_len + sizeof(block_id)))
{
if (NULL != global_collation_mstr.addr)
free(global_collation_mstr.addr);
global_collation_mstr.len = rlen - (hdr_len + SIZEOF(block_id));
global_collation_mstr.addr = (char *)malloc(global_collation_mstr.len);
}
/* the memcpy needs to be done here instead of out of for loop for
* concurrency consideration. We don't use s2pool because the pointer rp is 64 bits
*/
memcpy(global_collation_mstr.addr, rp + hdr_len + sizeof(block_id),
rlen - (hdr_len + sizeof(block_id)));
}
if (0 != dollar_tlevel)
{
status = tp_hist(NULL);
if (cdb_sc_normal != status)
{
gv_target->clue.end = 0;
RESET_GV_TARGET_LCL(save_targ);
gv_target->root = 0;
t_retry(status);
continue;
}
break;
}
}
if (0 == dollar_tlevel)
{
if ((trans_num)0 != t_end(&gv_target->hist, 0))
break;
} else
{
status = tp_hist(NULL);
if (cdb_sc_normal == status)
break;
gv_target->clue.end = 0;
RESET_GV_TARGET_LCL(save_targ);
gv_target->root = 0;
t_retry(status);
continue;
}
save_targ->root = 0;
} else
{
gv_target->clue.end = 0;
RESET_GV_TARGET_LCL(save_targ);
t_retry(status);
continue;
}
}
RESET_GV_TARGET_LCL_AND_CLR_GBL(save_targ);
if (rlen > hdr_len + sizeof(block_id))
{
assert(NULL != global_collation_mstr.addr);
subrec_ptr = get_spec((uchar_ptr_t)global_collation_mstr.addr,
(int)(rlen - (hdr_len + sizeof(block_id))), COLL_SPEC);
if (subrec_ptr)
{
gv_target->nct = *(subrec_ptr + COLL_NCT_OFFSET);
gv_target->act = *(subrec_ptr + COLL_ACT_OFFSET);
gv_target->ver = *(subrec_ptr + COLL_VER_OFFSET);
} else
{
gv_target->nct = 0;
gv_target->act = 0;
gv_target->ver = 0;
}
} else
{
gv_target->nct = 0;
gv_target->act = cs_addrs->hdr->def_coll;
gv_target->ver = cs_addrs->hdr->def_coll_ver;
}
if (gv_target->act)
act_in_gvt();
assert(gv_target->act || NULL == gv_target->collseq);
return;
}
void
change_c::parse_signed_integer() {
if (!parse_number(m_value, m_si_value))
mxerror(boost::format(Y("The property value is not a valid signed integer in '%1%'. %2%\n")) % get_spec() % FILE_NOT_MODIFIED);
}
main()
{
static char text[MAXSEARCH]; /* Pointer to buffer for search text */
static char date_time[19]; /* Receive file date and time */
int err, mode, handle, len; /* Codes, file handle, bytes read */
int row, col, ch; /* Cursor coordinates, kb character */
int i, j, attr; /* Index variables, file attribute */
int disp_attr; /* Display attribute */
char *spec, *ptr, *buffer; /* File spec, char match, read buffer */
long dsize, disk_use; /* Disk size and usage */
struct DISKSTAT disk; /* Structure for disk size params */
static char copy_msg[] =
{
"Files can be copied or moved in 2 different modes:\n" \
" 0 - overwrite target file if it exists\n" \
" 1 - abort if target file exists\n\n" \
"Mode 1 is supported only with DOS versions 3.0 or higher.\n"
};
static char move_msg[] =
{
"Quick Move uses DOS function 56h (Rename File) to effectively " \
"move a file from\none directory to another directory on the " \
"same drive. It copies the entry\nfrom the source directory to " \
"the target directory, but does not physically\ncopy the file.\n\n" \
"Source and target specifications must be given in full, " \
"including filenames,\neven if the names are the same."
};
static char grep_msg[] =
{
"The Find Text option uses the StrFindChar and StrCompare procedures " \
"to locate\na text string within specified files, like Unix's " \
"\"grep\" command. Find Text\nis limited to case-sensitive searches " \
"within the current directory.\n\nEnter the desired search string " \
"without quotation marks. When specifying the\nfilename, use " \
"wildcard characters to expand the search to a group of files --\n" \
"for example, \"*.*\" searches all files within the current " \
"directory, \"*.bat\"\nlimits the search to batch files, and so forth."
};
static char attr_msg[] =
{
"\t\t\t1 normal \n" \
"\t\t\t2 read-only \n" \
"\t\t\t3 hidden \n" \
"\t\t\t4 system \n" \
"\t\t\t volume \n" \
"\t\t\t subdirectory\n" \
"\t\t\t5 archive \n"
};
GetVidConfig();
ReadCharAttr( &disp_attr );
clear_scrn( disp_attr, 0, 24 );
SetCurPos( 8, 0 );
puts( "Welcome to the FILEDEMO program.\n\n\nThis program is meant " \
"to encourage experimentation while demonstrating how to\naccess " \
"DOS from assembly-language procedures. As a safety precaution, " \
"however,\nwe suggest you DO NOT experiment with files that " \
"cannot easily be replaced." );
press();
do
{
/* Display current drive and directory */
clear_scrn( disp_attr, 0, 24 );
SetCurPos( 0, 0 );
printf( "Current Directory: %c:\\", (char)(GetCurDrive() + 'A') );
GetCurDir( source );
puts( source );
/* Display DOS version */
SetCurPos( 1, 0 );
printf( "DOS Version: %2.1f", ( (float) GetVer() ) / 100 );
/* Display disk statistics for current drive */
SetCurPos( 0, 58 );
GetDiskSize( 0, &disk );
dsize = (long)disk.bytes * disk.sects * disk.total;
disk_use = (long)(disk.total - disk.avail) * disk.bytes * disk.sects;
printf( "Disk Size: %6lu K", dsize / 1024 );
SetCurPos( 1, 58 );
printf( "Disk Use: %6lu K", disk_use / 1024 );
/* Display menu and poll for keystroke */
clear_scrn( disp_attr, 2, 23 );
SetCurPos( 5, 0 );
puts( " \t *** FILE " \
"Demonstration Program ***" );
SetCurPos( 7, 0 );
puts( " \tA List Directory \t\tH Get/Set File Attribute" );
puts( " \tB Copy File \t\tI Get File Date and Time" );
puts( " \tC Move File \t\tJ Rename File" );
puts( " \tD Make Subdirectory \t\tK Delete File" );
puts( " \tE Remove Subdirectory \t\tL Create Unique File" );
puts( " \tF Change Default Drive \t\tM Quick Move" );
puts( " \tG Change Directory \t\tN Find Text" );
printf( "\n\n\tSelect an option, or press ESC to quit: " );
ch = getch();
switch( (ch = toupper( ch )) )
{
/* List first 60 files in specified directory */
case 'A':
err = list_dir( get_spec( 1 ), disp_attr );
if( !err )
press();
break;
/* Copy or Move File according to requested mode:
* 0 = overwrite target
* 1 = abort if target exists
* If Move requested, delete source file after copy.
*/
case 'B':
case 'C':
clear_scrn( disp_attr, 2, 17 );
SetCurPos( 9, 0 );
puts( copy_msg );
mode = -1;
while( (mode < 0) || (mode > 1) )
{
SetCurPos( 16, 0 );
printf( "Enter copy mode: " );
mode = (int)(getche() - '0');
}
spec = get_spec( 2 ); /* Get source */
strcpy( source, spec ); /* Save in buffer */
spec = get_spec( 3 ); /* Get target */
err = CopyFile( mode, source, spec );
if( (ch == 'C') && !err )
err = DelFile( source );
break;
/* Make Directory */
case 'D':
err = MakeDir( get_spec( 1 ) );
break;
/* Remove Directory */
case 'E':
err = RemoveDir( get_spec( 1 ) );
break;
/* Change Default Drive */
case 'F':
SetCurPos( 18, 0 );
printf( "Enter new drive letter: " );
ch = getch();
ch = toupper( ch );
ChangeDrive( ch );
err = 0;
break;
/* Change Directory */
case 'G':
err = ChangeDir( get_spec( 1 ) );
break;
/* Get and Set File Attributes */
case 'H':
strcpy( source, get_spec( 3 ) );
if( (err = GetAttribute( source )) != -1 )
{
attr = err;
if( !attr )
attr_msg[6] = '*';
else
attr_msg[6] = ' ';
for( j = 1, i = 27; j <= 32; j <<= 1, i+= 21 )
{
attr_msg[i] = ' ';
if( attr & j )
attr_msg[i] = '*';
}
err = 0;
clear_scrn( disp_attr, 2, 17 );
SetCurPos( 7, 0 );
puts( attr_msg );
printf( "\n\nToggle attribute bits by selecting 1-5, " \
"or any other key to exit: " );
mode = (int)( getch() - '0' );
if( (mode > 0) && (mode < 6) )
{
switch( --mode )
{
case 0:
attr = 0;
break;
case 1:
case 2:
case 3:
attr = attr ^ (1 << (--mode) );
break;
case 4:
attr = attr ^ 32;
}
err = SetAttribute( attr, source );
}
}
break;
/* Get File Date and Time */
case 'I':
if( (handle = OpenFile( 0, get_spec( 3 ) )) == -1 )
err = 1;
else
err = 0;
if( !err )
{
if( !(err = GetFileTime( handle, date_time )) )
{
clear_scrn( disp_attr, 2, 17 );
SetCurPos( 12, 10 );
printf( "File's date and time stamp: %s", date_time );
CloseFile( handle );
press();
}
}
break;
/* Rename File */
case 'J':
strcpy( source, get_spec( 2 ) );
err = RenameFile( source, get_spec( 3 ) );
break;
/* Delete File */
case 'K':
err = DelFile( get_spec( 3 ) );
break;
/* Create File with Unique Name */
case 'L':
strcpy( source, get_spec( 1 ) );
handle = UniqueFile( 0, source ); /* Normal file attr = 0 */
if( handle >= 0 )
{
printf( "\n\nDOS creates file %s", source );
press();
err = 0;
}
else err = 1;
break;
/* Quick Move from one directory to another */
case 'M':
clear_scrn( disp_attr, 2, 17 );
SetCurPos( 8, 0 );
puts( move_msg );
strcpy( source, get_spec( 2 ) );
err = RenameFile( source, get_spec( 3 ) );
break;
/* Search files for specified text */
case 'N':
clear_scrn( disp_attr, 2, 17 );
buffer = (char *) malloc( BUFFSIZE + 1 );
if( buffer == NULL )
{
SetCurPos( 12, 26 );
puts( "Insufficient memory for option" );
err = 1;
break;
}
SetCurPos( 7, 0 );
puts( grep_msg );
SetCurPos( 18, 0 );
printf( "Enter search text: " );
GetStr( text, MAXSEARCH );
/* Find first data file. */
if( err = FindFirst( 0, get_spec( 3 ), &file ) )
{
clear_scrn( disp_attr, 2, 17 );
SetCurPos( 12, 24 );
puts( "No files found matching specification" );
}
/* If file found, initialize screen coordinates and
* open file for reading.
*/
else
{
clear_scrn( disp_attr, 2, 17 );
row = 6;
col = 0;
do
{
if( (handle = OpenFile( 0, file.filename )) != -1 )
{
/* If file opened successfully, read a block
* of BUFFSIZE bytes. If end-of-file encountered
* (number of bytes read not equal to BUFFSIZE)
* or read error, set error flag to break loop.
* Terminate block with a NULL character to
* make it an ASCIIZ string.
*/
err = 0;
while( !err )
{
len = ReadFile( handle, BUFFSIZE, buffer );
if( (len == 0) || (len != BUFFSIZE) )
++err;
ptr = buffer;
*( ptr + len ) = 0;
/* Search block for first character in text */
while( spec = StrFindChar( text[0], ptr, 0 ) )
{
/* If initial character found, compare
* remaining characters in search text.
* If all characters match, display file
* name and break out of loop.
*/
ptr = StrCompare( ++spec, &text[1],
(strlen( text ) - 1) );
if( !ptr )
{
SetCurPos( row++, col );
puts( file.filename );
if( row == 16)
{
row = 6;
col += 20;
}
err = 1;
break;
}
}
}
CloseFile( handle );
}
else
{
err = 1;
break;
}
} while( !FindNext( &file ) );
if( (row == 6) && (col == 0) )
{
SetCurPos( 12, 22 );
puts( "Text not found in specified file(s)" );
}
press();
err = 0;
}
free( buffer ); /* Free allocated block */
break;
default:
continue;
}
if( err )
{
clear_scrn( disp_attr, 24, 24 );
SetCurPos( 24, 0 );
printf( "*** Error ***\a" );
press();
}
} while( ch != ESCAPE ); /* Exit if ESC key pressed */
clear_scrn( disp_attr, 0, 24 ); /* Clear screen before exit */
SetCurPos( 23, 0 ); /* and set cursor to bottom */
return( 0 );
}
void
change_c::parse_boolean() {
try {
m_b_value = parse_bool(m_value);
} catch (...) {
mxerror(boost::format(Y("The property value is not a valid boolean in '%1%'. %2%\n")) % get_spec() % FILE_NOT_MODIFIED);
}
}
void
change_c::validate(std::vector<property_element_c> *property_table) {
if (!property_table)
return;
for (auto &property : *property_table)
if (property.m_name == m_name) {
m_property = property;
if (change_c::ct_delete == m_type)
validate_deletion_of_mandatory();
else
parse_value();
return;
}
mxerror(boost::format(Y("The name '%1%' is not a valid property name for the current edit specification in '%2%'.\n")) % m_name % get_spec());
}
void
change_c::validate_deletion_of_mandatory() {
const EbmlSemantic *semantic = get_semantic();
if (semantic && semantic->Mandatory)
mxerror(boost::format(Y("This property is mandatory and cannot be deleted in '%1%'. %2%\n")) % get_spec() % FILE_NOT_MODIFIED);
}
void
change_c::parse_ascii_string() {
size_t i;
for (i = 0; m_value.length() > i; ++i)
if (127 < static_cast<unsigned char>(m_value[i]))
mxerror(boost::format(Y("The property value contains non-ASCII characters, but the property is not a Unicode string in '%1%'. %2%\n")) % get_spec() % FILE_NOT_MODIFIED);
m_s_value = m_value;
}
void
change_c::execute_delete() {
size_t idx = 0;
unsigned int num_deleted = 0;
while (m_master->ListSize() > idx) {
if (m_property.m_callbacks->GlobalId == (*m_master)[idx]->Generic().GlobalId) {
m_master->Remove(idx);
++num_deleted;
} else
++idx;
}
if (1 < verbose)
mxinfo(boost::format(Y("Change for '%1%' executed. Number of entries deleted: %2%\n")) % get_spec() % num_deleted);
}
void
change_c::parse_floating_point_number() {
if (!parse_number(m_value, m_fp_value))
mxerror(boost::format(Y("The property value is not a valid floating point number in '%1%'. %2%\n")) % get_spec() % FILE_NOT_MODIFIED);
}
void
change_c::parse_binary() {
try {
m_x_value = bitvalue_c(m_value, 128);
} catch (...) {
mxerror(boost::format(Y("The property value is not a valid binary spec or it is not exactly 128 bits long in '%1%'. %2%\n")) % get_spec() % FILE_NOT_MODIFIED);
}
}