void search(const board_t * board, int depth_max, double time_max) { char string[256]; ASSERT(board_is_ok(board)); ASSERT(depth_max>=1&&depth_max<DepthMax); ASSERT(time_max>=0.0); // engine Depth = 0; BestMove = MoveNone; BestValue = 0; line_clear(BestPV); NodeNb = 0; LeafNb = 0; Time = 0.0; Move = MoveNone; MovePos = 0; MoveNb = 0; // init uci_send_ucinewgame(Uci); uci_send_isready_sync(Uci); // position if (!board_to_fen(board,string,256)) ASSERT(false); engine_send(Engine,"position fen %s",string); // search engine_send_queue(Engine,"go"); engine_send_queue(Engine," movetime %.0f",time_max*1000.0); engine_send_queue(Engine," depth %d",depth_max); engine_send(Engine,""); // newline // wait for feed-back while (true) { engine_get(Engine,string,256); if (false) { } else if (match(string,"bestmove * ponder *")) { BestMove = move_from_can(Star[0],board); ASSERT(BestMove!=MoveNone&&move_is_legal(BestMove,board)); break; } else if (match(string,"bestmove *")) { BestMove = move_from_can(Star[0],board); ASSERT(BestMove!=MoveNone&&move_is_legal(BestMove,board)); break; } } printf("\n"); }
double castelo_prior(SEXP beta, SEXP target, SEXP parents, SEXP children, int debuglevel) { int i = 0, k = 0, t = 0, nnodes = 0, cur_arc = 0; int nbeta = length(VECTOR_ELT(beta, 0)); int *temp = NULL, *aid = INTEGER(VECTOR_ELT(beta, 2)); double prior = 0, result = 0; double *bkwd = REAL(VECTOR_ELT(beta, 4)), *fwd = REAL(VECTOR_ELT(beta, 3)); short int *adjacent = NULL; SEXP nodes, try; /* get the node labels. */ nodes = getAttrib(beta, BN_NodesSymbol); nnodes = length(nodes); /* match the target node. */ PROTECT(try = match(nodes, target, 0)); t = INT(try); UNPROTECT(1); /* find out which nodes are parents and which nodes are children. */ adjacent = allocstatus(nnodes); PROTECT(try = match(nodes, parents, 0)); temp = INTEGER(try); for (i = 0; i < length(try); i++) adjacent[temp[i] - 1] = PARENT; UNPROTECT(1); PROTECT(try = match(nodes, children, 0)); temp = INTEGER(try); for (i = 0; i < length(try); i++) adjacent[temp[i] - 1] = CHILD; UNPROTECT(1); /* prior probabilities table lookup. */ for (i = t + 1; i <= nnodes; i++) { /* compute the arc id. */ cur_arc = UPTRI3(t, i, nnodes); /* look up the prior probability. */ for (/*k,*/ prior = ((double)1/3); k < nbeta; k++) { /* arcs are ordered, so we can stop early in the lookup. */ if (aid[k] > cur_arc) break; if (aid[k] == cur_arc) { switch(adjacent[i - 1]) { case PARENT: prior = bkwd[k]; break; case CHILD: prior = fwd[k]; break; default: prior = fmax2(0, 1 - bkwd[k] - fwd[k]); }/*SWITCH*/ break; }/*THEN*/ }/*FOR*/ if (debuglevel > 0) { switch(adjacent[i - 1]) { case PARENT: Rprintf(" > found arc %s -> %s, prior pobability is %lf.\n", NODE(i - 1), NODE(t - 1), prior); break; case CHILD: Rprintf(" > found arc %s -> %s, prior probability is %lf.\n", NODE(t - 1), NODE(i - 1), prior); break; default: Rprintf(" > no arc between %s and %s, prior probability is %lf.\n", NODE(t - 1), NODE(i - 1), prior); }/*SWITCH*/ }/*THEN*/ /* move to log-scale and divide by the non-informative log(1/3), so that * the contribution of each arc whose prior has not been specified by the * user is zero; overflow is likely otherwise. */ result += log(prior / ((double)1/3)); }/*FOR*/ return result; }/*CASTELO_PRIOR*/ /* complete a prior as per Castelo & Siebes. */ SEXP castelo_completion(SEXP prior, SEXP nodes, SEXP learning) { int i = 0, k = 0, cur = 0, narcs1 = 0, narcs2 = 0, nnodes = length(nodes); int *m1 = NULL, *m2 = NULL, *und = NULL, *aid = NULL, *poset = NULL, *id = NULL; double *d1 = NULL, *d2 = NULL, *p = NULL; SEXP df, arc_id, undirected, a1, a2, match1, match2, prob; SEXP result, from, to, nid, dir1, dir2; /* compute numeric IDs for the arcs. */ a1 = VECTOR_ELT(prior, 0); a2 = VECTOR_ELT(prior, 1); narcs1 = length(a1); PROTECT(match1 = match(nodes, a1, 0)); PROTECT(match2 = match(nodes, a2, 0)); m1 = INTEGER(match1); m2 = INTEGER(match2); PROTECT(arc_id = allocVector(INTSXP, narcs1)); aid = INTEGER(arc_id); c_arc_hash(narcs1, nnodes, m1, m2, aid, NULL, FALSE); /* duplicates correspond to undirected arcs. */ PROTECT(undirected = dupe(arc_id)); und = INTEGER(undirected); /* extract the components from the prior. */ prob = VECTOR_ELT(prior, 2); p = REAL(prob); /* count output arcs. */ for (i = 0; i < narcs1; i++) narcs2 += 2 - und[i]; narcs2 /= 2; /* allocate the columns of the return value. */ PROTECT(from = allocVector(STRSXP, narcs2)); PROTECT(to = allocVector(STRSXP, narcs2)); PROTECT(nid = allocVector(INTSXP, narcs2)); id = INTEGER(nid); PROTECT(dir1 = allocVector(REALSXP, narcs2)); d1 = REAL(dir1); PROTECT(dir2 = allocVector(REALSXP, narcs2)); d2 = REAL(dir2); /* sort the strength coefficients. */ poset = alloc1dcont(narcs1); for (k = 0; k < narcs1; k++) poset[k] = k; R_qsort_int_I(aid, poset, 1, narcs1); for (i = 0, k = 0; i < narcs1; i++) { cur = poset[i]; #define ASSIGN(A1, A2, D1, D2) \ SET_STRING_ELT(from, k, STRING_ELT(A1, cur)); \ SET_STRING_ELT(to, k, STRING_ELT(A2, cur)); \ id[k] = aid[i]; \ D1[k] = p[cur]; \ if ((und[cur] == TRUE) && (i < narcs1 - 1)) \ D2[k] = p[poset[++i]]; \ else \ D2[k] = (1 - D1[k])/2; /* copy the node labels. */ if (m1[cur] < m2[cur]) { ASSIGN(a1, a2, d1, d2); }/*THEN*/ else { ASSIGN(a2, a1, d2, d1); }/*ELSE*/ /* check the probabilities do not exceed 1; fail only for large errors. */ if (d1[k] + d2[k] > 1) { if (d1[k] + d2[k] < 1 + 2 * MACHINE_TOL) { d1[k] = d1[k] / (d1[k] + d2[k]); d2[k] = d2[k] / (d1[k] + d2[k]); }/*THEN*/ else { UNPROTECT(9); error("the probabilities for arc %s -> %s sum to %lf.", CHAR(STRING_ELT(from, k)), CHAR(STRING_ELT(to, k)), d1[k] + d2[k]); }/*ELSE*/ }/*THEN*/ /* bound the probability of not including an arc away from zero, structure * learning otherwise fails when starting from the empty graph and gets * stuck very easily in general. */ if (isTRUE(learning) && (fabs(1 - d1[k] - d2[k]) < MACHINE_TOL)) { d1[k] = d1[k] - MACHINE_TOL; d2[k] = d2[k] - MACHINE_TOL; }/*THEN*/ /* move to the next arc. */ k++; }/*FOR*/ /* set up the return value. */ PROTECT(result = allocVector(VECSXP, 5)); SET_VECTOR_ELT(result, 0, from); SET_VECTOR_ELT(result, 1, to); SET_VECTOR_ELT(result, 2, nid); SET_VECTOR_ELT(result, 3, dir1); SET_VECTOR_ELT(result, 4, dir2); setAttrib(result, R_NamesSymbol, mkStringVec(5, "from", "to", "aid", "fwd", "bkwd")); PROTECT(df = minimal_data_frame(result)); UNPROTECT(11); return df; }/*CASTELO_COMPLETION*/
/** Interpret \a client as a client specifier and show which Client * block(s) match that client. * * The client specifier may contain an IP address, hostname, listener * port, or a combination of those separated by commas. IP addresses * and hostnamese may be preceded by "username@"; the last given * username will be used for the match. * * @param[in] client Client specifier. * @return Matching Client block structure. */ struct ConfItem *conf_debug_iline(const char *client) { struct irc_in_addr address; struct ConfItem *aconf; struct DenyConf *deny; char *sep; unsigned short listener; char username[USERLEN+1], hostname[HOSTLEN+1], realname[REALLEN+1]; /* Initialize variables. */ listener = 0; memset(&address, 0, sizeof(address)); memset(&username, 0, sizeof(username)); memset(&hostname, 0, sizeof(hostname)); memset(&realname, 0, sizeof(realname)); /* Parse client specifier. */ while (*client) { struct irc_in_addr tmpaddr; long tmp; /* Try to parse as listener port number first. */ tmp = strtol(client, &sep, 10); if (tmp && (*sep == '\0' || *sep == ',')) { listener = tmp; client = sep + (*sep != '\0'); continue; } /* Maybe username@ before an IP address or hostname? */ tmp = strcspn(client, ",@"); if (client[tmp] == '@') { if (tmp > USERLEN) tmp = USERLEN; ircd_strncpy(username, client, tmp); /* and fall through */ client += tmp + 1; } /* Looks like an IP address? */ tmp = ircd_aton(&tmpaddr, client); if (tmp && (client[tmp] == '\0' || client[tmp] == ',')) { memcpy(&address, &tmpaddr, sizeof(address)); client += tmp + (client[tmp] != '\0'); continue; } /* Realname? */ if (client[0] == '$' && client[1] == 'R') { client += 2; for (tmp = 0; *client != '\0' && *client != ',' && tmp < REALLEN; ++client, ++tmp) { if (*client == '\\') realname[tmp] = *++client; else realname[tmp] = *client; } continue; } /* Else must be a hostname. */ tmp = strcspn(client, ","); if (tmp > HOSTLEN) tmp = HOSTLEN; ircd_strncpy(hostname, client, tmp); client += tmp + (client[tmp] != '\0'); } /* Walk configuration to find matching Client block. */ for (aconf = GlobalConfList; aconf; aconf = aconf->next) { if (aconf->status != CONF_CLIENT) continue; if (aconf->address.port && aconf->address.port != listener) { fprintf(stdout, "Listener port mismatch: %u != %u\n", aconf->address.port, listener); continue; } if (aconf->username && match(aconf->username, username)) { fprintf(stdout, "Username mismatch: %s != %s\n", aconf->username, username); continue; } if (aconf->host && match(aconf->host, hostname)) { fprintf(stdout, "Hostname mismatch: %s != %s\n", aconf->host, hostname); continue; } if ((aconf->addrbits >= 0) && !ipmask_check(&address, &aconf->address.addr, aconf->addrbits)) { fprintf(stdout, "IP address mismatch: %s != %s\n", aconf->name, ircd_ntoa(&address)); continue; } fprintf(stdout, "Match! username=%s host=%s ip=%s class=%s maxlinks=%u password=%s\n", (aconf->username ? aconf->username : "******"), (aconf->host ? aconf->host : "(null)"), (aconf->name ? aconf->name : "(null)"), ConfClass(aconf), aconf->maximum, (aconf->passwd ? aconf->passwd : "(null)")); break; } /* If no authorization, say so and exit. */ if (!aconf) { fprintf(stdout, "No authorization found.\n"); return NULL; } /* Look for a Kill block with the user's name on it. */ for (deny = denyConfList; deny; deny = deny->next) { if (deny->usermask && match(deny->usermask, username)) continue; if (deny->realmask && match(deny->realmask, realname)) continue; if (deny->bits > 0) { if (!ipmask_check(&address, &deny->address, deny->bits)) continue; } else if (deny->hostmask && match(deny->hostmask, hostname)) continue; /* Looks like a match; report it. */ fprintf(stdout, "Denied! usermask=%s realmask=\"%s\" hostmask=%s (bits=%u)\n", deny->usermask ? deny->usermask : "(null)", deny->realmask ? deny->realmask : "(null)", deny->hostmask ? deny->hostmask : "(null)", deny->bits); } return aconf; }
static mowgli_node_t *charybdis_next_matching_ban(channel_t *c, user_t *u, int type, mowgli_node_t *first) { chanban_t *cb; mowgli_node_t *n; char hostbuf[NICKLEN+USERLEN+HOSTLEN]; char realbuf[NICKLEN+USERLEN+HOSTLEN]; char ipbuf[NICKLEN+USERLEN+HOSTLEN]; char strippedmask[NICKLEN+USERLEN+HOSTLEN+CHANNELLEN+2]; char *p; bool negate, matched; int exttype; channel_t *target_c; snprintf(hostbuf, sizeof hostbuf, "%s!%s@%s", u->nick, u->user, u->vhost); snprintf(realbuf, sizeof realbuf, "%s!%s@%s", u->nick, u->user, u->host); /* will be nick!user@ if ip unknown, doesn't matter */ snprintf(ipbuf, sizeof ipbuf, "%s!%s@%s", u->nick, u->user, u->ip); MOWGLI_ITER_FOREACH(n, first) { cb = n->data; if (cb->type != type) continue; /* * strip any banforwards from the mask. (SRV-73) * charybdis itself doesn't support banforward but i don't feel like copying * this stuff into ircd-seven and it is possible that charybdis may support them * one day. * --nenolod */ mowgli_strlcpy(strippedmask, cb->mask, sizeof strippedmask); p = strrchr(strippedmask, '$'); if (p != NULL && p != strippedmask) *p = 0; if ((!match(strippedmask, hostbuf) || !match(strippedmask, realbuf) || !match(strippedmask, ipbuf) || !match_cidr(strippedmask, ipbuf))) return n; if (strippedmask[0] == '$') { p = strippedmask + 1; negate = *p == '~'; if (negate) p++; exttype = *p++; if (exttype == '\0') continue; /* check parameter */ if (*p++ != ':') p = NULL; switch (exttype) { case 'a': matched = u->myuser != NULL && !(u->myuser->flags & MU_WAITAUTH) && (p == NULL || !match(p, entity(u->myuser)->name)); break; case 'c': if (p == NULL) continue; target_c = channel_find(p); if (target_c == NULL || (target_c->modes & (CMODE_PRIV | CMODE_SEC))) continue; matched = chanuser_find(target_c, u) != NULL; break; case 'o': matched = is_ircop(u); break; case 'r': if (p == NULL) continue; matched = !match(p, u->gecos); break; case 's': if (p == NULL) continue; matched = !match(p, u->server->name); break; case 'x': if (p == NULL) continue; matched = extgecos_match(p, u); break; default: continue; } if (negate ^ matched) return n; } }
void match(QNFAMatchContext *lexer, const QChar *d, int length, QNFAMatchNotifier notify) { if ( !lexer || !lexer->context ) { //qWarning("get off you scum!"); return; } // restore message buffering notify.clear(); int olvls = lexer->parents.count(), nlvls = 0, lvls = olvls; if ( lvls ) notify.startBuffering(); // quint16 c = 0; const QChar *di = d; QNFA *chain = 0, *start = 0; int index = 0, lastCxt = 0, len, idx; bool bFound, bEscape = false, bEscaped = false; bool wPrev = false, wCur = false; while ( index < length ) { bFound = false; bEscaped = false; //bEscape &= !lexer->meaningless.contains(d[index].unicode()); //while ( lexer->meaningless.contains(d[index].unicode()) && ((index + 1) < length) ) // ++index; if ( index >= length ) break; c = di->unicode(); wCur = isWord(*di); int plainIndex = -1, plainMatch, plainLength; // try fast plain matching if ( !(wPrev && wCur) ) { //qDebug("trying plain..."); //len = 0; idx = index; QCharTree::const_iterator it, match, end; it = lexer->context->tree.constFind(c); if ( it != lexer->context->tree.constEnd() ) { //qDebug("plain on %c", c); do { ++di; ++idx; end = it->next.constEnd(); match = it->next.constFind(0); if ( idx < length ) { c = di->unicode(); it = it->next.constFind(c); } else { it = end; } if ( it == end ) { if ( (match != end) && !isWord(*di) ) { //word boundary found // corresponding token end found wPrev = isWord(*(di - 1)); bFound = true; if ( match->value.action & 0x40000000 ) { // try regexps before notifying plainIndex = index; plainLength = idx - index; plainMatch = match->value.action; //qDebug("ambiguity."); } else { notify(index, idx - index, match->value.action); index = idx; } //qDebug("next step : %c", d[index].toLatin1()); //bMonitor = true; } break; } } while ( idx < length ) ; if ( bFound ) { bEscape = false; if ( plainIndex == -1 ) continue; bFound = false; } di -= idx - index; } } // fallback on regexp-like NFA-based matching QNFABranch* children = lexer->context->out.branch; if ( children ) { //qDebug("trying %i sub nfas on %c", children->count(), d[index].toLatin1()); int max = children->count(); for ( quint16 i = 0; i < max; ++i ) { len = 0; idx = index; start = chain = children->at(i); //qDebug("%ith attempt on %c", i, d[index + len].toLatin1()); while ( (idx < length) || (chain->type & Match) ) { bEscaped = false; if ( chain->type & Match ) { if ( (chain->assertion & WordEnd) && (idx < length) && isWord(*di) && isWord(*(di - 1)) ) { //qDebug("end assertion failed..."); break; } //qDebug("matched to end"); if ( chain->type & CxtBeg ) { //qDebug("entering context : 0x%x", chain); ++nlvls; bool notifySub = notify.bufferLevel(); if ( notifySub ) { // pop one message buffer notify.stopBuffering(); } // notify content of previous context until nest notify(lastCxt, index - lastCxt, lexer->context->actionid | 0x80000000); if ( notifySub ) { // notify sub matches so far to avoid tricky handling later on notify.flush(); //notify.startBuffering(); } // notify begin marker notify(index, len, start->actionid ? start->actionid : chain->actionid); // update context stack lexer->parents.push(lexer->context); lexer->context = chain; // update nest index lastCxt = idx; // push a message buffer notify.startBuffering(); } else if ( chain->type & CxtEnd ) { //qDebug("leaving context :"); if ( lexer->parents.isEmpty() ) qFatal("context nesting problem"); if ( bEscape ) { // not really end : escape found... bEscape = false; bEscaped = true; } else { if ( nlvls ) --nlvls; else --lvls; // pop one message buffer notify.stopBuffering(); // notify context content from last nest notify(lastCxt, index - lastCxt, lexer->context->actionid | 0x80000000); // flush sub matches notify.flush(); // update context stack lexer->context = lexer->parents.pop(); if ( lexer->parents.count() ) notify.startBuffering(); // update nest index lastCxt = idx; // notify end marker notify(index, len, chain->actionid); //qDebug("cxt notif..."); if ( chain->type & Exclusive ) index = idx; --index; --di; bFound = true; break; } } else if ( chain->type & CxtEsc ) { //qDebug("matched %s", qPrintable(QString(index, len))); //notify(index, len, chain->actionid); bEscape = !bEscape; } else { //qDebug("matched %s", qPrintable(QString(d + index, len))); if ( plainIndex != -1 && plainLength >= len ) { break; } notify(index, len, chain->actionid); bEscape = false; } bFound = true; index = idx; --index; --di; //qDebug("next step : %c", d[index + 1].toLatin1()); //bMonitor = true; break; } else { // "regular" nfa match (no match yet...) if ( (chain->assertion & WordStart) && (idx >= 1) && ( isWord(*(di - 1)) && isWord(*di) ) ) { //qDebug("beg assertion failed..."); break; } QChar cc = *di; bool found = match(cc, chain); if ( !(chain->assertion & ZeroOrOne) && !(chain->assertion & ZeroOrMore) && !found ) { //if ( cc.toLatin1() == ')' ) // qDebug("mismatch : %c != %c", cc.toLatin1(), chain->c.at(0)); break; } if ( found ) { //qDebug("%c", d[index + len].toLatin1()); if ( (chain->assertion & OneOrMore) || (chain->assertion & ZeroOrMore) ) { do { ++di; ++len; ++idx; } while ( (idx < length) && match(*di, chain) ); } else { ++len; ++idx; ++di; } } else { //qDebug("! %c", d[index + len].toLatin1()); } chain = chain->out.next; } } if ( bFound ) break; di -= len; } } if ( !bFound ) { if ( plainIndex != -1 ) { notify(plainIndex, plainLength, plainMatch); index = plainIndex + plainLength; di += plainLength; continue; } bEscape = false; //++index; wPrev = wCur; } else { wPrev = isWord(*di); } ++index; ++di; } // flush messages if ( !notify.bufferLevel() ) return; //qDebug("%i context nests", notify.bufferLevel()); //qDebug("[%i;+00[ : 0x%x", lastCxt, lexer->context->actionid | 0x80000000); // pop down one buffer notify.stopBuffering(); // notify overlapping context so far notify(lastCxt, length - lastCxt, lexer->context->actionid | 0x80000000); // notify sub matches notify.flush(); // make sure we leave a blank notifier... notify.clear(); // preserve escape power... if ( bEscaped ) return; // some existing left AND new one(s) if ( (olvls == lvls) && nlvls ) ++lvls; // close stay-on-line contexts, if any QStack<QNFA*>::iterator it = lexer->parents.begin() + lvls; while ( it != lexer->parents.end() ) { if ( (*it)->type & StayOnLine ) { //qDebug("staid..."); it = lexer->parents.erase(it); } else { ++it; } } if ( (lexer->context->type & StayOnLine) && nlvls && lexer->parents.count() ) lexer->context = lexer->parents.pop(); }
static void process() { /* Loop through the program text, looking for patterns. */ int c, i, left = 0; line_nr = 1; c = get(FALSE); for (;;) { if (c == EOF) { break; } else if (c == '\'' || c == '"' || c == '`') { emit(c); string(c, FALSE); c = 0; /* The most complicated case is the slash. It can mean division or a regexp literal or a line comment or a block comment. A block comment can also be a pattern to be expanded. */ } else if (c == '/') { /* A slash slash comment skips to the end of the file. */ if (peek() == '/') { emit('/'); for (;;) { c = get(TRUE); if (c == '\n' || c == '\r' || c == EOF) { break; } } c = get(FALSE); /* The first component of a slash star comment might be the tag. */ } else { if (peek() == '*') { get(FALSE); for (i = 0; i < MAX_TAG_LENGTH; i += 1) { c = get(FALSE); if (!is_alphanum(c)) { break; } tag[i] = (char)c; } tag[i] = 0; unget(c); /* Did the tag match something? */ i = (i == 0) ? -1 : match(); if (i >= 0) { expand(i); c = get(FALSE); } else { /* If the tag didn't match, then echo the comment. */ emits("/*"); emits(tag); for (;;) { if (c == EOF) { error("unterminated comment."); } if (c == '/') { c = get(TRUE); if (c == '*') { error("nested comment."); } } else if (c == '*') { c = get(TRUE); if (c == '/') { break; } } else { c = get(TRUE); } } c = get(FALSE); } } else { emit('/'); /* We are looking at a single slash. Is it a division operator, or is it the start of a regexp literal? It is not possible to tell for sure without doing a complete parse of the program, and we are not going to do that. Instead, we are adopting the convention that a regexp literal must have one of a small set of characters to its left. */ if (pre_regexp(left)) { regexp(FALSE); } left = '/'; c = get(FALSE); } } } else { /* The character was nothing special, so just echo it. If it wasn't whitespace, remember it as the character to the left of the next character. */ emit(c); if (c > ' ') { left = c; } c = get(FALSE); } } }
static const char *match (MatchState *ms, const char *s, const char *p) { if (ms->matchdepth-- == 0) luaL_error(ms->L, "pattern too complex"); init: /* using goto's to optimize tail recursion */ if (p != ms->p_end) { /* end of pattern? */ switch (*p) { case '(': { /* start capture */ if (*(p + 1) == ')') /* position capture? */ s = start_capture(ms, s, p + 2, CAP_POSITION); else s = start_capture(ms, s, p + 1, CAP_UNFINISHED); break; } case ')': { /* end capture */ s = end_capture(ms, s, p + 1); break; } case '$': { if ((p + 1) != ms->p_end) /* is the `$' the last char in pattern? */ goto dflt; /* no; go to default */ s = (s == ms->src_end) ? s : NULL; /* check end of string */ break; } case L_ESC: { /* escaped sequences not in the format class[*+?-]? */ switch (*(p + 1)) { case 'b': { /* balanced string? */ s = matchbalance(ms, s, p + 2); if (s != NULL) { p += 4; goto init; /* return match(ms, s, p + 4); */ } /* else fail (s == NULL) */ break; } case 'f': { /* frontier? */ const char *ep; char previous; p += 2; if (*p != '[') luaL_error(ms->L, "missing " LUA_QL("[") " after " LUA_QL("%%f") " in pattern"); ep = classend(ms, p); /* points to what is next */ previous = (s == ms->src_init) ? '\0' : *(s - 1); if (!matchbracketclass(uchar(previous), p, ep - 1) && matchbracketclass(uchar(*s), p, ep - 1)) { p = ep; goto init; /* return match(ms, s, ep); */ } s = NULL; /* match failed */ break; } case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': { /* capture results (%0-%9)? */ s = match_capture(ms, s, uchar(*(p + 1))); if (s != NULL) { p += 2; goto init; /* return match(ms, s, p + 2) */ } break; } default: goto dflt; } break; } default: dflt: { /* pattern class plus optional suffix */ const char *ep = classend(ms, p); /* points to optional suffix */ /* does not match at least once? */ if (!singlematch(ms, s, p, ep)) { if (*ep == '*' || *ep == '?' || *ep == '-') { /* accept empty? */ p = ep + 1; goto init; /* return match(ms, s, ep + 1); */ } else /* '+' or no suffix */ s = NULL; /* fail */ } else { /* matched once */ switch (*ep) { /* handle optional suffix */ case '?': { /* optional */ const char *res; if ((res = match(ms, s + 1, ep + 1)) != NULL) s = res; else { p = ep + 1; goto init; /* else return match(ms, s, ep + 1); */ } break; } case '+': /* 1 or more repetitions */ s++; /* 1 match already done */ /* go through */ case '*': /* 0 or more repetitions */ s = max_expand(ms, s, p, ep); break; case '-': /* 0 or more repetitions (minimum) */ s = min_expand(ms, s, p, ep); break; default: /* no suffix */ s++; p = ep; goto init; /* return match(ms, s + 1, ep); */ } } break; } } } ms->matchdepth++; return s; }
void JudgeTask::doRun() { ILogger *logger = LoggerFactory::getLogger(LoggerId::AppInitLoggerId); OJString infoBuffer; FormatString(infoBuffer, OJStr("[JudgeTask] task %d"), Input.SolutionID); logger->logInfo(infoBuffer); //编译 if(!compile()) { return; } //搜索测试数据 OJString path; FormatString(path, OJStr("%s/%d"), AppConfig::Path::TestDataPath.c_str(), Input.ProblemID); DebugMessage(OJStr("[JudgeTask] %d search path: %s"), Input.SolutionID, path.c_str()); //TODO: 根据是否specialJudge,决定搜索.out还是.in文件。 FileTool::FileNameList fileList; FileTool::GetSpecificExtFiles(fileList, path, OJStr(".out"), true); OJUInt32_t testCount = fileList.size(); if(testCount <= 0)//没有测试数据 { output_.Result = AppConfig::JudgeCode::SystemError; FormatString(infoBuffer, OJStr("[JudgeTask] not found test data for solution %d problem %d."), Input.SolutionID, Input.ProblemID); logger->logError(infoBuffer); return; } //测试多组数据 OJUInt32_t accepted = 0; for(OJUInt32_t i=0; i<testCount; ++i) { answerOutputFile_ = fileList[i]; answerInputFile_ = FileTool::RemoveFileExt(answerOutputFile_); answerInputFile_ += OJStr(".in"); DebugMessage(OJStr("[JudgeTask] %d input file: %s"), Input.SolutionID, answerInputFile_.c_str()); DebugMessage(OJStr("[JudgeTask] %d output file: %s"), Input.SolutionID, answerOutputFile_.c_str()); if(!safeRemoveFile(userOutputFile_)) { output_.Result = AppConfig::JudgeCode::SystemError; break; } if(!excute()) { break; } if(!match()) { break; } ++accepted; } output_.PassRate = float(accepted)/testCount; }
static const char * match(MatchState * ms, const char *s, const char *p) { init: /* using goto's to optimize tail recursion */ switch (*p) { case '(': { /* start capture */ if (*(p + 1) == ')') /* position capture? */ return start_capture(ms, s, p + 2, CAP_POSITION); else return start_capture(ms, s, p + 1, CAP_UNFINISHED); } case ')': { /* end capture */ return end_capture(ms, s, p + 1); } case ESC: { switch (*(p + 1)) { case 'b': { /* balanced string? */ s = matchbalance(ms, s, p + 2); if (s == NULL) return NULL; p += 4; goto init; /* else return match(ms, s, p+4); */ } case 'f': { /* frontier? */ const char *ep; char previous; p += 2; if (*p != '[') luaL_error(ms->L, "missing `[' after `%%f' in pattern"); ep = luaI_classend(ms, p); /* points to what is next */ previous = (s == ms->src_init) ? '\0' : *(s - 1); if (matchbracketclass(uchar(previous), p, ep - 1) || !matchbracketclass(uchar(*s), p, ep - 1)) return NULL; p = ep; goto init; /* else return match(ms, s, ep); */ } default: { if (isdigit(uchar(*(p + 1)))) { /* capture results (%0-%9)? */ s = match_capture(ms, s, *(p + 1)); if (s == NULL) return NULL; p += 2; goto init; /* else return match(ms, s, p+2) */ } goto dflt; /* case default */ } } } case '\0': { /* end of pattern */ return s; /* match succeeded */ } case '$': { if (*(p + 1) == '\0') /* is the `$' the last char in pattern? */ return (s == ms->src_end) ? s : NULL; /* check end of string */ else goto dflt; } default: dflt:{ /* it is a pattern item */ const char *ep = luaI_classend(ms, p); /* points to what is next */ int m = s < ms->src_end && luaI_singlematch(uchar(*s), p, ep); switch (*ep) { case '?': { /* optional */ const char *res; if (m && ((res = match(ms, s + 1, ep + 1)) != NULL)) return res; p = ep + 1; goto init; /* else return match(ms, s, ep+1); */ } case '*': { /* 0 or more repetitions */ return max_expand(ms, s, p, ep); } case '+': { /* 1 or more repetitions */ return (m ? max_expand(ms, s + 1, p, ep) : NULL); } case '-': { /* 0 or more repetitions (minimum) */ return min_expand(ms, s, p, ep); } default: { if (!m) return NULL; s++; p = ep; goto init; /* else return match(ms, s+1, ep); */ } } } } }
static mowgli_node_t *inspircd_next_matching_ban(channel_t *c, user_t *u, int type, mowgli_node_t *first) { chanban_t *cb; mowgli_node_t *n; char hostbuf[NICKLEN+USERLEN+HOSTLEN]; char realbuf[NICKLEN+USERLEN+HOSTLEN]; char ipbuf[NICKLEN+USERLEN+HOSTLEN]; char *p; snprintf(hostbuf, sizeof hostbuf, "%s!%s@%s", u->nick, u->user, u->vhost); snprintf(realbuf, sizeof realbuf, "%s!%s@%s", u->nick, u->user, u->host); /* will be nick!user@ if ip unknown, doesn't matter */ snprintf(ipbuf, sizeof ipbuf, "%s!%s@%s", u->nick, u->user, u->ip); MOWGLI_ITER_FOREACH(n, first) { channel_t *target_c; cb = n->data; if (cb->type != type) continue; if ((!match(cb->mask, hostbuf) || !match(cb->mask, realbuf) || !match(cb->mask, ipbuf)) || !match_cidr(cb->mask, ipbuf)) return n; if (cb->mask[1] == ':' && strchr("MRUjrm", cb->mask[0])) { bool matched = false; p = cb->mask + 2; if (*(p - 1) != ':') p = NULL; switch (cb->mask[0]) { case 'M': case 'R': matched = u->myuser != NULL && !(u->myuser->flags & MU_WAITAUTH) && (p == NULL || !match(p, entity(u->myuser)->name)); break; case 'U': matched = u->myuser == NULL; break; case 'j': if (p == NULL) continue; target_c = channel_find(p); if (target_c == NULL || (target_c->modes & (CMODE_PRIV | CMODE_SEC))) continue; matched = chanuser_find(target_c, u) != NULL; break; case 'r': if (p == NULL) continue; matched = !match(p, u->gecos); break; case 'm': matched = (!match(p, hostbuf) || !match(p, realbuf) || !match(p, ipbuf)) || !match_cidr(p, ipbuf); break; default: continue; } if (matched) return n; } }
int m_stats(struct Client *cptr, struct Client *sptr, int parc, char *parv[]) { struct Message* mptr; struct Client* acptr; char l_stat = parc > 1 ? parv[1][0] : '\0'; int i; int doall = 0; int wilds = 0; int ignore_request = 0; int valid_stats = 0; char* name; char *mename = me.name; if(sptr->user && sptr->user->vlink) mename = sptr->user->vlink->name; if(!IsClient(sptr)) { return 0; } if(!IsAnOper(sptr)) { sendto_one(sptr, form_str(ERR_NOPRIVILEGES), mename, parv[0]); return -1; } if (hunt_server(cptr,sptr,":%s STATS %s :%s",2,parc,parv)!=HUNTED_ISME) return 0; if (parc > 2) { name = parv[2]; if (!irccmp(name, mename)) doall = 2; else if (match(name, mename)) doall = 1; if (strchr(name, '*') || strchr(name, '?')) wilds = 1; } else name = mename; switch (l_stat) { case 'L' : case 'l' : /* * send info about connections which match, or all if the * mask matches mename. Only restrictions are on those who * are invisible not being visible to 'foreigners' who use * a wild card based search to list it. */ for (i = 0; i <= highest_fd; i++) { if (!(acptr = local[i])) continue; if (!doall && wilds && !match(name, acptr->name)) continue; if (!(doall || wilds) && irccmp(name, acptr->name)) continue; /* I've added a sanity test to the "CurrentTime - acptr->since" * occasionally, acptr->since is larger than CurrentTime. * The code in parse.c "randomly" increases the "since", * which means acptr->since is larger then CurrentTime at times, * this gives us very high odd number.. * So, I am going to return 0 for ->since if this happens. * - Dianora */ /* trust opers not on this server */ /* if(IsAnOper(sptr)) */ /* Don't trust opers not on this server */ #ifdef HIDE_SERVERS_IPS if(MyClient(sptr) && IsAnOper(sptr) && !IsServer(acptr) && !IsConnecting(acptr) && !IsHandshake(acptr)) #else if(MyClient(sptr) && IsAnOper(sptr)) #endif { sendto_one(sptr, Lformat, mename, RPL_STATSLINKINFO, parv[0], get_client_name(acptr, TRUE), (int)DBufLength(&acptr->sendQ), (int)acptr->sendM, (int)acptr->sendK, (int)acptr->receiveM, (int)acptr->receiveK, CurrentTime - acptr->firsttime, (CurrentTime > acptr->since) ? (CurrentTime - acptr->since):0, IsServer(acptr) ? show_capabilities(acptr) : "-"); } else { if(IsServer(acptr)) sendto_one(sptr, Lformat, mename, RPL_STATSLINKINFO, parv[0], get_client_name(acptr, HIDEME), (int)DBufLength(&acptr->sendQ), (int)acptr->sendM, (int)acptr->sendK, (int)acptr->receiveM, (int)acptr->receiveK, CurrentTime - acptr->firsttime, (CurrentTime > acptr->since) ? (CurrentTime - acptr->since):0, IsServer(acptr) ? show_capabilities(acptr) : "-"); else sendto_one(sptr, Lformat, mename, RPL_STATSLINKINFO, parv[0], (IsUpper(lstat)) ? get_client_name(acptr, TRUE) : get_client_name(acptr, FALSE), (int)DBufLength(&acptr->sendQ), (int)acptr->sendM, (int)acptr->sendK, (int)acptr->receiveM, (int)acptr->receiveK, CurrentTime - acptr->firsttime, (CurrentTime > acptr->since) ? (CurrentTime - acptr->since):0, IsServer(acptr) ? show_capabilities(acptr) : "-"); } } valid_stats++; break; case 'C' : case 'c' : report_configured_links(sptr, CONF_CONNECT_SERVER|CONF_NOCONNECT_SERVER); valid_stats++; break; case 'B' : case 'b' : sendto_one(sptr,":%s NOTICE %s :Use stats I instead", mename, parv[0]); break; case 'D': report_dlines(sptr); valid_stats++; break; case 'd': report_domain_stats(sptr); valid_stats++; break; case 'E' : case 'e' : sendto_one(sptr,":%s NOTICE %s :Use stats I instead", mename, parv[0]); break; case 'F' : case 'f' : report_channel_stats(sptr); break; case 'g' : report_sxlines(sptr); valid_stats++; break; case 'G' : report_glines(sptr, NULL); valid_stats++; break; case 'H' : case 'h' : report_configured_links(sptr, CONF_HUB|CONF_LEAF); valid_stats++; break; case 'i' : report_vlinks(sptr); valid_stats++; break; case 'I' : report_mtrie_conf_links(sptr, CONF_CLIENT); valid_stats++; break; case 'k' : report_temp_klines(sptr); valid_stats++; break; case 'K' : if(parc > 3) report_matching_host_klines(sptr,parv[3]); else report_mtrie_conf_links(sptr, CONF_KILL); valid_stats++; break; case 'M' : case 'm' : for (mptr = msgtab; mptr->cmd; mptr++) sendto_one(sptr, form_str(RPL_STATSCOMMANDS), mename, parv[0], mptr->cmd, mptr->count, mptr->bytes); valid_stats++; break; case 'o' : case 'O' : report_configured_links(sptr, CONF_OPS); valid_stats++; break; case 'P' : show_ports(sptr); valid_stats++; break; case 'p' : show_opers(sptr); valid_stats++; break; case 'Q' : report_qlines(sptr); valid_stats++; break; case 'q' : report_sqlines(sptr); valid_stats++; break; case 'R' : case 'r' : send_usage(sptr,parv[0]); valid_stats++; break; case 'S' : list_scache(cptr,sptr,parc,parv); valid_stats++; break; case 'T' : case 't' : tstats(sptr, parv[0]); valid_stats++; break; case 'U' : report_specials(sptr,CONF_ULINE,RPL_STATSULINE); valid_stats++; break; case 'u' : { time_t now; now = CurrentTime - me.since; sendto_one(sptr, form_str(RPL_STATSUPTIME), mename, parv[0], now/86400, (now/3600)%24, (now/60)%60, now%60); sendto_one(sptr, form_str(RPL_STATSCONN), mename, parv[0], MaxConnectionCount, MaxClientCount, Count.totalrestartcount); valid_stats++; break; } case 'V' : show_servers(sptr); valid_stats++; break; case 'v' : report_svlines(sptr); valid_stats++; break; case 'x' : report_specials(sptr,CONF_XLINE,RPL_STATSXLINE); valid_stats++; break; case 'X' : report_configured_links(sptr, CONF_MISSING); valid_stats++; break;; case 'Y' : case 'y' : report_classes(sptr); valid_stats++; break; case 'Z' : report_zlines(sptr); valid_stats++; break; case 'z' : count_memory(sptr, parv[0]); valid_stats++; break; case '?': serv_info(sptr, parv[0]); valid_stats++; break; default : l_stat = '*'; break; } sendto_one(sptr, form_str(RPL_ENDOFSTATS), mename, parv[0], l_stat); /* personally, I don't see why opers need to see stats requests * at all. They are just "noise" to an oper, and users can't do * any damage with stats requests now anyway. So, why show them? * -Dianora */ if (valid_stats) { if ( (l_stat == 'L') || (l_stat == 'l') ) { sendto_ops_imodes(IMODE_SPY, "STATS %c requested by %s (%s@%s) [%s] on %s%s", l_stat, sptr->name, sptr->username, sptr->host, sptr->user->server, parc > 2 ? parv[2] : "<no recipient>", ignore_request > 0 ? " [request ignored]" : "\0" ); } else { sendto_ops_imodes(IMODE_SPY, "STATS %c requested by %s (%s@%s) [%s]%s", l_stat, sptr->name, sptr->username, sptr->host, sptr->user->server, ignore_request > 0 ? " [request ignored]" : "\0" ); } } return 0; }
int main(int argc, char **argv) { struct passwd *pwd; int ch, count, newline; const char *file; char *sender, *p; #if MAXPATHLEN > BUFSIZ char buf[MAXPATHLEN]; #else char buf[BUFSIZ]; #endif file = sender = NULL; count = -1; while ((ch = getopt(argc, argv, "cf:s:")) != -1) switch (ch) { case 'c': count = 0; break; case 'f': file = optarg; break; case 's': sender = optarg; for (p = sender; *p; ++p) *p = tolower(*p); break; case '?': default: usage(); } argv += optind; if (file == NULL) { if (*argv) { snprintf(buf, sizeof(buf), "%s/%s", _PATH_MAILDIR, *argv); file = buf; } else { if ((file = getenv("MAIL")) == NULL) { if (!(pwd = getpwuid(getuid()))) errx(1, "no password file entry for you"); file = pwd->pw_name; snprintf(buf, sizeof(buf), "%s/%s", _PATH_MAILDIR, file); file = buf; } } } /* read from stdin */ if (strcmp(file, "-") == 0) { } else if (freopen(file, "r", stdin) == NULL) { err(1, "can't read %s", file); } for (newline = 1; fgets(buf, sizeof(buf), stdin);) { if (*buf == '\n') { newline = 1; continue; } if (newline && !strncmp(buf, "From ", 5) && (!sender || match(buf + 5, sender))) { if (count != -1) count++; else printf("%s", buf); } newline = 0; } if (count != -1) printf("There %s %d message%s in your incoming mailbox.\n", count == 1 ? "is" : "are", count, count == 1 ? "" : "s"); exit(0); }
void mk_quantifier_instantiation::instantiate_quantifier(quantifier* q, app* pat, expr_ref_vector & conjs) { m_binding.reset(); m_binding.resize(q->get_num_decls()); term_pairs todo; match(0, pat, 0, todo, q, conjs); }
/* * parse a buffer. * * NOTE: parse() should not be called recusively by any other functions! */ int parse(aClient *cptr, char *pbuffer, char *bufend) { aClient *from = cptr; char *ch; char *s; char parsebuf[2048]; int i; char* numeric = 0; int paramcount; struct Message *mptr; Debug((DEBUG_DEBUG, "Parsing %s: %s", get_client_name(cptr, TRUE), pbuffer)); if (IsDead(cptr)) return -1; if (MyClient(cptr) && cptr->codepage) { char *trans = codepage_to_unicode(pbuffer, cptr->codepage - 1); if (trans != pbuffer) { strncpy(parsebuf, trans, sizeof(parsebuf)); pbuffer = parsebuf; bufend = parsebuf + strlen(parsebuf) - 1; } } s = sender; *s = '\0'; for (ch = pbuffer; *ch == ' '; ch++) /* skip spaces */ /* null statement */ ; para[0] = from->name; if (*ch == ':') { ch++; /* ** Copy the prefix to 'sender' assuming it terminates ** with SPACE (or NULL, which is an error, though). */ for (i = 0; *ch && *ch != ' '; i++ ) { if (i < (sizeof(sender)-1)) *s++ = *ch; /* leave room for NULL */ ch++; } *s = '\0'; i = 0; /* ** Actually, only messages coming from servers can have ** the prefix--prefix silently ignored, if coming from ** a user client... ** ** ...sigh, the current release "v2.2PL1" generates also ** null prefixes, at least to NOTIFY messages (e.g. it ** puts "sptr->nickname" as prefix from server structures ** where it's null--the following will handle this case ** as "no prefix" at all --msa (": NOTICE nick ...") */ if (*sender && IsServer(cptr)) { from = find_client(sender, (aClient *) NULL); if (!from || !match(from->name, sender)) from = find_server(sender); para[0] = sender; /* Hmm! If the client corresponding to the * prefix is not found--what is the correct * action??? Now, I will ignore the message * (old IRC just let it through as if the * prefix just wasn't there...) --msa */ if (!from) { Debug((DEBUG_ERROR, "Unknown prefix (%s)(%s) from (%s)", sender, pbuffer, cptr->name)); ServerStats->is_unpf++; remove_unknown(cptr, sender, pbuffer); return -1; } if (from->from != cptr) { ServerStats->is_wrdi++; Debug((DEBUG_ERROR, "Message (%s) coming from (%s)", pbuffer, cptr->name)); return cancel_clients(cptr, from, pbuffer); } } while (*ch == ' ') ch++; } if (*ch == '\0') { ServerStats->is_empt++; Debug((DEBUG_NOTICE, "Empty message from host %s:%s", cptr->name, from->name)); return(-1); } /* ** Extract the command code from the packet. Point s to the end ** of the command code and calculate the length using pointer ** arithmetic. Note: only need length for numerics and *all* ** numerics must have parameters and thus a space after the command ** code. -avalon * * ummm???? - Dianora */ /* Lets log any message we receive except nickserv/chanserv and privmsgs/notices - Lamego */ if(debug_opt) { if(strncasecmp(ch,"PRIVMSG",7)==0 || strncasecmp(ch,"NOTICE",6)==0) irclog(L_NOTICE,"Recv: (%s) PRIVMSG/NOTICE ...", from->name); else if(strncasecmp(ch,"NICKSERV",8)==0 || strncasecmp(ch,"CHANSERV",8)==0) irclog(L_NOTICE,"Recv: (%s) NICKSERV/CHANSERV ...", from->name); else irclog(L_NOTICE,"Recv: (%s) %s", from->name, ch); } if( *(ch + 3) == ' ' && /* ok, lets see if its a possible numeric.. */ IsDigit(*ch) && IsDigit(*(ch + 1)) && IsDigit(*(ch + 2)) ) { mptr = (struct Message *)NULL; numeric = ch; paramcount = MAXPARA; ServerStats->is_num++; s = ch + 3; /* I know this is ' ' from above if */ *s++ = '\0'; /* blow away the ' ', and point s to next part */ } else { s = strchr(ch, ' '); /* moved from above,now need it here */ if (s) *s++ = '\0'; mptr = tree_parse(ch); if (!mptr || !mptr->cmd) { /* ** Note: Give error message *only* to recognized ** persons. It's a nightmare situation to have ** two programs sending "Unknown command"'s or ** equivalent to each other at full blast.... ** If it has got to person state, it at least ** seems to be well behaving. Perhaps this message ** should never be generated, though... --msa ** Hm, when is the buffer empty -- if a command ** code has been found ?? -Armin */ if (pbuffer[0] != '\0') { if (IsPerson(from)) sendto_one(from, ":%s %d %s %s :Unknown command", me.name, ERR_UNKNOWNCOMMAND, from->name, ch); Debug((DEBUG_ERROR,"Unknown (%s) from %s", ch, get_client_name(cptr, TRUE))); } ServerStats->is_unco++; return(-1); } paramcount = mptr->parameters; i = bufend - ((s) ? s : ch); mptr->bytes += i; #ifdef FLOOD_DELAY /* Allow only 1 msg per 2 seconds * (on average) to prevent dumping. * to keep the response rate up, * bursts of up to 5 msgs are allowed * -SRB * Opers can send 1 msg per second, burst of ~20 * -Taner */ if ((mptr->flags & 1) && !(IsServer(cptr)) && !IsFloodEx(cptr) ) { #ifdef NO_OPER_FLOOD #ifndef TRUE_NO_OPER_FLOOD /* note: both have to be defined for the real no-flood */ if (IsAnOper(cptr)) /* "randomly" (weighted) increase the since */ cptr->since += (cptr->receiveM % 5) ? 1 : 0; else #else if (!IsAnOper(cptr)) #endif #endif cptr->since += (2 + i / 120); } #endif /* FLOOD_DELAY */ } /* ** Must the following loop really be so devious? On ** surface it splits the message to parameters from ** blank spaces. But, if paramcount has been reached, ** the rest of the message goes into this last parameter ** (about same effect as ":" has...) --msa */ /* Note initially true: s==NULL || *(s-1) == '\0' !! */ /* ZZZ hmmmmmmmm whats this then? */ #if 0 if (me.user) para[0] = sender; #endif i = 1; if (s) { if (paramcount > MAXPARA) paramcount = MAXPARA; for (;;) { while(*s == ' ') /* tabs are not considered space */ *s++ = '\0'; if(!*s) break; if (*s == ':') { /* ** The rest is single parameter--can ** include blanks also. */ para[i++] = s + 1; break; } else { para[i++] = s; if (i >= paramcount) { break; } /* scan for end of string, either ' ' or '\0' */ while (IsNonEOS(*s)) s++; } } } para[i] = NULL; if (mptr == (struct Message *)NULL) return (do_numeric(numeric, cptr, from, i, para)); mptr->count++; /* patch to avoid server flooding from unregistered connects */ /* check allow_unregistered_use flag I've set up instead of function comparing *yech* - Dianora */ if ((!IsRegistered(cptr) || (hvc_enabled && cptr->hvc)) && !mptr->allow_unregistered_use) { /* if its from a possible server connection * ignore it.. more than likely its a header thats sneaked through */ if(IsHandshake(cptr) || IsConnecting(cptr) || IsServer(cptr)) return -1; sendto_one(from, ":%s %d %s %s :Register first.", me.name, ERR_NOTREGISTERED, BadPtr(from->name) ? "*" : from->name, ch); return -1; } /* Again, instead of function address comparing, see if * this function resets idle time as given from mptr * if IDLE_FROM_MSG is undefined, the sense of the flag is reversed. * i.e. if the flag is 0, then reset idle time, otherwise don't reset it. * * - Dianora */ #ifdef IDLE_FROM_MSG if (IsRegisteredUser(cptr) && mptr->reset_idle) from->user->last = CurrentTime; #else if (IsRegisteredUser(cptr) && !mptr->reset_idle) from->user->last = CurrentTime; #endif /* don't allow other commands while a list is blocked. since we treat them specially with respect to sendq. */ if ((IsDoingList(cptr)) && (*mptr->func != m_list)) return -1; return (*mptr->func)(cptr, from, i, para); }
Lexeme *init(Parser *p) { match(p,ASSIGN); return expression(p); }
/* determine version of OS by mem * 1.To get signature of multiply versions of os, which is the md5 of kernel code * 2.scan all pages of input memory, generate the md5 checksum of one page, compare to all the signature, * if they are match, output the version of the os. * 3.Done! * 4.abandoned*/ void determineOsVersion2(Mem * mem) { //get signature // initHashTable(); int osNumber = initDb(); int pageSize = 4 * 1024; //4k int totalPageNumber = mem->mem_size / (4 * 1024); //assume that every page has 4k //record when two page have different page index and the same sharp int calledPages[totalPageNumber]; int dsmPages[totalPageNumber]; //record virtual address int i; unsigned virtualAddrs[totalPageNumber]; for (i = 0; i < totalPageNumber; i++) { calledPages[i] = 0; dsmPages[i] = 0; virtualAddrs[i] = 0; } //start address unsigned start_vaddr = 0x80000000; unsigned vaddr = start_vaddr; int matchCount = 0; int matchPageIndex = 0; int availableOs[FINGERPRINT_NO]; for (i = 0; i < FINGERPRINT_NO; i++) availableOs[i] = 1; for (; vaddr > start_vaddr - 1; vaddr += 0x1000) { int rw = 0, us = 0, g = 0, ps = 0; //page size 4M or 4k unsigned pAddr = vtopPageProperty(mem->mem, mem->mem_size, mem->pgd, vaddr, &rw, &us, &g, &ps); if (pAddr == -1 || pAddr > mem->mem_size) continue; int pageIndex = pAddr / pageSize; if (us == 0 && g == 256 && is_code_page(mem, vaddr, pageSize, virtualAddrs) == 0) { page_init(mem, pageIndex, pageSize, dsmPages, 0, vaddr, calledPages); if (dsmPages[pageIndex] != 1) continue; void * startAdress = (void *) ((unsigned) mem->mem + pageIndex * pageSize); unsigned char md5digest[16]; MDMem(startAdress, pageSize, md5digest); MDPrint(md5digest); printf("\n"); //search hash table int ret = match(osNumber, md5digest, &matchPageIndex, availableOs); while (ret == 2) { matchPageIndex++; ret = match(osNumber, md5digest, &matchPageIndex, availableOs); } if (ret >= 0) { matchPageIndex++; matchCount++; if (ret == 1) break; } // char * version = hashTableGet(md5digest); // if (version != NULL) { // printf("OS is %s\n", version); // matchCount++; // break; // } } } // hashTableCleanup(); if (matchCount == 0) puts("Unknown OS!"); printf("match Count:%d\n", matchCount); }
/* * ms_encap() * * inputs - destination server, subcommand, parameters * output - none * side effects - propogates subcommand to locally connected servers */ static void ms_encap(struct Client *client_p, struct Client *source_p, int parc, char *parv[]) { char buffer[BUFSIZE], *ptr = buffer; unsigned int cur_len = 0, len, i; int paramcount, mpara = 0; struct Message *mptr = NULL; MessageHandler handler = 0; for (i = 1; i < (unsigned int)parc - 1; i++) { len = strlen(parv[i]) + 1; if ((cur_len + len) >= sizeof(buffer)) return; ircsprintf(ptr, "%s ", parv[i]); cur_len += len; ptr += len; } len = strlen(parv[i]); /* * if the final parameter crosses our buffer size, should we bail, * like the rest, or should we truncate? ratbox seems to think truncate, * so i'll do that for now until i can talk to lee. -bill * * if the rest bail, we should too, but i'll make it optional for now. * frankily, bailing shouldn't matter, as ENCAP is basically worthless anyway. * infact, it will most likely not make final release. * --nenolod */ if (parc == 3) ircsprintf(ptr, "%s", parv[2]); else ircsprintf(ptr, ":%s", parv[parc-1]); #ifdef RATBOX_STYLE_ENCAP if ((cur_len + len) >= sizeof(buffer)) buffer[sizeof(buffer)-1] = '\0'; #else if ((cur_len + len) >= sizeof(buffer)) return; #endif sendto_match_servs(source_p, parv[1], CAP_ENCAP, "ENCAP %s", buffer); if (!match(parv[1], me.name)) return; mptr = find_command(parv[2]); if ((mptr == NULL) || (mptr->cmd == NULL)) return; paramcount = mptr->parameters; mpara = mptr->maxpara; mptr->bytes += strlen(buffer); /* * yes this is an ugly hack, but it is quicker than copying the entire array again * note: this hack wouldnt be needed if parv[0] were set to the command name, rather * than being derived from the prefix, as it should have been from the beginning. */ ptr = parv[0]; parv+=2; parc-=2; parv[0] = ptr; if ((handler = mptr->handlers[2]) == NULL) return; (*handler)(client_p, source_p, parc, parv); }
/* * m_kline * Add a local user@host ban. * * parv[0] = sender * parv[1] = duration (optional) * parv[2] = nick or user@host mask * parv[3] = reason (optional) */ int m_kline(aClient *cptr, aClient *sptr, int parc, char *parv[]) { char rbuf[512]; char hostbuf[HOSTIPLEN+3+1]; char *target; char *user; char *host; char *reason = "<no reason>"; int tkminutes = DEFAULT_KLINE_TIME; int tkseconds; long lval; struct userBan *ban; struct userBan *existing; aClient *acptr; if (!OPCanKline(sptr)) { sendto_one(sptr, err_str(ERR_NOPRIVILEGES), me.name, parv[0]); return 0; } if (parc < 2) { sendto_one(sptr, err_str(ERR_NEEDMOREPARAMS), me.name, parv[0], "KLINE"); return 0; } lval = strtol(parv[1], &target, 10); if (*target != 0) { target = parv[1]; if (parc > 2 && !BadPtr(parv[2])) reason = parv[2]; } else { /* valid expiration time */ tkminutes = lval; if (parc < 3) { sendto_one(sptr, err_str(ERR_NEEDMOREPARAMS), me.name, parv[0], "KLINE"); return 0; } target = parv[2]; if (parc > 3 && !BadPtr(parv[3])) reason = parv[3]; } /* negative times, or times greater than a year, are permanent */ if (tkminutes < 0 || tkminutes > (365 * 24 * 60)) tkminutes = 0; tkseconds = tkminutes * 60; if ((host = strchr(target, '@'))) { *host++ = 0; user = target; } else if (strchr(target, '*')) { user = "******"; host = target; } else { if (!(acptr = find_chasing(sptr, target, NULL))) return 0; if (!acptr->user) return 0; user = acptr->user->username; if (acptr->ip_family == AF_INET) { ircsprintf(hostbuf, "%s/24", acptr->hostip); host = hostbuf; } else host = acptr->hostip; } if (!match(user, "akjhfkahfasfjd") && !match(host, "ldksjfl.kss...kdjfd.jfklsjf")) { sendto_one(sptr, ":%s NOTICE %s :KLINE: %s@%s mask is too wide", me.name, parv[0], user, host); return 0; } if (strchr(host, ' ') || !(ban = make_hostbased_ban(user, host))) { sendto_one(sptr, ":%s NOTICE %s :KLINE: invalid ban mask %s@%s", me.name, parv[0], user, host); return 0; } ban->flags |= UBAN_LOCAL; /* only looks for duplicate klines, not akills */ if ((existing = find_userban_exact(ban, UBAN_LOCAL))) { sendto_one(sptr, ":%s NOTICE %s :KLINE: %s@%s is already %s: %s", me.name, parv[0], user, host, LOCAL_BANNED_NAME, existing->reason ? existing->reason : "<no reason>"); userban_free(ban); return 0; } if (user_match_ban(sptr, ban)) { sendto_one(sptr, ":%s NOTICE %s :KLINE: %s@%s matches you, rejected", me.name, parv[0], user, host); userban_free(ban); return 0; } ircsnprintf(rbuf, sizeof(rbuf), "%s (%s)", reason, smalldate(0)); ban->reason = MyMalloc(strlen(rbuf) + 1); strcpy(ban->reason, rbuf); if (tkseconds) { ban->flags |= UBAN_TEMPORARY; ban->timeset = NOW; ban->duration = tkseconds; } add_hostbased_userban(ban); if (!tkminutes || tkminutes >= KLINE_MIN_STORE_TIME) klinestore_add(ban); userban_sweep(ban); host = get_userban_host(ban, rbuf, sizeof(rbuf)); if (tkminutes) sendto_realops("%s added temporary %d min. "LOCAL_BAN_NAME" for" " [%s@%s] [%s]", parv[0], tkminutes, user, host, reason); else sendto_realops("%s added "LOCAL_BAN_NAME" for [%s@%s] [%s]", parv[0], user, host, reason); return 0; }
bool Reader::readToken( Token &token ) { skipSpaces(); token.start_ = current_; Char c = getNextChar(); bool ok = true; switch ( c ) { case '{': token.type_ = tokenObjectBegin; break; case '}': token.type_ = tokenObjectEnd; break; case '[': token.type_ = tokenArrayBegin; break; case ']': token.type_ = tokenArrayEnd; break; case '"': token.type_ = tokenString; ok = readString(); break; case '/': token.type_ = tokenComment; ok = readComment(); break; case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': case '-': token.type_ = tokenNumber; readNumber(); break; case 't': token.type_ = tokenTrue; ok = match( "rue", 3 ); break; case 'f': token.type_ = tokenFalse; ok = match( "alse", 4 ); break; case 'n': token.type_ = tokenNull; ok = match( "ull", 3 ); break; case ',': token.type_ = tokenArraySeparator; break; case ':': token.type_ = tokenMemberSeparator; break; case 0: token.type_ = tokenEndOfStream; break; default: ok = false; break; } if ( !ok ) token.type_ = tokenError; token.end_ = current_; return true; }
bool OpenDDS::DCPS::ReceivedDataElementList::remove(ReceivedDataElement *data_sample) { IdentityFilter match(data_sample); return remove(match, false); // short-circuit evaluation }
int cmd_set (struct session *sess, char *tbuf, char *word[], char *word_eol[]) { int wild = FALSE; int or = FALSE; int off = FALSE; int quiet = FALSE; int erase = FALSE; int i = 0, finds = 0, found; int idx = 2; int prev_numeric; char *var, *val, *prev_string; if (g_ascii_strcasecmp (word[2], "-e") == 0) { idx++; erase = TRUE; } /* turn a bit OFF */ if (g_ascii_strcasecmp (word[idx], "-off") == 0) { idx++; off = TRUE; } /* turn a bit ON */ if (g_ascii_strcasecmp (word[idx], "-or") == 0 || g_ascii_strcasecmp (word[idx], "-on") == 0) { idx++; or = TRUE; } if (g_ascii_strcasecmp (word[idx], "-quiet") == 0) { idx++; quiet = TRUE; } var = word[idx]; val = word_eol[idx+1]; if (!*var) { set_list (sess, tbuf); return TRUE; } if ((strchr (var, '*') || strchr (var, '?')) && !*val) { wild = TRUE; } if (*val == '=') { val++; } do { if (wild) { found = !match (var, vars[i].name); } else { found = g_ascii_strcasecmp (var, vars[i].name); } if (found == 0) { finds++; switch (vars[i].type) { case TYPE_STR: if (erase || *val) { /* save the previous value until we print it out */ prev_string = (char*) malloc (vars[i].len + 1); strncpy (prev_string, (char *) &prefs + vars[i].offset, vars[i].len); /* update the variable */ strncpy ((char *) &prefs + vars[i].offset, val, vars[i].len); ((char *) &prefs)[vars[i].offset + vars[i].len - 1] = 0; if (!quiet) { PrintTextf (sess, "%s set to: %s (was: %s)\n", var, (char *) &prefs + vars[i].offset, prev_string); } free (prev_string); } else { set_showval (sess, &vars[i], tbuf); } break; case TYPE_INT: case TYPE_BOOL: if (*val) { prev_numeric = *((int *) &prefs + vars[i].offset); if (vars[i].type == TYPE_BOOL) { if (atoi (val)) { *((int *) &prefs + vars[i].offset) = 1; } else { *((int *) &prefs + vars[i].offset) = 0; } if (!g_ascii_strcasecmp (val, "YES") || !g_ascii_strcasecmp (val, "ON")) { *((int *) &prefs + vars[i].offset) = 1; } if (!g_ascii_strcasecmp (val, "NO") || !g_ascii_strcasecmp (val, "OFF")) { *((int *) &prefs + vars[i].offset) = 0; } } else { if (or) { *((int *) &prefs + vars[i].offset) |= atoi (val); } else if (off) { *((int *) &prefs + vars[i].offset) &= ~(atoi (val)); } else { *((int *) &prefs + vars[i].offset) = atoi (val); } } if (!quiet) { PrintTextf (sess, "%s set to: %d (was: %d)\n", var, *((int *) &prefs + vars[i].offset), prev_numeric); } } else { set_showval (sess, &vars[i], tbuf); } break; } } i++; } while (vars[i].name); if (!finds && !quiet) { PrintText (sess, "No such variable.\n"); } else if (!save_config ()) { PrintText (sess, "Error saving changes to disk.\n"); } return TRUE; }
static int str_format (lua_State *L) { int arg = 1; const char *strfrmt = luaL_check_string(L, arg); luaL_Buffer b; luaL_buffinit(L, &b); while (*strfrmt) { if (*strfrmt != '%') luaL_putchar(&b, *strfrmt++); else if (*++strfrmt == '%') luaL_putchar(&b, *strfrmt++); /* %% */ else { /* format item */ struct Capture cap; char form[MAX_FORMAT]; /* to store the format ('%...') */ char buff[MAX_ITEM]; /* to store the formatted item */ const char *initf = strfrmt; form[0] = '%'; if (isdigit((unsigned char)*initf) && *(initf+1) == '$') { arg = *initf - '0'; initf += 2; /* skip the 'n$' */ } arg++; cap.src_end = strfrmt+strlen(strfrmt)+1; cap.level = 0; strfrmt = match(L, initf, "[-+ #0]*(%d*)%.?(%d*)", &cap); if (cap.capture[0].len > 2 || cap.capture[1].len > 2 || /* < 100? */ strfrmt-initf > MAX_FORMAT-2) lua_error(L, "invalid format (width or precision too long)"); strncpy(form+1, initf, strfrmt-initf+1); /* +1 to include conversion */ form[strfrmt-initf+2] = 0; switch (*strfrmt++) { case 'c': case 'd': case 'i': sprintf(buff, form, luaL_check_int(L, arg)); break; case 'o': case 'u': case 'x': case 'X': sprintf(buff, form, (unsigned int)luaL_check_number(L, arg)); break; case 'e': case 'E': case 'f': case 'g': case 'G': sprintf(buff, form, luaL_check_number(L, arg)); break; case 'q': luaI_addquoted(L, &b, arg); continue; /* skip the "addsize" at the end */ case 's': { size_t l; const char *s = luaL_check_lstr(L, arg, &l); if (cap.capture[1].len == 0 && l >= 100) { /* no precision and string is too long to be formatted; keep original string */ lua_pushvalue(L, arg); luaL_addvalue(&b); continue; /* skip the "addsize" at the end */ } else { sprintf(buff, form, s); break; } } default: /* also treat cases 'pnLlh' */ lua_error(L, "invalid option in `format'"); } luaL_addlstring(&b, buff, strlen(buff)); } } luaL_pushresult(&b); return 1; }
bool match(const wchar* pattern, const wchar* string, bool ForceCase) { for (;; ++string) { wchar stringc = touppercw(*string, ForceCase); wchar patternc = touppercw(*pattern++, ForceCase); switch (patternc) { case 0: return(stringc == 0); case '?': if (stringc == 0) return(false); break; case '*': if (*pattern == 0) return(true); if (*pattern == '.') { if (pattern[1] == '*' && pattern[2] == 0) return(true); const wchar* dot = wcschr(string, '.'); if (pattern[1] == 0) return (dot == NULL || dot[1] == 0); if (dot != NULL) { string = dot; if (wcspbrk(pattern, L"*?") == NULL && wcschr(string + 1, '.') == NULL) return(mwcsicompc(pattern + 1, string + 1, ForceCase) == 0); } } while (*string) if (match(pattern, string++, ForceCase)) return(true); return(false); default: if (patternc != stringc) { // Allow "name." mask match "name" and "name.\" match "name\". if (patternc == '.' && (stringc == 0 || stringc == '\\' || stringc == '.')) return(match(pattern, string, ForceCase)); else return(false); } break; } } }
//------------------------------------------------------------------------------ void ClassDefinition::bindPropertyImpl( const char * name, const ObjectHandle & pBase, PropertyAccessor & o_PropertyAccessor ) const { if (!*name) { // empty name causes noop return; } // find property operator auto propOperator = name; while (true) { if( !*propOperator || *propOperator == INDEX_OPEN || *propOperator == DOT_OPERATOR ) { break; } propOperator += 1; } auto propName = name; auto propLength = propOperator - propName; auto baseProp = findProperty( propName, propLength ); if (baseProp == nullptr) { // error: property `propName` is not found o_PropertyAccessor.setBaseProperty( nullptr ); return; } o_PropertyAccessor.setObject( pBase ); o_PropertyAccessor.setBaseProperty( baseProp ); assert( strncmp( propName, o_PropertyAccessor.getName(), propLength ) == 0 ); if (!*propOperator) { // no operator, so that's it return; } Variant propVal = o_PropertyAccessor.getValue(); if (*propOperator == INDEX_OPEN) { auto wholeIndex = propOperator; // read "multidimensional" indices without recursive bind (optimization) while (true) { Collection collection; if (!propVal.tryCast( collection )) { // error: index operator is applicable to collections only o_PropertyAccessor.setBaseProperty( nullptr ); return; } // determine key type (heterogeneous keys are not supported yet) const auto begin = collection.begin(); const auto end = collection.end(); if (begin == end) { // error: can't index empty collection o_PropertyAccessor.setBaseProperty( nullptr ); return; } // read key Variant key( begin.key().type() ); { propOperator += 1; // skip INDEX_OPEN FixedMemoryStream dataStream( propOperator ); TextStream stream( dataStream ); stream >> key >> match( INDEX_CLOSE ); if (stream.fail()) { // error: either key can't be read, or it isn't followed by INDEX_CLOSE o_PropertyAccessor.setBaseProperty( nullptr ); return; } // skip key and closing bracket propOperator += stream.seek( 0, std::ios_base::cur ); } auto it = collection.find( key ); // If (it == end), still return a valid property accessor to end, // rather than an invalid property accessor. if (!*propOperator || (it == end)) { // name parsing is completed auto baseProp = std::make_shared< CollectionElementHolder >( collection, it, collection.valueType(), wholeIndex ); // o_PropertyAccessor.setObject(); - keep current base o_PropertyAccessor.setBaseProperty( baseProp ); return; } propVal = it.value(); if (*propOperator == INDEX_OPEN) { continue; } // parse next operator break; } }
static int glob3(Char *pathbuf, Char *pathend, Char *pathend_last, Char *pattern, Char *restpattern, glob_t *pglob, size_t *limit) { struct dirent *dp; DIR *dirp; int err; char buf[MAXPATHLEN]; /* * The readdirfunc declaration can't be prototyped, because it is * assigned, below, to two functions which are prototyped in glob.h * and dirent.h as taking pointers to differently typed opaque * structures. */ struct dirent *(*readdirfunc)(); if (pathend > pathend_last) return (GLOB_ABORTED); *pathend = EOS; errno = 0; if ((dirp = g_opendir(pathbuf, pglob)) == NULL) { /* TODO: don't call for ENOENT or ENOTDIR? */ if (pglob->gl_errfunc) { if (g_Ctoc(pathbuf, buf, sizeof(buf))) return (GLOB_ABORTED); if (pglob->gl_errfunc(buf, errno) || pglob->gl_flags & GLOB_ERR) return (GLOB_ABORTED); } return(0); } err = 0; /* Search directory for matching names. */ if (pglob->gl_flags & GLOB_ALTDIRFUNC) readdirfunc = pglob->gl_readdir; else readdirfunc = readdir; while ((dp = (*readdirfunc)(dirp))) { char *sc; Char *dc; wchar_t wc; size_t clen; mbstate_t mbs; /* Initial DOT must be matched literally. */ if (dp->d_name[0] == DOT && *pattern != DOT) continue; memset(&mbs, 0, sizeof(mbs)); dc = pathend; sc = dp->d_name; while (dc < pathend_last) { clen = mbrtowc(&wc, sc, MB_LEN_MAX, &mbs); if (clen == (size_t)-1 || clen == (size_t)-2) { wc = *sc; clen = 1; memset(&mbs, 0, sizeof(mbs)); } if ((*dc++ = wc) == EOS) break; sc += clen; } if (!match(pathend, pattern, restpattern)) { *pathend = EOS; continue; } err = glob2(pathbuf, --dc, pathend_last, restpattern, pglob, limit); if (err) break; } if (pglob->gl_flags & GLOB_ALTDIRFUNC) (*pglob->gl_closedir)(dirp); else closedir(dirp); return(err); }
bool Glob::matchAfterAsterisk(TextIterator itp, const TextIterator& endp, TextIterator its, const TextIterator& ends) { return match(itp, endp, its, ends); }
/** Searches for a K/G-line for a client. If one is found, notify the * user and disconnect them. * @param cptr Client to search for. * @return 0 if client is accepted; -1 if client was locally denied * (K-line); -2 if client was globally denied (G-line); -3 if client * was globally IP denied (Z-line). */ int find_kill(struct Client *cptr) { const char* host; const char* name; const char* realname; const char* country; const char* continent; const char* version; struct DenyConf* deny; struct Gline* agline = NULL; struct Zline* azline = NULL; assert(0 != cptr); if (!cli_user(cptr)) return 0; host = cli_sockhost(cptr); name = cli_user(cptr)->username; realname = cli_info(cptr); country = cli_countrycode(cptr); continent = cli_continentcode(cptr); version = cli_version(cptr); assert(strlen(host) <= HOSTLEN); assert((name ? strlen(name) : 0) <= HOSTLEN); assert((realname ? strlen(realname) : 0) <= REALLEN); assert((country ? strlen(country) : 0) <= 3); assert((continent ? strlen(continent) : 0) <= 3); assert((version ? strlen(version) : 0) <= VERSIONLEN); /* 2000-07-14: Rewrote this loop for massive speed increases. * -- Isomer */ if (!find_except_conf(cptr, EFLAG_KLINE)) { for (deny = denyConfList; deny; deny = deny->next) { if (deny->usermask && match(deny->usermask, name)) continue; if (deny->realmask && match(deny->realmask, realname)) continue; if (deny->countrymask && country && match(deny->countrymask, country)) continue; if (deny->continentmask && continent && match(deny->continentmask, continent)) continue; if (feature_bool(FEAT_CTCP_VERSIONING) && feature_bool(FEAT_CTCP_VERSIONING_KILL)) { if (deny->version && version && match(deny->version, version)) continue; } if (deny->bits > 0) { if (!ipmask_check(&cli_ip(cptr), &deny->address, deny->bits)) continue; } else if (deny->hostmask && match(deny->hostmask, host)) continue; if ((deny->flags & DENY_FLAGS_AUTHEX) && IsAccount(cptr)) { if (!EmptyString(deny->mark) && EmptyString(cli_killmark(cptr))) ircd_strncpy(cli_killmark(cptr), deny->mark, BUFSIZE); continue; } if (EmptyString(deny->message)) send_reply(cptr, SND_EXPLICIT | ERR_YOUREBANNEDCREEP, ":Connection from your host is refused on this server."); else { if (deny->flags & DENY_FLAGS_FILE) killcomment(cptr, deny->message); else send_reply(cptr, SND_EXPLICIT | ERR_YOUREBANNEDCREEP, ":%s.", deny->message); } return -1; } } /* Check Zlines here just in case a spoofed IP matches */ if (!feature_bool(FEAT_DISABLE_ZLINES) && (azline = zline_lookup(cptr, 0))) { /* * find active zlines * added a check against the user's IP address to find_zline() */ send_reply(cptr, SND_EXPLICIT | ERR_YOUREBANNEDCREEP, ":%s.", ZlineReason(azline)); return -3; } /* Don't need to do an except lookup here as it's done in gline_lookup() */ if (!feature_bool(FEAT_DISABLE_GLINES) && (agline = gline_lookup(cptr, 0))) { /* * find active glines * added a check against the user's IP address to find_gline() -Kev */ send_reply(cptr, SND_EXPLICIT | ERR_YOUREBANNEDCREEP, ":%s.", GlineReason(agline)); return -2; } return 0; }
// TODO fix? Lexeme *operator(Parser *p) { return match(p,p->pending->type); }
int main(int argc, char **argv) { wchar_t t; int i, opt_end = 0; int sigs[] = {SIGHUP, SIGINT, SIGPIPE, 0}; #if defined(__lint) yydebug = 0; #endif for (i = 0; sigs[i]; ++i) { if (signal(sigs[i], SIG_IGN) != SIG_IGN) (void) signal(sigs[i], catchsig); } tempfile = mktemp(tmp_name); (void) close(creat(tempfile, 0)); (void) setlocale(LC_ALL, ""); #if !defined(TEXT_DOMAIN) /* Should be defined by cc -D */ #define TEXT_DOMAIN "SYS_TEST" #endif (void) textdomain(TEXT_DOMAIN); if ((mb_cur_max = MB_CUR_MAX) > 1) wide = 1; procnam = argv[0]; getflags(&argc, &argv, &opt_end); initalloc(); setfname("-"); if (argc > 1) { --argc; ++argv; if (strcmp(argv[0], "-")) { ifile[ifx] = m4open(&argv, "r", &argc); setfname(argv[0]); } } for (;;) { token[0] = t = getchr(); token[1] = EOS; if (t == WEOF) { if (ifx > 0) { (void) fclose(ifile[ifx]); ipflr = ipstk[--ifx]; continue; } getflags(&argc, &argv, &opt_end); if (argc <= 1) /* * If dowrap() has been called, the m4wrap * macro has been processed, and a linked * list of m4wrap strings has been created. * The list starts at wrapstart. */ if (wrapstart) { /* * Now that EOF has been processed, * display the m4wrap strings. */ showwrap(); continue; } else break; --argc; ++argv; if (ifile[ifx] != stdin) (void) fclose(ifile[ifx]); if (strcmp(argv[0], "-")) ifile[ifx] = m4open(&argv, "r", &argc); else ifile[ifx] = stdin; setfname(argv[0]); continue; } if (is_alpha(t) || t == '_') { wchar_t *tp = token+1; int tlim = toksize; struct nlist *macadd; /* temp variable */ while ((*tp = getchr()) != WEOF && (is_alnum(*tp) || *tp == '_')) { tp++; if (--tlim <= 0) error2(gettext( "more than %d chars in word"), toksize); } putbak(*tp); *tp = EOS; macadd = lookup(token); *Ap = (wchar_t *)macadd; if (macadd->def) { if ((wchar_t *)(++Ap) >= astklm) { --Ap; error2(gettext( "more than %d items on " "argument stack"), stksize); } if (Cp++ == NULL) Cp = callst; Cp->argp = Ap; *Ap++ = op; puttok(token); stkchr(EOS); t = getchr(); putbak(t); if (t != '(') pbstr(L"()"); else /* try to fix arg count */ *Ap++ = op; Cp->plev = 0; } else { puttok(token); } } else if (match(t, lquote)) { int qlev = 1; for (;;) { token[0] = t = getchr(); token[1] = EOS; if (match(t, rquote)) { if (--qlev > 0) puttok(token); else break; } else if (match(t, lquote)) { ++qlev; puttok(token); } else { if (t == WEOF) error(gettext( "EOF in quote")); putchr(t); } } } else if (match(t, lcom) && ((lcom[0] != L'#' || lcom[1] != L'\0') || prev_char != '$')) { /* * Don't expand commented macro (between lcom and * rcom). * What we know so far is that we have found the * left comment char (lcom). * Make sure we haven't found '#' (lcom) immediately * preceded by '$' because we want to expand "$#". */ puttok(token); for (;;) { token[0] = t = getchr(); token[1] = EOS; if (match(t, rcom)) { puttok(token); break; } else { if (t == WEOF) error(gettext( "EOF in comment")); putchr(t); } } } else if (Cp == NULL) { putchr(t); } else if (t == '(') { if (Cp->plev) stkchr(t); else { /* skip white before arg */ while ((t = getchr()) != WEOF && is_space(t)) ; putbak(t); } ++Cp->plev; } else if (t == ')') { --Cp->plev; if (Cp->plev == 0) { stkchr(EOS); expand(Cp->argp, Ap-Cp->argp-1); op = *Cp->argp; Ap = Cp->argp-1; if (--Cp < callst) Cp = NULL; } else stkchr(t); } else if (t == ',' && Cp->plev <= 1) { stkchr(EOS); *Ap = op; if ((wchar_t *)(++Ap) >= astklm) { --Ap; error2(gettext( "more than %d items on argument stack"), stksize); } while ((t = getchr()) != WEOF && is_space(t)) ; putbak(t); } else { stkchr(t); } } if (Cp != NULL) error(gettext( "EOF in argument list")); delexit(exitstat, 1); return (0); }
/** Splits into at most maxfields. If maxfields is unspecified or 0, ** trailing empty matches are discarded. If maxfields is positive, ** no more than maxfields fields will be returned and trailing empty ** matches are preserved. If maxfields is empty, all fields (including ** trailing empty ones) are returned. This *should* be the same as the ** perl behaviour */ int PME::split(const std::string & s, unsigned maxfields) { /// stores the marks for the split vector<markers> oMarks; // this is a list of current trailing empty matches if maxfields is // unspecified or 0. If there is stuff in it and a non-empty match // is found, then everything in here is pushed into oMarks and then // the new match is pushed on. If the end of the string is reached // and there are empty matches in here, they are discarded. vector<markers> oCurrentTrailingEmpties; int nOffset = 0; unsigned int nMatchesFound = 0; // while we are still finding matches and maxfields is 0 or negative // (meaning we get all matches), or we haven't gotten to the number // of specified matches int nMatchStatus; while ( ( nMatchStatus = match ( s, nOffset ) ) && ( ( maxfields < 1 ) || nMatchesFound < maxfields ) ) { nMatchesFound++; // printf ( "nMatchesFound = %d\n", nMatchesFound ); // check to see if the match is empty if ( nOffset != m_marks [ 0 ].first ) { //fprintf ( stderr, "Match is not empty\n" ); // if this one isn't empty, then make sure to push anything from // oCurrentTrailingEmpties into oMarks oMarks.insert ( oMarks.end ( ), oCurrentTrailingEmpties.begin ( ), oCurrentTrailingEmpties.end ( ) ); // grab from nOffset to m_marks[0].first and again from m_marks[0].second to // the end of the string oMarks.push_back ( markers ( nOffset, m_marks [ 0 ].first ) ); } // else the match was empty and we have to do some checking // to see what to do else { //fprintf ( stderr, "match was empty\n" ); // if maxfields == 0, discard empty trailing matches if ( maxfields == 0 ) { //fprintf ( stderr, "putting empty into trailing empties list"); oCurrentTrailingEmpties.push_back ( markers ( nOffset, m_marks [ 0 ].first ) ); } // else we keep all the matches, empty or no else { //fprintf ( stderr, "Keeping empty match\n" ); // grab from nOffset to m_marks[0].first and again from m_marks[0].second to // the end of the string oMarks.push_back ( markers ( nOffset, m_marks [ 0 ].first ) ); } } // set nOffset to the beginning of the second part of the split nOffset = m_marks [ 0 ].second; fflush ( stdout ); } // end while ( match ( ... ) ) //fprintf ( stderr, "***match status = %d offset = %d\n", nMatchStatus, nOffset); // if there were no matches found, push the whole thing on if ( nMatchesFound == 0 ) { // printf ( "Putting the whole thing in..\n" ); oMarks.push_back ( markers ( 0, s.length ( ) ) ); } // if we ran out of matches, then append the rest of the string // onto the end of the last split field else if ( maxfields > 0 && nMatchesFound >= maxfields ) { // printf ( "Something else..\n" ); oMarks [ oMarks.size ( ) - 1 ].second = s.length ( ); } // else we have to add another entry for the end of the string else { // printf ( "Something REALLY else..\n" ); oMarks.push_back ( markers ( m_marks [ 0 ].second, s.length ( ) ) ); } m_marks = oMarks; //fprintf ( stderr, "match returning %d\n", m_marks.size ( ) ); nMatches = m_marks.size ( ); return m_marks.size ( ); }