static void override_abs(int fd, const char *devnode,
unsigned evcode, const char *value) {
struct input_absinfo absinfo;
int rc;
char *next;
rc = ioctl(fd, EVIOCGABS(evcode), &absinfo);
if (rc < 0) {
log_error_errno(errno, "Unable to EVIOCGABS device \"%s\"", devnode);
return;
}
next = parse_token(value, &absinfo.minimum);
next = parse_token(next, &absinfo.maximum);
next = parse_token(next, &absinfo.resolution);
next = parse_token(next, &absinfo.fuzz);
next = parse_token(next, &absinfo.flat);
if (!next) {
log_error("Unable to parse EV_ABS override '%s' for '%s'", value, devnode);
return;
}
log_debug("keyboard: %x overridden with %"PRIi32"/%"PRIi32"/%"PRIi32"/%"PRIi32"/%"PRIi32" for \"%s\"",
evcode,
absinfo.minimum, absinfo.maximum, absinfo.resolution, absinfo.fuzz, absinfo.flat,
devnode);
rc = ioctl(fd, EVIOCSABS(evcode), &absinfo);
if (rc < 0)
log_error_errno(errno, "Unable to EVIOCSABS device \"%s\"", devnode);
}
/*---------------------------------------------------------------------*/
string_t *
readstring( FILE *file ) {
token_t *tok = parse_token( file );
if( !tok ) {
fprintf( stderr, "Premature end of file\n" );
return 0L;
} else {
if( tok->tok == TOKEN_SYMBOL ) {
token_t *tok2 = parse_token( file );
if( !tok2 ) {
fprintf( stderr, "Premature end of file\n" );
return 0L;
} else {
if( tok2->tok == TOKEN_GUIL ) {
return make_string( tok->val );
} else {
fprintf( stderr, "Illegal string...%s\n", tok->val );
return 0L;
}
}
} else {
return 0L;
}
}
}
/* Convert a symbolic value to a mask/value pair */
int pvr2_ctrl_sym_to_value(struct pvr2_ctrl *cptr,
const char *ptr,unsigned int len,
int *maskptr,int *valptr)
{
int ret = -EINVAL;
unsigned int cnt;
*maskptr = 0;
*valptr = 0;
cnt = 0;
while ((cnt < len) && ((ptr[cnt] <= 32) || (ptr[cnt] >= 127))) cnt++;
len -= cnt; ptr += cnt;
cnt = 0;
while ((cnt < len) && ((ptr[len-(cnt+1)] <= 32) ||
(ptr[len-(cnt+1)] >= 127))) cnt++;
len -= cnt;
if (!len) return -EINVAL;
LOCK_TAKE(cptr->hdw->big_lock); do {
if (cptr->info->type == pvr2_ctl_int) {
ret = parse_token(ptr,len,valptr,NULL,0);
if ((ret >= 0) &&
((*valptr < cptr->info->def.type_int.min_value) ||
(*valptr > cptr->info->def.type_int.max_value))) {
ret = -ERANGE;
}
if (maskptr) *maskptr = ~0;
} else if (cptr->info->type == pvr2_ctl_bool) {
ret = parse_token(
ptr,len,valptr,boolNames,
sizeof(boolNames)/sizeof(boolNames[0]));
if (ret == 1) {
*valptr = *valptr ? !0 : 0;
} else if (ret == 0) {
*valptr = (*valptr & 1) ? !0 : 0;
}
if (maskptr) *maskptr = 1;
} else if (cptr->info->type == pvr2_ctl_enum) {
ret = parse_token(
ptr,len,valptr,
cptr->info->def.type_enum.value_names,
cptr->info->def.type_enum.count);
if ((ret >= 0) &&
((*valptr < 0) ||
(*valptr >= cptr->info->def.type_enum.count))) {
ret = -ERANGE;
}
if (maskptr) *maskptr = ~0;
} else if (cptr->info->type == pvr2_ctl_bitmask) {
ret = parse_tlist(
ptr,len,maskptr,valptr,
cptr->info->def.type_bitmask.bit_names,
cptr->info->def.type_bitmask.valid_bits);
}
} while(0); LOCK_GIVE(cptr->hdw->big_lock);
return ret;
}
int main(int argc, char* argv[])
{
assert(parse_token("it is used to token segmentation. is it easy?", " .?", on_token, NULL) == 9);
assert(parse_token("/backup/tools/jdk1.5.0_18/bin/:/usr/lib/qt-3.3/bin:/usr/kerberos/bin:/backup/tools/jdk1.5.0_18/bin/:/usr/lib/ccache:/usr/local/bin:/usr/bin:/bin:/home/lixianjing/bin", ":", on_token, NULL) == 9);
assert(parse_token("/backup/tools/jdk1.5.0_18/bin/", "/", on_token, NULL) == 4);
return 0;
}
/*
* write table index to keys[]
* internal function for process_keyfile()
*/
static int
fkey_table_relation (char *args)
{
int ti=0, ki=0;
char *s_func=NULL, *s_key=NULL;
int slen=0, restidx=-1, sublen=-1;
int ret = 1;
slen = parse_token(args, "\x09= ", &restidx);
/* special case separately: empty line */
if (slen == 0) {
return (0);
}
args[slen] = '\0';
s_key = &args[0];
if (restidx > 0) {
s_func = &args[restidx];
sublen = parse_token(s_func, "\x09 ", &restidx);
s_func[sublen] = '\0';
}
if (slen < 3 || sublen < 1 || s_key[0] == '#') {
/* comment lines covered also */
return (0);
}
/* find ti and ki */
ret=1;
ti = index_func_fullname(s_func);
if (ti < TLEN && table[ti].fkey != -1) {
ki = index_key_string(s_key);
if (ki < KLEN && ki >= RES_KLEN) {
keys[ki].table_index = ti;
ret = 0;
} else {
if (ki < RES_KLEN) {
fprintf(stderr, "eda: key %s is reserved\n", s_key);
} else {
fprintf(stderr, "eda: key %s is unknown\n", s_key);
}
}
} else {
fprintf(stderr, "eda: function %s is unknown or cannot bind fkey\n", s_func);
}
return (ret);
}/* fkey_table_relation */
void prim_fsize(PRIM_PROTOTYPE)
{
FILE *fh;
char *filename;
int result;
long offset;
CHECKOP(1);
oper1 = POP();
if (getuid() == 0 )
abort_interp("Muck is running under root privs, file prims disabled.");
if (mlev < LBOY) abort_interp("BOY primitive only.");
if (oper1->type != PROG_STRING) abort_interp("Arguement 1 is not a string.");
if (!oper1->data.string) abort_interp("Arguement 1 is a null string.");
filename = oper1->data.string->data;
#ifdef SECURE_FILE_PRIMS
if (!(valid_name(filename)))
abort_interp( "Invalid file name.");
if ( strchr( filename, '$' ) == NULL )
filename = set_directory(filename);
else
filename = parse_token( filename );
if ( filename == NULL )
abort_interp( "Invalid shortcut used." );
#endif
fh = fopen(filename, "r");
if (fh == NULL) { offset = -1; } else {
fseek(fh, 0, SEEK_END);
offset = ftell(fh);
if(tp_log_files)
log2filetime("logs/files", "#%d by %s FSIZE: %s \n", program, unparse_object(player, player), oper1->data.string->data);
}
fclose(fh);
CLEAR(oper1);
PushInt(offset);
}
void prim_frm(PRIM_PROTOTYPE)
{
char *filename;
CHECKOP(1);
oper1 = POP();
if (getuid() == 0 )
abort_interp("Muck is running under root privs, file prims disabled.");
if (mlev < LBOY) abort_interp("BOY primitive only.");
if(oper1->type != PROG_STRING) abort_interp("Argument 1 is not a string.");
if(!oper1->data.string) abort_interp("Argument 1 is a null string.");
filename = oper1->data.string->data;
#ifdef SECURE_FILE_PRIMS
if (!(valid_name(filename)))
abort_interp( "Invalid file name.");
if ( strchr( filename, '$' ) == NULL )
filename = set_directory(filename);
else
filename = parse_token( filename );
if ( filename == NULL )
abort_interp( "Invalid shortcut used." );
#endif
result = unlink(filename);
if(tp_log_files)
log2filetime("logs/files", "#%d by %s FRM: %s \n", program, unparse_object(player, player), oper1->data.string->data);
CLEAR(oper1);
PushInt(result);
}
int
main(int argc, char **argv)
{
char text[100], delims[10];
scanf("%s %s", text, delims);
parse_token(text, delims, token_print, NULL);
}
KeyMap_t *parse_mapping(Display *ctrl_conn, char *mapping) {
char *token;
KeyMap_t *rval, *km, *nkm;
rval = km = NULL;
for (;;) {
token = strsep(&mapping, ";");
if (token == NULL)
break;
nkm = parse_token(ctrl_conn, token);
if (nkm != NULL) {
if (km == NULL)
rval = km = nkm;
else {
km->next = nkm;
km = nkm;
}
}
}
return rval;
}
void simple_parser::load(const std::string& fileName, bool makeLowercaseTags)
{
std::ifstream xmlFile(fileName.c_str());
if ( !xmlFile.is_open() )
throw std::runtime_error("Cannot open file <" + fileName + ">!" );
xmlFile.exceptions(std::ios::badbit);
std::string tokenName;
bool isComment;
bool isInTag;
for (;;)
{
isInTag = parse_token(xmlFile, tokenName, isComment);
if ( xmlFile.eof() )
break;
if ( isInTag )
{
if ( isComment )
continue;
boost::shared_ptr<tree_node> pTmpMap(new tree_node());
m_root.push_back(pTmpMap);
recursive_parse_tag(tokenName, xmlFile, pTmpMap, makeLowercaseTags);
}
}
}
static int parse_absolute_path(http_parser_t *parser)
{
char *path, *token;
path = malloc(PATH_LEN);
ASSERT(path != NULL);
memset(path, 0, PATH_LEN);
do {
if (parser->parse_ptr - parser->data >= parser->len)
return 1;
if (parse_char(parser, '/'))
break;
token = parse_token(parser);
if (!token)
return 1;
strlcat(path, "/", PATH_LEN);
strlcat(path, token, PATH_LEN);
free(token);
} while (1);
parser->req.path = path;
return 0;
}
static int
parse_directive(char **conf)
{
char *dir;
int error;
error = parse_token(conf, &dir);
if (error)
return (error);
if (strcmp(dir, ".ask") == 0)
error = parse_dir_ask(conf);
else if (strcmp(dir, ".md") == 0)
error = parse_dir_md(conf);
else if (strcmp(dir, ".onfail") == 0)
error = parse_dir_onfail(conf);
else if (strcmp(dir, ".timeout") == 0)
error = parse_dir_timeout(conf);
else {
printf("mountroot: invalid directive `%s'\n", dir);
/* Ignore the rest of the line. */
(void)parse_skipto(conf, '\n');
error = EINVAL;
}
free(dir, M_TEMP);
return (error);
}
static
int parse_index(FILE * file)
{
if (0 != parse_token(file, number_buffer, NUMBER_BUFFER_LEN))
return -1;
return to_number(number_buffer);
}
static int
parse_dir_onfail(char **conf)
{
char *action;
int error;
error = parse_token(conf, &action);
if (error)
return (error);
if (!strcmp(action, "continue"))
root_mount_onfail = A_CONTINUE;
else if (!strcmp(action, "panic"))
root_mount_onfail = A_PANIC;
else if (!strcmp(action, "reboot"))
root_mount_onfail = A_REBOOT;
else if (!strcmp(action, "retry"))
root_mount_onfail = A_RETRY;
else {
printf("rootmount: %s: unknown action\n", action);
error = EINVAL;
}
free(action, M_TEMP);
return (0);
}
static int parse_message_header(http_parser_t *parser)
{
int field_num;
http_header_field_t *field;
field_num = add_field(parser);
field = &parser->req.fields[field_num];
field->valid = 0;
parse_crlf(parser);
field->name = parse_token(parser);
if (!field)
return 1;
if (parse_char(parser, ':')) {
free(field->name);
return 1;
}
// optional
while (parse_char(parser, ' ') == 0)
;
field->value = parse_field_content(parser);
if (!field->value)
return 1;
while (parse_char(parser, ' ') == 0)
;
field->valid = 1;
return 0;
}
int parse_noise(char *noise_param, int store)
{
int ret = 0;
char *tmp = strdup(noise_param);
char * pch, *ech;
pch = strchr(tmp, '[');
if (NULL != pch) {
pch++;
ech = strchr(pch, ']');
if (NULL != ech) {
*ech = '\0';
ech++;
if ('\0' != *ech) {
ret = 1;
} else {
ret = parse_token(pch, 1, store);
}
} else {
ret = 1;
}
}
free(tmp);
return ret;
}
/**
* Parse a string for a crtc.
* \param crtc Crtc to write.
* \param begin Start of the string to parse.
* \param end End of the string to parse.
* \return
* - ==0 on success
* - !=0 on error
*/
adv_error crtc_parse(adv_crtc* crtc, const char* begin, const char* end)
{
crtc_reset(crtc);
crtc_user_reset(crtc);
parse_separator(" \t", &begin, end);
if (begin != end && *begin == '"') {
if (parse_quote(crtc->name, CRTC_NAME_MAX, &begin, end))
return -1;
} else {
if (parse_token(crtc->name, CRTC_NAME_MAX, " \t", &begin, end))
return -1;
}
parse_separator(" \t", &begin, end);
if (begin == end) {
snprintf(video_mode_parse_error_buffer, sizeof(video_mode_parse_error_buffer), "Missing modeline data");
return -1;
}
if (parse_crtc(crtc, begin, end) != 0)
return -1;
return 0;
}
// 解析response json ， 获取token，验证scope信息
RETURN_CODE
speech_get_token(const char *api_key, const char *secret_key, const char *scope, char *token) {
char url_pattern[] = "%s?grant_type=client_credentials&client_id=%s&client_secret=%s";
char url[200];
char *response = NULL;
snprintf(url, 200, url_pattern, API_TOKEN_URL, api_key, secret_key);
printf("url is: %s\n", url);
CURL *curl = curl_easy_init();
curl_easy_setopt(curl, CURLOPT_URL, url); // 注意返回值判读
curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, 5);
curl_easy_setopt(curl, CURLOPT_TIMEOUT, 60); // 60s超时
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, writefunc);
curl_easy_setopt(curl, CURLOPT_WRITEDATA, &response);
CURLcode res_curl = curl_easy_perform(curl);
RETURN_CODE res = RETURN_OK;
if (res_curl != CURLE_OK) {
snprintf(g_demo_error_msg, BUFFER_ERROR_SIZE, "perform curl error:%d, %s.\n", res,
curl_easy_strerror(res_curl));
res = ERROR_TOKEN_CURL;
} else {
res = parse_token(response, scope, token); // 解析token，结果保存在token里
if (res == RETURN_OK) {
printf("token: %s of %s\n", token, response);
}
}
free(response);
curl_easy_cleanup(curl);
return res;
}
/*---------------------------------------------------------------------*/
obj_t *
readobj( FILE *file ) {
token_t *tok = parse_token( file );
if( !tok ) {
return 0L;
} else {
switch( tok->tok ) {
case TOKEN_OPENPAR:
return (obj_t *)readlist( file );
case TOKEN_SYMBOL:
return (obj_t *)make_symbol( tok->val );
case TOKEN_STRING:
return (obj_t *)make_string( tok->val );
case TOKEN_INT:
return (obj_t *)make_integer( atol( tok->val ) );
default:
fprintf( stderr, "Illegal %s: %s\n",
token_type( tok ),
tok->val );
return (obj_t *)NIL;
}
}
}
void ASVolume_parseGnomeIconString (ASVolume *v)
{
if (v) {
static char signature[] = ". GThemedIcon ";
destroy_string (&(v->idString));
if (v->icon) {
ASImage *tmp = GIcon2ASImage (v->icon);
gchar* str = g_icon_to_string (v->icon);
show_activity ("volume added with icon \"%s\".", str);
if (str) {
if (strncmp (str, signature, sizeof(signature)-1) == 0)
parse_token (&str [sizeof(signature)-1], &(v->idString));
safefree (str);
}
if (tmp) {
int l, t, r, b;
get_asimage_closure (tmp, &l, &t, &r, &b, 10);
v->iconIm = tile_asimage (Scr.asv, tmp, l, t, r+1-l, b+1-t, 0x4F7F7F7F, ASA_ASImage, 100, ASIMAGE_QUALITY_DEFAULT);
safe_asimage_destroy (tmp);
}
LOCAL_DEBUG_OUT ("Icon asim = %p", v->iconIm);
}
if (!v->idString)
v->idString = mystrdup ("unknown");
}
}
static int format_string(const char *format, char *buffer, int buf_size, MU_Logger_Format_Info_t *info, va_list args){
int buf_index = 0, left = buf_size;
const int token_size = 4;
/// Since max size of each format is 3, I can just read 2 to 3 characters to determine whether or not it passes a check.
char token[token_size + 1];
char ch;
while((ch = *format++))
{
if(!left) break;
info->should_free = 0;
if(ch == '%'){
sprintf(token, "%%%.*s", token_size - 1, format);
const char *tok_str = parse_token(token, info, args);
if(tok_str){
int should_copy = strlen(tok_str) > left ? left : strlen(tok_str);
strncpy(buffer + buf_index, tok_str, left);
format += token_size - 1;
buf_index += should_copy;
left -= should_copy;
if(info->should_free) free((char *)tok_str);
continue;
}
}
buffer[buf_index++] = ch;
left--;
}
buffer[buf_index] = '\0';
return buf_index;
}
/*
* Extract a tag from the line.
*
* Return 1 if a valid tag was found.
* Return 0 if no tag found.
* Return -ve error code.
*/
static int parse_tag(blkid_cache cache, blkid_dev dev, char **cp)
{
char *name = NULL;
char *value = NULL;
int ret;
if (!cache || !dev)
return -BLKID_ERR_PARAM;
if ((ret = parse_token(&name, &value, cp)) <= 0 /* &&
(ret = parse_xml(&name, &value, cp)) <= 0 */)
return ret;
DBG(READ, ul_debug("tag: %s=\"%s\"", name, value));
/* Some tags are stored directly in the device struct */
if (!strcmp(name, "DEVNO"))
dev->bid_devno = strtoull(value, NULL, 0);
else if (!strcmp(name, "PRI"))
dev->bid_pri = strtol(value, NULL, 0);
else if (!strcmp(name, "TIME")) {
char *end = NULL;
dev->bid_time = strtoull(value, &end, 0);
if (end && *end == '.')
dev->bid_utime = strtoull(end + 1, NULL, 0);
} else
ret = blkid_set_tag(dev, name, value, strlen(value));
return ret < 0 ? ret : 1;
}
std::string ptb_normalizer::next()
{
// if we have buffered tokens, keep returning them until we have
// exhausted the buffer
if (!tokens_.empty())
{
auto token = tokens_.front();
tokens_.pop_front();
return token;
}
if (!*source_)
throw token_stream_exception{"next() called with empty source"};
auto token = source_->next();
if (token == "\"")
{
tokens_.push_back("``");
// keep reading until we either hit the next pair of quotes or, in
// error cases, the end of sentence marker. Buffer tokens along the
// way.
while (*source_)
{
auto nxt = source_->next();
if (nxt == "\"")
{
tokens_.push_back("''");
return current_token();
}
parse_token(nxt);
if (nxt == "</s>")
return current_token();
}
// only get here if we've parsed the whole source and never found a
// matching end quote, so just return the buffered tokens at this
// point
return current_token();
}
parse_token(token);
return current_token();
}
static void
vfs_mountroot_conf0(struct sbuf *sb)
{
char *s, *tok, *mnt, *opt;
int error;
sbuf_printf(sb, ".onfail panic\n");
sbuf_printf(sb, ".timeout %d\n", root_mount_timeout);
if (boothowto & RB_ASKNAME)
sbuf_printf(sb, ".ask\n");
#ifdef ROOTDEVNAME
if (boothowto & RB_DFLTROOT)
sbuf_printf(sb, "%s\n", ROOTDEVNAME);
#endif
if (boothowto & RB_CDROM) {
sbuf_printf(sb, "cd9660:/dev/cd0 ro\n");
sbuf_printf(sb, ".timeout 0\n");
sbuf_printf(sb, "cd9660:/dev/acd0 ro\n");
sbuf_printf(sb, ".timeout %d\n", root_mount_timeout);
}
s = getenv("vfs.root.mountfrom");
if (s != NULL) {
opt = getenv("vfs.root.mountfrom.options");
tok = s;
error = parse_token(&tok, &mnt);
while (!error) {
sbuf_printf(sb, "%s %s\n", mnt,
(opt != NULL) ? opt : "");
free(mnt, M_TEMP);
error = parse_token(&tok, &mnt);
}
if (opt != NULL)
freeenv(opt);
freeenv(s);
}
if (rootdevnames[0] != NULL)
sbuf_printf(sb, "%s\n", rootdevnames[0]);
if (rootdevnames[1] != NULL)
sbuf_printf(sb, "%s\n", rootdevnames[1]);
#ifdef ROOTDEVNAME
if (!(boothowto & RB_DFLTROOT))
sbuf_printf(sb, "%s\n", ROOTDEVNAME);
#endif
if (!(boothowto & RB_ASKNAME))
sbuf_printf(sb, ".ask\n");
}
// media-type = type "/" subtype *( ";" parameter )
// type = token
// subtype = token
const char* parse_media_type(unsigned char** p)
{
if (parse_token(p))
return ERR;
if (parse_char(p, '/'))
return ERR;
if (parse_token(p))
return ERR;
while (0 != (char)**p) {
if (parse_char(p, ';'))
break;
if (parse_parameter(p))
return ERR;
}
return NULL;
}
/*
* Name: parse_macro
* Purpose: separate literals from keys in a macro definition
* Date: June 5, 1992
* Passed: macro_key: key that we are a assigning a macro to
* residue: pointer to macro defs
* Notes: for each token in macro def, find out if it's a literal or a
* function key.
* a literal begins with a ". to put a " in a macro def, precede
* a " with a ".
*/
void parse_macro( int macro_key, char *residue )
{
int rc;
char literal[1042];
char *l;
int key_no;
/*
* reset any previous macro def.
*/
initialize_macro( macro_key );
while (residue != NULL) {
/*
* skip over any leading spaces.
*/
while (*residue == ' ')
++residue;
/*
* done if we hit a comment
*/
if (*residue == ';')
residue = NULL;
/*
* check for a literal.
*/
else if (*residue == '\"') {
rc = parse_literal( macro_key, residue, literal, &residue );
if (rc == OK) {
l = literal;
while (*l != '\0' && rc == OK) {
rc = record_keys( macro_key, *l );
++l;
}
} else {
printf( "==> %s", line_in );
printf( "Literal not recognized: line %u : literal %s\n", line_no, literal );
}
/*
* check for a function key.
*/
} else {
residue = parse_token( residue, literal );
key_no = search( literal, valid_keys, AVAIL_KEYS );
if (key_no != ERROR)
record_keys( macro_key, key_no+256 );
else {
printf( "==> %s", line_in );
printf( "Unrecognized key: line %u : key %s\n", line_no, literal );
}
}
}
check_macro( macro_key );
}
// parameter = attribute "=" value
// attribute = token
const char* parse_parameter(unsigned char** p)
{
if (parse_token(p))
return ERR;
if (parse_char(p, '='))
return ERR;
if (parse_value(p))
return ERR;
return NULL;
}
bool UUID::fromString( const char* str )
{
if( parse_token( str, ( xuuid_t* ) this ) != 0 )
{
dMemset( this, 0, sizeof( UUID ) );
return false;
}
return true;
}
void prim_fren(PRIM_PROTOTYPE)
{
char *oldname, *newname;
char tempB[BUFFER_LEN] = "";
CHECKOP(2);
oper1 = POP();
oper2 = POP();
if (getuid() == 0 )
abort_interp("Muck is running under root privs, file prims disabled.");
if (mlev < LBOY) abort_interp("BOY primitive only.");
if(oper1->type != PROG_STRING) abort_interp("Argument 1 is not a string.");
if(!oper1->data.string) abort_interp("Argument 1 is a null string.");
if(oper2->type != PROG_STRING) abort_interp("Argument 2 is not a string.");
if(!oper2->data.string) abort_interp("Argument 2 is a null string.");
newname = oper1->data.string->data;
oldname = oper2->data.string->data; /* ( s<old> s<new> -- i ) */
#ifdef SECURE_FILE_PRIMS
if (!(valid_name( newname )))
abort_interp( "Invalid file name. (2)");
if ( strchr( newname, '$' ) == NULL )
newname = set_directory(newname);
else
newname = parse_token( newname );
if ( newname == NULL )
abort_interp( "Invalid shortcut used. (2)" );
strcpy( tempB, newname );
if (!(valid_name(oldname)))
abort_interp( "Invalid file name. (1)");
if ( strchr( oldname, '$' ) == NULL )
oldname = set_directory(oldname);
else
oldname = parse_token( oldname );
if ( oldname == NULL )
abort_interp( "Invalid shortcut used. (1)" );
newname = tempB;
#endif
result = rename(oldname, newname);
if(tp_log_files)
log2filetime("logs/files", "#%d by %s FREN: %s -> %s \n", program, unparse_object(player, player), oper2->data.string->data, oper1->data.string->data);
CLEAR(oper1);
CLEAR(oper2);
PushInt(result);
}
const char * parse_op_name(FILE * file)
{
if (0 != parse_token(file, op_name_buffer, OP_NAME_BUFFER_LEN))
return NULL;
for (int i = 0; i < OP_COUNT; i++)
{
if (0 == strcmp(OPS[i], op_name_buffer))
return OPS[i];
}
return NULL;
}
