static char *
consume_argument(struct argparse *ap)
{
char *ret = get_argument(ap);
delete_argument(ap);
return ret;
}
gboolean test_argument(FILE *fp,const char *option,char **result)
{
char buf[1024];
while(!feof(fp))
{
bzero(buf,sizeof(buf));
fgets(buf,sizeof(buf)-1,fp);
/*以#开头的为注释被忽视掉*/
if(buf[0]=='#')
continue;
if(strstr(buf,option))
{
*result=get_argument(buf);
break;
}
}
if(feof(fp))
{
fseek(fp,0,SEEK_SET);
return FALSE;
}
fseek(fp,0,SEEK_SET);
return TRUE;
}
void serv_seg(t_on_screen *screen, char *msg)
{
char *team;
SDL_Color color;
SDL_Rect pos;
SDL_Surface *victory;
pos.x = 0;
pos.y = 0;
team = get_argument(msg, 2);
team[n_strlen(team, 1)] = '\0';
victory = img_load("images/victory.png");
xsdl_blitsurface(victory, NULL, screen->window, &pos);
if (TTF_Init() != -1)
{
color.r = 250;
color.g = 250;
color.b = 0;
send_team(screen, team, &pos, &color);
TTF_Quit();
}
SDL_FreeSurface(victory);
xsdl_flip(screen->window);
SDL_Delay(10000);
}
static awk_value_t *
test_array_param(int nargs, awk_value_t *result)
{
awk_value_t new_array;
awk_value_t arg0;
(void) nargs; /* silence warnings */
make_number(0.0, result);
if (! get_argument(0, AWK_UNDEFINED, & arg0)) {
printf("test_array_param: could not get argument\n");
goto out;
}
if (arg0.val_type != AWK_UNDEFINED) {
printf("test_array_param: argument is not undefined (%d)\n",
arg0.val_type);
goto out;
}
fill_in_array(& new_array);
if (! set_argument(0, new_array.array_cookie)) {
printf("test_array_param: could not change type of argument\n");
goto out;
}
make_number(1.0, result);
out:
return result; /* for now */
}
short ListCount::process(SqlciEnv * sqlci_env)
{
if (!get_argument())
{
sqlci_env->setListCount();
}
else
{
char *tmp;
ULng32 val = strtoul(get_argument(), &tmp, 10/*decimal base*/);
if (tmp == get_argument())
{ /* ##?emit an errmsg, illegal value? */ }
else
sqlci_env->setListCount(val);
}
return 0;
}
static awk_value_t *
var_test(int nargs, awk_value_t *result)
{
awk_value_t value, value2;
awk_value_t *valp;
assert(result != NULL);
make_number(0.0, result);
if (nargs != 1) {
printf("var_test: nargs not right (%d should be 1)\n", nargs);
goto out;
}
/* look up PROCINFO - should fail */
if (sym_lookup("PROCINFO", AWK_ARRAY, & value))
printf("var_test: sym_lookup of PROCINFO failed - got a value!\n");
else
printf("var_test: sym_lookup of PROCINFO passed - did not get a value\n");
/* look up a reserved variable - should pass */
if (sym_lookup("ARGC", AWK_NUMBER, & value))
printf("var_test: sym_lookup of ARGC passed - got a value!\n");
else
printf("var_test: sym_lookup of ARGC failed - did not get a value\n");
/* now try to set it - should fail */
value.num_value++;
if (sym_update("ARGC", & value))
printf("var_test: sym_update of ARGC passed and should not have!\n");
else
printf("var_test: sym_update of ARGC failed - correctly\n");
/* look up variable whose name is passed in, should pass */
if (get_argument(0, AWK_STRING, & value)) {
if (sym_lookup(value.str_value.str, AWK_STRING, & value2)) {
/* change the value, should be reflected in awk script */
valp = make_number(42.0, & value2);
if (sym_update(value.str_value.str, valp)) {
printf("var_test: sym_update(\"%s\") succeeded\n", value.str_value.str);
} else {
printf("var_test: sym_update(\"%s\") failed\n", value.str_value.str);
goto out;
}
} else {
printf("var_test: sym_lookup(\"%s\") failed\n", value.str_value.str);
goto out;
}
} else {
printf("var_test: get_argument() failed\n");
goto out;
}
make_number(1.0, result);
out:
return result;
}
void Server::c_cmsg(string msg) {
string argument = get_argument(msg, 1);
for (vector<string>::iterator i = channels.begin(); i != channels.end(); i++) {
if (*i == argument) {
for (map<string, CList*>::iterator it = chanmap.begin(); it != chanmap.end(); it++ ) {
if (it->first == argument) {
say("S_CMSG " + argument);
for(vector<int>::iterator j = it->second->begin(); j != it->second->end(); j++) {
say("CMSG " + argument + " " + nick + " " + get_argument(msg, 2), *j);
}
return;
}
}
}
}
say("E_CMSG " + argument);
return;
}
Array* Arguments::as_array(STATE) {
Array* ary = Array::create(state, total());
for(uint32_t i = 0; i < total(); i++) {
ary->set(state, i, get_argument(i));
}
return ary;
}
const std::string& ClArgs::get_option_value(
const std::string& option_name) const
{
int option_index = find_option(option_name);
if (option_index >= 0)
++option_index;
return get_argument(option_index);
}
/**
* Deletes a file
*/
void console_delete(char *dir, char *command) {
memset(senddir, 0, 64);
strcpy(senddir, dir);
strcat(senddir, "/");
strcat(senddir, get_argument(command, 1));
if(!vfs_delete(senddir)) {
printk("delete: Error deleting file\n");
}
}
/**
* Creates a file
*/
void console_touch(char *dir, char *command) {
memset(senddir, 0, 64);
strcpy(senddir, dir);
strcat(senddir, "/");
strcat(senddir, get_argument(command, 1));
if(!vfs_touch(senddir)) {
printk("touch: Error creating file\n");
}
}
void Server::c_join(string msg) {
string argument = get_argument(msg, 1);
bool found = false;
if (chanmap.find(argument) == chanmap.end()) {
chanmap.insert(make_pair(argument, new CList()));
}
for (vector<int>::iterator it = chanmap.find(argument)->second->begin(); it != chanmap.find(argument)->second->end(); it++) {
if (*it == this->fd) {
found = true;
} else {
say("CMSG " + argument + " JOINS: " + nick + " " + get_argument(msg, 2), *it);
}
}
if (!found) {
chanmap.find(argument)->second->push_back(this->fd);
}
channels.push_back(argument);
say("SJOIN "+argument);
}
static awk_value_t *
do_pg_getvalue(int nargs, awk_value_t *result)
{
PGresult *res;
awk_value_t rowarg, colarg;
int row;
int col;
if (do_lint && (nargs > 3))
lintwarn(ext_id, _("pg_getvalue: called with too many arguments"));
if (!(res = find_handle(results, 0))) {
set_ERRNO(_("pg_getvalue called with unknown result handle"));
RET_NULSTR;
}
if (!get_argument(1, AWK_NUMBER, &rowarg)) {
set_ERRNO(_("pg_getvalue: 2nd argument must be a row number"));
RET_NULSTR;
}
row = rowarg.num_value;
if (!get_argument(2, AWK_NUMBER, &colarg)) {
set_ERRNO(_("pg_getvalue: 3rd argument must be a column number"));
RET_NULSTR;
}
col = colarg.num_value;
if ((row < 0) || (row >= PQntuples(res))) {
set_ERRNO(_("pg_getvalue: 2nd argument row_number is out of range"));
RET_NULSTR;
}
if ((col < 0) || (col >= PQnfields(res))) {
set_ERRNO(_("pg_getvalue: 3rd argument col_number is out of range"));
RET_NULSTR;
}
{
char *val = PQgetvalue(res, row, col);
return make_string_malloc(val, strlen(val), result);
}
}
bool IOHandler::fseek_exec()
{
if (!m_file)
return false;
int64_t offset, whence;
if (!get_argument(offset, whence))
return false;
return return_argument(fseek(m_file, offset, whence));
}
short SetParam::process(SqlciEnv * sqlci_env)
{
if (get_arglen() == -1)
{
// set param to null value
Param * param = sqlci_env->get_paramlist()->get(param_name);
if (param)
param->makeNull();
else
{
param = new Param(param_name, (char*)0);
sqlci_env->get_paramlist()->append(param);
param->makeNull();
}
}
else
if (!get_argument())
{
/* RESET PARAM command */
if (!param_name)
{
/* RESET all params */
Param * param = sqlci_env->get_paramlist()->getFirst();
while (param)
{
sqlci_env->get_paramlist()->remove(param->getName());
delete param;
param = sqlci_env->get_paramlist()->getNext();
}
}
else
{
Param * param = sqlci_env->get_paramlist()->get(param_name);
sqlci_env->get_paramlist()->remove(param_name);
delete param;
}
}
else
{
/* SET PARAM command */
Param * param = sqlci_env->get_paramlist()->get(param_name);
if (param) {
param->setValue(this);
} else
{
param = new Param(param_name, this);
sqlci_env->get_paramlist()->append(param);
}
}
return 0;
}
void Arguments::unshift(STATE, Object* val) {
Tuple* tup = Tuple::create_dirty(state, total() + 1);
tup->put(state, 0, val);
for(uint32_t i = 0; i < total(); i++) {
tup->put(state, i + 1, get_argument(i));
}
use_tuple(tup, total() + 1);
}
static void *
find_handle(strhash *ht, unsigned int argnum)
{
awk_value_t handle;
strhash_entry *ent;
if (!get_argument(argnum, AWK_STRING, &handle))
return NULL;
ent = strhash_get(ht, handle.str_value.str, handle.str_value.len, 0);
return ent ? ent->data : NULL;
}
bool IOHandler::ungetc_exec()
{
if (!m_file)
return false;
int64_t c;
if (!get_argument(c))
return false;
return return_argument(ungetc(c, m_file));
}
/* Get parameters for calling PQsendQueryParams, PQsendQueryPrepared,
PQexecParams, and PQexecPrepared. For these functions, the SQL
uses $1, $2, ... to represent the parameters, so we map the gawk
associative array values array[1] -> $1, array[2] -> $2, etc.
Note that the C API uses C arrays which start with subscript 0,
so be careful about off-by-one errors. */
static int
get_params(unsigned int nargs, unsigned int argnum, const char ***pvp)
{
awk_value_t paramValues_array;
const char **paramValues;
int nParams;
{
awk_value_t nParams_node;
if (!get_argument(argnum, AWK_NUMBER, &nParams_node))
return -1;
nParams = nParams_node.num_value;
}
if (nParams < 0)
return nParams;
if (!nParams || (argnum+1 >= nargs))
paramValues = NULL;
else {
int i;
if (!get_argument(argnum+1, AWK_ARRAY, ¶mValues_array))
return -1;
emalloc(paramValues, const char **, nParams*sizeof(*paramValues),
"get_params");
for (i = 0; i < nParams; i++) {
awk_value_t idx;
awk_value_t val;
/* Must add one when doing the array lookup because, for example, we
must set paramValues[0] to the value for $1 (which is stored in
the gawk array with subscript [1]) */
if (!get_array_element(paramValues_array.array_cookie,
make_number(i+1, &idx), AWK_STRING, &val))
paramValues[i] = NULL;
else
paramValues[i] = val.str_value.str;
}
}
*pvp = paramValues;
return nParams;
}
short SetPattern::process(SqlciEnv * sqlci_env)
{
if (!get_argument())
{
/* RESET PATTERN command */
if (!pattern_name)
{
/* RESET all patterns */
Param * pattern = sqlci_env->get_patternlist()->getFirst();
while (pattern)
{
sqlci_env->get_patternlist()->remove(pattern->getName());
delete pattern;
pattern = sqlci_env->get_patternlist()->getNext();
}
}
else
{
Param * pattern = sqlci_env->get_patternlist()->get(pattern_name);
sqlci_env->get_patternlist()->remove(pattern_name);
delete pattern;
}
}
else
{
/* SET PATTERN command */
Param * pattern = sqlci_env->get_patternlist()->get(pattern_name);
if (pattern)
{
pattern->setValue(get_argument(), sqlci_env->getTerminalCharset());
}
else
{
pattern = new Param(pattern_name, get_argument());
sqlci_env->get_patternlist()->append(pattern);
}
}
return 0;
}
void Arguments::unshift2(STATE, Object* one, Object* two) {
Tuple* tup = Tuple::create_dirty(state, total() + 2);
tup->put(state, 0, one);
tup->put(state, 1, two);
for(uint32_t i = 0; i < total(); i++) {
tup->put(state, i + 2, get_argument(i));
}
use_tuple(tup, total() + 2);
}
/**
* Starts a program
*/
void console_start(char *dir, char *command) {
memset(senddir, 0, 64);
strcpy(senddir, dir);
strcat(senddir, "/");
strcat(senddir, get_argument(command, 1));
// Cut the arguments from the path
if(get_argument(senddir, 1)) {
strncpy(senddir, senddir, strlen(senddir) - strlen(get_argument(senddir, 1)) - 1);
}
char *arguments = kmalloc(128);
memset(arguments, 0, 128);
strcpy(arguments, get_argument(command, 2));
int procn = start_proc(senddir, arguments);
if(procn != PROC_STOPPED) {
while(proc_state(procn) != PROC_STOPPED);
remove_proc(procn);
printk("\n");
}
}
void serv_plv(t_on_screen *screen, char *msg)
{
int num_cli;
int lvl;
t_cli *list_cli;
num_cli = atoi(get_argument(msg, 2));
lvl = atoi(get_argument(msg, 3));
list_cli = screen->world->client;
while (list_cli != NULL)
{
if (num_cli == list_cli->num)
{
list_cli->lvl = lvl;
init_perso(screen, list_cli);
screen->world->loading = 0;
return ;
}
list_cli = list_cli->next;
}
}
short Reset::reset_define(SqlciEnv * sqlci_env)
{
if (!get_argument())
{
/* RESET all defines */
Define * define = sqlci_env->get_definelist()->getFirst();
while (define)
{
define->reset(sqlci_env);
sqlci_env->get_definelist()->remove(define->getName());
define = sqlci_env->get_definelist()->getNext();
}
}
else
{
// DEFINEs are case insensitive (currently).
// Upcase the argument.
char * define_name = new char[strlen(get_argument())+1];
// NT_PORT 7/10/96 (LS) changed k definition from int to size_t
//
for (size_t k=0; k < strlen(get_argument()); k++)
{
#pragma nowarn(1506) // warning elimination
define_name[k] = toupper((get_argument())[k]);
#pragma warn(1506) // warning elimination
}
define_name[strlen(get_argument())] = 0;
Define * define = sqlci_env->get_definelist()->get(define_name);
if (define)
{
define->reset(sqlci_env);
sqlci_env->get_definelist()->remove(define_name);
}
delete define_name;
}
return 0;
}
static awk_value_t *
do_pg_getisnull(int nargs, awk_value_t *result)
{
PGresult *res;
awk_value_t rowarg, colarg;
int row;
int col;
if (do_lint && (nargs > 3))
lintwarn(ext_id, _("pg_getisnull: called with too many arguments"));
if (!(res = find_handle(results, 0))) {
set_ERRNO(_("pg_getisnull called with unknown result handle"));
RET_NUM(-1);
}
if (!get_argument(1, AWK_NUMBER, &rowarg)) {
set_ERRNO(_("pg_getisnull: 2nd argument must be a row number"));
RET_NUM(-1);
}
row = rowarg.num_value;
if (!get_argument(2, AWK_NUMBER, &colarg)) {
set_ERRNO(_("pg_getisnull: 3rd argument must be a column number"));
RET_NUM(-1);
}
col = colarg.num_value;
if ((row < 0) || (row >= PQntuples(res))) {
set_ERRNO(_("pg_getisnull: 2nd argument row_number is out of range"));
RET_NUM(-1);
}
if ((col < 0) || (col >= PQnfields(res))) {
set_ERRNO(_("pg_getisnull: 3rd argument col_number is out of range"));
RET_NUM(-1);
}
RET_NUM(PQgetisnull(res, row, col));
}
/**
* Outputs a file into the console
*/
void console_read(char *dir, char *command) {
memset(senddir, 0, 64);
strcpy(senddir, dir);
strcat(senddir, "/");
strcat(senddir, get_argument(command, 1));
file *f = vfs_file_open(senddir, "r");
if(f->type != FS_FILE) {
printk("read: file %s not found\n", senddir);
} else {
print_file(f);
}
vfs_file_close(f);
}
void Message::append_splat(STATE, Array* splat) {
Array* args = Array::create(state, splat->size() + total_args);
for(size_t i = 0; i < total_args; i++) {
args->set(state, i, get_argument(i));
}
for(size_t i = 0, n = total_args; i < splat->size(); i++, n++) {
args->set(state, n, splat->get(state, i));
}
use_array(args);
}
void serv_ebo(t_on_screen *screen, char *msg)
{
int ghost_num;
t_point pos;
ghost_num = atoi(get_argument(msg, 2));
pos = ghost_killer(screen, ghost_num);
if (pos.x != screen->world->width)
{
screen->world->map[pos.y][pos.x].nb_ghost -= 1;
screen->world->loading = 0;
}
}
int main()
{
#if DEBUG
parse_argument("action=read&tag_epc=E20494546478545324401C10");
getchar();
#else
char *request=NULL;
printf("Content-type; text/plain\n\n");
request=get_argument();
parse_argument(request);
#endif
return 0;
}
Array* Message::as_array(STATE) {
if(arguments_array) {
return arguments_array;
}
Array* ary = Array::create(state, args());
for(size_t i = 0; i < args(); i++) {
ary->set(state, i, get_argument(i));
}
return ary;
}
