int Hashhandler(char* cmd){
char* tok = strtok(NULL,DELIM);
if(!strcmp(tok,"--verify")){
tok = strtok(NULL,DELIM);
strcpy(files[0].name,tok);
gethash(parse2(files[0].name));
for(int j=0;j<MD5_DIGEST_LENGTH;++j){
files[0].hash[j]=h[j];
}
files[0].timestamp = findtime(files[0].name);
return 1;
}
else if(!strcmp(tok,"--checkall")){
int nu = IndexGet();
for(int i=0;i<nu;++i){
gethash(parse2(files[i].name));
for(int j=0;j<MD5_DIGEST_LENGTH;++j){
files[i].hash[j]=h[j];
}
files[i].timestamp = findtime(parse2(files[i].name));
}
return nu;
}
else{
//printf("wrong input\n");
return -1;
}
}
void PptvLive2::async_open(
response_type const & resp)
{
assert(StepType::closed == open_step_);
set_response(resp);
boost::system::error_code ec;
if (url_.path().find('-') != std::string::npos) {
// "[StreamID]-[Interval]-[datareate]
std::vector<std::string> strs;
slice<std::string>(url_.path(), std::inserter(strs, strs.end()), "-");
if (strs.size() >= 3) {
jump_info_.video.name = strs[0].substr(1);
jump_info_.video.rid = jump_info_.video.name;
parse2(strs[2], jump_info_.video.bitrate);
parse2(strs[1], seg_.interval);
} else {
ec = error::bad_url_format;
}
} else {
ec = error::bad_url_format;
}
handle_async_open(ec);
}
bool RemoteRepositoryAssistant::check_git_version ()
// Checks the git version.
{
bool okay = false;
GwSpawn spawn("git");
spawn.arg("--version");
spawn.read();
spawn.run();
ustring versiontext;
if (!spawn.standardout.empty())
versiontext = spawn.standardout[0];
gw_message (versiontext);
Parse parse1(versiontext, false);
if (parse1.words.size() >= 3) {
Parse parse2(parse1.words[2], false, ".");
if (parse2.words.size() >= 3) {
unsigned int version = 100 * convert_to_int(parse2.words[0]) + 10 * convert_to_int(parse2.words[1]) + convert_to_int(parse2.words[2]);
if (version >= 150)
okay = true;
}
}
if (!okay) {
versiontext.append(_(", but should be 1.5.0 or higher"));
gtk_label_set_text(GTK_LABEL(label_try_git), versiontext.c_str());
}
if (!spawn.result) {
gtk_label_set_text(GTK_LABEL(label_try_git), _("Program git failed to run. Has git been installed?"));
}
return okay;
}
void FunctionListPanel::reload()
{
// clean up
removeAllEntries();
generic_string funcBegin = TEXT("^[\\s]*");
generic_string qualifier_maybe = TEXT("((static|const)[\\s]+)?");
generic_string returnType = TEXT("[\\w]+");
generic_string space_starMaybe = TEXT("([\\s]+|\\*[\\s]+|[\\s]+\\*|[\\s]+\\*[\\s]+)");
//generic_string space_starMaybe = TEXT("([\\s]+|\\*[\\s]+|[\\s]+\\*)");
generic_string classQualifier_maybe = TEXT("([\\w_]+[\\s]*::)?");
generic_string funcName = TEXT("(?!(if|whil|for))[\\w_]+");
generic_string const_maybe = TEXT("([\\s]*const[\\s]*)?");
generic_string space_maybe = TEXT("[\\s]*");
generic_string params = TEXT("\\([\\n\\w_,*&\\s]*\\)");
generic_string funcBody = TEXT("\\{");
generic_string space_eol_maybe = TEXT("[\\n\\s]*");
generic_string function = funcBegin + qualifier_maybe + returnType + space_starMaybe + classQualifier_maybe + funcName + space_maybe + params + const_maybe + space_eol_maybe + funcBody;
generic_string secondSearch = funcName + space_maybe;
secondSearch += TEXT("\\(");
int docLen = (*_ppEditView)->getCurrentDocLen();
vector<foundInfo> fi;
vector<generic_string> regExpr1;
vector<generic_string> regExpr2;
regExpr1.push_back(secondSearch);
regExpr1.push_back(funcName);
generic_string secondSearch_className = TEXT("[\\w_]+(?=[\\s]*::)");
regExpr2.push_back(secondSearch_className);
generic_string classRegExpr = TEXT("^[\\t ]*(class|struct)[\\t ]+[\\w]+[\\s]*(:[\\s]*(public|protected|private)[\\s]+[\\w]+[\\s]*)?\\{");
vector<generic_string> classRegExprArray;
generic_string str1 = TEXT("(class|struct)[\\t ]+[\\w]+");
generic_string str2 = TEXT("[\\t ]+[\\w]+");
generic_string str3 = TEXT("[\\w]+");
classRegExprArray.push_back(str1.c_str());
classRegExprArray.push_back(str2.c_str());
classRegExprArray.push_back(str3.c_str());
//parse(fi, 0, docLen, function.c_str(), regExpr1, regExpr2);
const TCHAR bodyOpenSymbol[] = TEXT("\\{");
const TCHAR bodyCloseSymbol[] = TEXT("\\}");
parse2(fi, 0, docLen, classRegExpr.c_str(), classRegExprArray, bodyOpenSymbol, bodyCloseSymbol, function.c_str(), regExpr1);
for (size_t i = 0; i < fi.size(); i++)
{
generic_string entryName = TEXT("");
if (fi[i]._pos2 != -1)
{
entryName = fi[i]._data2;
entryName += TEXT("=>");
}
entryName += fi[i]._data;
addEntry(entryName.c_str(), fi[i]._pos);
}
}
ff::Signature ff::SignatureParser::parse(const std::string &str)
{
string::size_type pos = 0;
if ((pos = str.rfind("->")) == string::npos) {
return parse1(str);
}
return parse2(str, pos);
}
http_method_t HttpMethod::parse( const char * pMethod )
{
http_method_t method = parse2( pMethod );
if ( method )
{
char ch= *(pMethod + getLen( method ) );
if (( ch != ' ' )&&( ch != '\t' ))
return 0;
}
return method;
}
void iterate(int size, char arr[20][20], char arr2[20][20], char lines[108][200]) {
printf("size is %d \n", size);
if (size % 2 == 0) {
printf("2->3 transform \n");
int x;
int y;
for (x=0;x<size/2;x++){
for(y=0;y<size/2;y++){
printf("x, y = %d, %d\n", x,y);
//grab a 2x2 square into "two"
copyfrom(20, 2, arr, x*2, y*2, a2);
//looking for match
int l;
for (l=0; l<108; l++)
{
if (lines[l][6]=='=') {
parse2(lines[l],b2, b3);
if (match(2, a2, b2)==1) {
printf("match found \n");
copyto(3,20, b3, arr2,x*3,y*3);
break;
}
}
}
}
}
size = (size/2)*3;
}
else if (size % 3 == 0) {
printf("3->4 transform \n");
int x;
int y;
for (x=0;x<size/3;x++){
for(y=0;y<size/3;y++){
printf("x, y = %d, %d\n", x,y);
//grab a 3x3 square into "three"
copyfrom(20, 3, arr, x*3, y*3, a3);
printf("three:\n");
printarr(3, a3);
//looking for match
int l;
for (l=0; l<108; l++)
{
if (lines[l][6]!='=') {
parse3(lines[l],b3, b4);
if (match(3, a3, b3)==1) {
/*
printf("line > ");
printf(lines[l]);
printf("three2:\n");
printarr(3, b3);
printf("four2:\n");
printarr(4, b4);
printf("----\n\n");
*/
printf("match!\n");
copyto(4,20, b4, arr2,x*4,y*4);
break;
}
}
}
}
}
size = (size/3)*4;
}
return;
}
command_t
parse(arvore_vec* v)
{
if (v->size == 0)
{
fprintf(stderr, "Input is empty.\n");
exit(0);
}
if (DEBUG)
{
printf("-----------------------\n INITIAL\n-----------------------\n");
print_arvore_vec(v);
}
size_t i, j, k;
int started = 0;
// parse subshell
int has_sub = 0;
do
{
// find the longest subshell, skipping over any nested subshells
size_t paren_start = 0;
size_t paren_end = 0;
size_t open_count = 0;
started = 0;
for (i = 0; i < v->size; i++)
{
if (v->array[i].type == TOKEN_AT)
{
if (v->array[i].u.tok->type == OPEN_PAREN_TOKEN)
{
if (!started)
{
started = 1;
paren_start = i;
}
open_count++;
}
else if (v->array[i].u.tok->type == CLOSE_PAREN_TOKEN)
{
open_count--;
if (started && open_count == 0)
{
started = 0;
paren_end = i;
break;
}
}
}
}
if (open_count != 0)
error(1, 0, "Parenthesis do not match.");
// if there is a subshell, recursively parse the contents inside
if (paren_end > 0)
{
// copy the subsequence
arvore_vec* w;
size_t w_len = paren_end - paren_start + 1 - 2;
init_arvore_vec(&w, w_len);
for (i = 0; i < w_len; i++)
append_arvore_vec(w, v->array[paren_start + 1 + i]);
// parse the subsequence
command_t ss = parse(w);
// create the subshell command and replace the original tokens
arvore a;
a.type = COMMAND_AT;
a.u.cmd = (command_t) checked_malloc(sizeof(struct command));
a.u.cmd->input = NULL;
a.u.cmd->output = NULL;
a.u.cmd->type = SUBSHELL_COMMAND;
a.u.cmd->u.subshell_command = ss;
splice_arvore_vec(v, paren_start, w_len + 2, a);
has_sub = 1;
}
else
has_sub = 0;
}
while (has_sub);
if (DEBUG)
{
printf("-----------------------\n SUBSHELL\n-----------------------\n");
print_arvore_vec(v);
}
// parse simple commands
size_t cmd_start = 0;
size_t cmd_len = 0;
started = 0;
for (i = 0;
i <= v->size /* iterate one past to deal with file ending on a word */;
i++)
{
if (i < v->size && v->array[i].type == TOKEN_AT
&& v->array[i].u.tok->type == WORD_TOKEN)
{
// check it's not a IO redirect
if (i == 0
|| (v->array[i - 1].type == TOKEN_AT
&& v->array[i - 1].u.tok->type != L_REDIR_TOKEN
&& v->array[i - 1].u.tok->type != R_REDIR_TOKEN))
{
if (!started)
{
cmd_start = i;
started = 1;
}
if (started)
cmd_len++;
}
}
else if (started)
{
char** words = (char**) checked_malloc(sizeof(char*) * (cmd_len + 1));
for (j = 0; j < cmd_len; j++)
words[j] = v->array[cmd_start + j].u.tok->text;
words[cmd_len] = NULL;
command_t com = (command_t) checked_malloc(sizeof(struct command));
com->input = NULL;
com->output = NULL;
com->type = SIMPLE_COMMAND;
com->u.word = words;
arvore a;
a.type = COMMAND_AT;
a.u.cmd = com;
splice_arvore_vec(v, cmd_start, cmd_len, a);
cmd_len = 0;
i = cmd_start;
started = 0;
}
}
if (DEBUG)
{
printf(
"-----------------------\n SIMPLE COMMANDS\n-----------------------\n");
print_arvore_vec(v);
}
// parse IO redirects
for (i = 0; i < v->size; i++)
{
if (v->array[i].type == TOKEN_AT)
{
if (v->array[i].u.tok->type == L_REDIR_TOKEN
|| v->array[i].u.tok->type == R_REDIR_TOKEN)
{
// left side must be a command
if (i == 0 || v->array[i - 1].type == TOKEN_AT)
{
//printf("----------\n fail at %u\n----------\n", (unsigned int) i);
//print_arvore_vec(v);
error(1, 0, "Invalid input: IO redirection in wrong place.");
//exit(1);
}
// next token must be a word
if (i + 1 >= v->size || v->array[i + 1].type != TOKEN_AT
|| v->array[i + 1].u.tok->type != WORD_TOKEN)
{
//printf("----------\n fail at %u\n----------\n", (unsigned int) i);
//print_arvore_vec(v);
error(1, 0, "Invalid input: redirect source/destination invalid.");
//exit(1);
}
// store the redirect
if (v->array[i].u.tok->type == L_REDIR_TOKEN)
v->array[i - 1].u.cmd->input = v->array[i + 1].u.tok->text;
else
v->array[i - 1].u.cmd->output = v->array[i + 1].u.tok->text;
// delete the 2 tokens consumed
delete_arvore_vec(v, i);
delete_arvore_vec(v, i);
i--;
}
}
}
if (DEBUG)
{
printf(
"-----------------------\n IO REDIRECTS\n-----------------------\n");
print_arvore_vec(v);
}
// parse the rest
token_type pp = PIPE_TOKEN;
v = parse2(v, &pp, 1);
if (DEBUG)
{
printf("-----------------------\n PIPES\n-----------------------\n");
print_arvore_vec(v);
}
token_type and_n_ors[2] =
{ AND_TOKEN, OR_TOKEN };
v = parse2(v, and_n_ors, 2);
if (DEBUG)
{
printf("-----------------------\n ANDS & ORS\n-----------------------\n");
print_arvore_vec(v);
}
token_type nls_n_scs[2] =
{ NEWLINE_TOKEN, SEMICOLON_TOKEN };
v = parse2(v, nls_n_scs, 2);
if (DEBUG)
{
printf(
"-----------------------\n NEWLINE & SEMICOLONSs\n-----------------------\n");
print_arvore_vec(v);
}
return get_arvore_vec(v, 0).u.cmd;
}
arvore_vec*
parse2(arvore_vec *cmds_tokens, token_type* target_types, size_t num_targets)
{
size_t array_size = cmds_tokens->size;
arvore_vec *temp;
init_arvore_vec(&temp, array_size);
token_type curr_token_type;
size_t i, z, loc = array_size + 1;
for (i = 0; i < array_size; i++)
{
//look for delimiter, it can be either pipes, and or or
//once delimiter is found it splits the arvore vect into 2.
if (cmds_tokens->array[i].type == TOKEN_AT)
{
token_type tp = cmds_tokens->array[i].u.tok->type;
for (z = 0; z < num_targets; z++)
{
if (tp == target_types[z])
{
//location of first delim found
//location of delim = i;
loc = i;
curr_token_type = cmds_tokens->array[i].u.tok->type;
i = array_size;
break;
}
} //end if
}
} //end for
if (loc == 0)
{
error(1, 0, "Cannot start with a special token.");
//exit(1);
}
if (loc == array_size - 1)
{
error(1, 0, "Cannot end with a special token.");
//exit(1);
}
if (loc < array_size)
{
if (get_arvore_vec(cmds_tokens, loc - 1).type != COMMAND_AT)
error(1, 0, "Left hand side not a command.");
if (get_arvore_vec(cmds_tokens, loc + 1).type != COMMAND_AT)
error(1, 0, "Right hand side not a command.");
// create parent node
command_t left = get_arvore_vec(cmds_tokens, loc - 1).u.cmd;
command_t right = get_arvore_vec(cmds_tokens, loc + 1).u.cmd;
command_t new_cmd = (command_t) checked_malloc(sizeof(struct command));
new_cmd->input = NULL;
new_cmd->output = NULL;
if (curr_token_type == PIPE_TOKEN)
{
new_cmd->type = PIPE_COMMAND;
}
else if (curr_token_type == OR_TOKEN)
{
new_cmd->type = OR_COMMAND;
}
else if (curr_token_type == AND_TOKEN)
{
new_cmd->type = AND_COMMAND;
}
else if (curr_token_type == NEWLINE_TOKEN || curr_token_type == SEMICOLON_TOKEN)
{
new_cmd->type = SEQUENCE_COMMAND;
}
new_cmd->u.command[0] = left;
new_cmd->u.command[1] = right;
// copy unused arvores on the left
size_t j;
for (j = 0; j < loc - 1; j++)
append_arvore_vec(temp, get_arvore_vec(cmds_tokens, j));
// append command on left hand side
arvore a;
a.type = COMMAND_AT;
a.u.cmd = new_cmd;
append_arvore_vec(temp, a);
// copy unused arvores on the right
for (j = loc + 2; j < array_size; j++)
{
append_arvore_vec(temp, get_arvore_vec(cmds_tokens, j));
}
// recurse
return parse2(temp, target_types, num_targets);
}
// base case: return the only command left
return cmds_tokens;
}
/*
function to drink a potion
*/
void quaffpotion(int pot)
{
int i,j;
int k;
if (pot<0 || pot>=MAXPOTION)
return; /* check for within bounds */
/* first character of potion name starts off as \0. */
/* drinking a certain type of potion changes that to a space */
/* ...and from then on it is printable. */
/* if (potionname[pot][0] == '\0') */
/* potionname[pot][0] = ' '; */
if (potionknown[pot] == 0)
potionknown[pot] = 1;
lprintf("\nYou drink a potion of %s.", &potionname[pot][1]);
switch(pot) {
case PSLEEP:
lprcat(" You fall asleep...");
lflush();
i=rnd(11)-(c[CONSTITUTION]>>2)+2;
while(--i>0) {
parse2();
nap(1000);
}
cursors();
lprcat("\n.. you wake up.");
return;
case PHEALING:
lprcat(" You feel better.");
if (c[HP] == c[HPMAX])
raisemhp(1);
else if ((c[HP] += rnd(20)+20+c[LEVEL]) > c[HPMAX])
c[HP]=c[HPMAX];
break;
case PRAISELEVEL:
lprcat(" You feel much more skillful!");
raiselevel();
raisemhp(1);
return;
case PINCABILITY:
lprcat(" You feel strange for a moment.");
c[rund(6)]++;
break;
case PWISDOM:
lprcat(" You feel more self-confident!");
c[WISDOM] += rnd(2);
break;
case PSTRENGTH:
lprcat(" Wow! You feel great!");
if (c[STRENGTH]<12) c[STRENGTH]=12;
else c[STRENGTH]++;
break;
case PCHARISMA:
lprcat(" You feel charismatic!");
c[CHARISMA]++;
break;
case PDIZZINESS:
lprcat(" You become dizzy!");
if (--c[STRENGTH] < 3) c[STRENGTH]=3;
break;
case PLEARNING:
lprcat(" You feel clever!");
c[INTELLIGENCE]++;
break;
case PGOLDDET:
lprcat(" You feel greedy...");
lflush();
nap(2000);
for (i=0; i<MAXY; i++) for (j=0; j<MAXX; j++)
if ((item[j][i]==OGOLDPILE) || (item[j][i]==OMAXGOLD)) {
know[j][i]=1;
show1cell(j,i);
}
showplayer();
return;
case PMONSTDET:
for (i=0; i<MAXY; i++) for (j=0; j<MAXX; j++)
if (mitem[j][i].mon) {
know[j][i]=1;
show1cell(j,i);
}
return;
case PFORGETFUL:
lprcat(" You stagger for a moment...");
lflush();
for (i=0; i<MAXY; i++) for (j=0; j<MAXX; j++)
know[j][i]=0;
nap(2000);
draws(0,MAXX,0,MAXY);
return;
case PWATER:
return;
case PBLINDNESS:
lprcat(" You can't see anything!");
c[BLINDCOUNT]+=500; /* dang, that's a long time. */
/* erase the character, too! */
cursor(playerx+1,playery+1);
lprc(' ');
cursor(playerx+1,playery+1);
return;
case PCONFUSION:
lprcat(" You feel confused.");
c[CONFUSE]+= 20+rnd(9);
return;
case PHEROISM:
lprcat(" WOW! You feel fantastic!");
if (c[HERO]==0) for (i=0; i<6; i++) c[i] += 11;
c[HERO] += 250;
break;
case PSTURDINESS:
lprcat(" You feel healthier!");
c[CONSTITUTION]++;
break;
case PGIANTSTR:
lprcat(" You now have incredible bulging muscles!");
if (c[GIANTSTR]==0) c[STREXTRA] += 21;
c[GIANTSTR] += 700;
break;
case PFIRERESIST:
lprcat(" You feel a chill run up your spine!");
c[FIRERESISTANCE] += 1000;
break;
case PTREASURE:
lprcat(" You feel greedy...");
lflush();
nap(2000);
for (i=0; i<MAXY; i++) for (j=0; j<MAXX; j++) {
k=item[j][i];
if ((k==ODIAMOND) || (k==ORUBY) || (k==OEMERALD)
|| (k==OMAXGOLD) || (k==OSAPPHIRE)
|| (k==OLARNEYE) || (k==OGOLDPILE)) {
know[j][i]=1;
show1cell(j,i);
}
}
showplayer();
return;
case PINSTHEAL:
c[HP] = c[HPMAX];
removecurse();
break;
case PCUREDIANTH:
lprcat(" You don't seem to be affected.");
return;
case PPOISON:
lprcat(" You feel a sickness engulf you!");
c[HALFDAM] += 200 + rnd(200);
return;
case PSEEINVIS:
lprcat(" You feel your vision sharpen.");
c[SEEINVISIBLE] += rnd(1000)+400;
monstnamelist[INVISIBLESTALKER] = 'I';
return;
};
/* show new stats */
bottomline();
return;
}
