/** * The /ns list command. * @param u The user who issued the command * @param MOD_CONT to continue processing other modules, MOD_STOP to stop processing. **/ static int do_list(User * u) { /* SADMINS can search for nicks based on their NS_VERBOTEN and NS_NO_EXPIRE * status. The keywords FORBIDDEN and NOEXPIRE represent these two states * respectively. These keywords should be included after the search pattern. * Multiple keywords are accepted and should be separated by spaces. Only one * of the keywords needs to match a nick's state for the nick to be displayed. * Forbidden nicks can be identified by "[Forbidden]" appearing in the last * seen address field. Nicks with NOEXPIRE set are preceeded by a "!". Only * SADMINS will be shown forbidden nicks and the "!" indicator. * Syntax for sadmins: LIST pattern [FORBIDDEN] [NOEXPIRE] * -TheShadow * * UPDATE: SUSPENDED keyword is now accepted as well. */ char *pattern = strtok(NULL, " "); char *keyword; NickAlias *na; NickCore *mync; int nnicks, i; char buf[BUFSIZE]; int is_servadmin = is_services_admin(u); int16 matchflags = 0; NickRequest *nr = NULL; int nronly = 0; int susp_keyword = 0; char noexpire_char = ' '; int count = 0, from = 0, to = 0, tofree = 0; char *tmp = NULL; char *s = NULL; if (!(!NSListOpersOnly || (is_oper(u)))) { /* reverse the help logic */ notice_lang(s_NickServ, u, ACCESS_DENIED); return MOD_STOP; } if (!pattern) { syntax_error(s_NickServ, u, "LIST", is_servadmin ? NICK_LIST_SERVADMIN_SYNTAX : NICK_LIST_SYNTAX); } else { if (pattern) { if (pattern[0] == '#') { tmp = myStrGetOnlyToken((pattern + 1), '-', 0); /* Read FROM out */ if (!tmp) { notice_lang(s_ChanServ, u, LIST_INCORRECT_RANGE); return MOD_CONT; } for (s = tmp; *s; s++) { if (!isdigit(*s)) { free(tmp); notice_lang(s_ChanServ, u, LIST_INCORRECT_RANGE); return MOD_CONT; } } from = atoi(tmp); free(tmp); tmp = myStrGetTokenRemainder(pattern, '-', 1); /* Read TO out */ if (!tmp) { notice_lang(s_ChanServ, u, LIST_INCORRECT_RANGE); return MOD_CONT; } for (s = tmp; *s; s++) { if (!isdigit(*s)) { free(tmp); notice_lang(s_ChanServ, u, LIST_INCORRECT_RANGE); return MOD_CONT; } } to = atoi(tmp); free(tmp); pattern = sstrdup("*"); tofree = 1; } } nnicks = 0; while (is_servadmin && (keyword = strtok(NULL, " "))) { if (stricmp(keyword, "FORBIDDEN") == 0) matchflags |= NS_VERBOTEN; if (stricmp(keyword, "NOEXPIRE") == 0) matchflags |= NS_NO_EXPIRE; if (stricmp(keyword, "SUSPENDED") == 0) susp_keyword = 1; if (stricmp(keyword, "UNCONFIRMED") == 0) nronly = 1; } mync = (nick_identified(u) ? u->na->nc : NULL); notice_lang(s_NickServ, u, NICK_LIST_HEADER, pattern); if (nronly != 1) { for (i = 0; i < 1024; i++) { for (na = nalists[i]; na; na = na->next) { /* Don't show private and forbidden nicks to non-services admins. */ if ((na->status & NS_VERBOTEN) && !is_servadmin) continue; if ((na->nc->flags & NI_PRIVATE) && !is_servadmin && na->nc != mync) continue; if ((matchflags != 0) && !(na->status & matchflags) && (susp_keyword == 0)) continue; else if ((susp_keyword == 1) && !(na->nc->flags & NI_SUSPENDED)) continue; /* We no longer compare the pattern against the output buffer. * Instead we build a nice nick!user@host buffer to compare. * The output is then generated separately. -TheShadow */ snprintf(buf, sizeof(buf), "%s!%s", na->nick, (na->last_usermask && !(na->status & NS_VERBOTEN)) ? na-> last_usermask : "*@*"); if (stricmp(pattern, na->nick) == 0 || match_wild_nocase(pattern, buf)) { if ((((count + 1 >= from) && (count + 1 <= to)) || ((from == 0) && (to == 0))) && (++nnicks <= NSListMax)) { if (is_servadmin && (na->status & NS_NO_EXPIRE)) noexpire_char = '!'; else { noexpire_char = ' '; } if ((na->nc->flags & NI_HIDE_MASK) && !is_servadmin && na->nc != mync) { snprintf(buf, sizeof(buf), "%-20s [Hostname Hidden]", na->nick); } else if (na->status & NS_VERBOTEN) { snprintf(buf, sizeof(buf), "%-20s [Forbidden]", na->nick); } else if (na->nc->flags & NI_SUSPENDED) { snprintf(buf, sizeof(buf), "%-20s [Suspended]", na->nick); } else { snprintf(buf, sizeof(buf), "%-20s %s", na->nick, na->last_usermask); } notice_user(s_NickServ, u, " %c%s", noexpire_char, buf); } count++; } } } } if (nronly == 1 || (is_servadmin && matchflags == 0 && susp_keyword == 0)) { noexpire_char = ' '; for (i = 0; i < 1024; i++) { for (nr = nrlists[i]; nr; nr = nr->next) { snprintf(buf, sizeof(buf), "%s!*@*", nr->nick); if (stricmp(pattern, nr->nick) == 0 || match_wild_nocase(pattern, buf)) { if (++nnicks <= NSListMax) { snprintf(buf, sizeof(buf), "%-20s [UNCONFIRMED]", nr->nick); notice_user(s_NickServ, u, " %c%s", noexpire_char, buf); } } } } } notice_lang(s_NickServ, u, NICK_LIST_RESULTS, nnicks > NSListMax ? NSListMax : nnicks, nnicks); } if (tofree) free(pattern); return MOD_CONT; }
enum command_type scan(char *buffer) { while(!feof(get_byte_argument)) { char c = get_byte(get_byte_argument); char d = get_byte(get_byte_argument); if(d == '#' && !strchr("\n\t ", c)) syntax_error(); ungetc(d, get_byte_argument); switch(c) { case '#': d = get_byte(get_byte_argument); while(d != '\n') { if(d == EOF) return SIMPLE_COMMAND; d = get_byte(get_byte_argument); } return scan(buffer); case '&': d = get_byte(get_byte_argument); if(d == '&') { eat_whitespace(); return AND_COMMAND; } else if(d == EOF) syntax_error(); else ungetc(d, get_byte_argument); break; case '(': { eat_whitespace(); return SUBSHELL_COMMAND; } case ')': { ungetc(c, get_byte_argument); return SIMPLE_COMMAND; } case '|': d = get_byte(get_byte_argument); if(d == '|') { eat_whitespace(); return OR_COMMAND; } else if(isalnum(d) || strchr("!%+,-./:@^_\t\n ", d)) { ungetc(d, get_byte_argument); eat_whitespace(); return PIPE_COMMAND; } else if(d == EOF) syntax_error(); case '\n': line_count++; case ';': case EOF: return SIMPLE_COMMAND; } buffer[strlen(buffer)] = c; } return SEQUENCE_COMMAND; }
int do_addnick(User * u) { NickAlias *na, *target; NickCore *nc; char *nick = strtok(NULL, " "); char *pass = strtok(NULL, " "); int i; char tsbuf[16]; char modes[512]; int len; if (NSEmailReg && (findrequestnick(u->nick))) { notice_lang(s_NickServ, u, NS_REQUESTED); return MOD_CONT; } if (readonly) { notice_lang(s_NickServ, u, NS_ADDNICK_DISABLED); return MOD_CONT; } if (checkDefCon(DEFCON_NO_NEW_NICKS)) { notice_lang(s_NickServ, u, OPER_DEFCON_DENIED); return MOD_CONT; } if (RestrictOperNicks) { for (i = 0; i < RootNumber; i++) { if (stristr(u->nick, ServicesRoots[i]) && !is_oper(u)) { notice_lang(s_NickServ, u, NICK_CANNOT_BE_REGISTERED, u->nick); return MOD_CONT; } } for (i = 0; i < servadmins.count && (nc = servadmins.list[i]); i++) { if (stristr(u->nick, nc->display) && !is_oper(u)) { notice_lang(s_NickServ, u, NICK_CANNOT_BE_REGISTERED, u->nick); return MOD_CONT; } } for (i = 0; i < servopers.count && (nc = servopers.list[i]); i++) { if (stristr(u->nick, nc->display) && !is_oper(u)) { notice_lang(s_NickServ, u, NICK_CANNOT_BE_REGISTERED, u->nick); return MOD_CONT; } } } if (!nick || !pass) { syntax_error(s_NickServ, u, "ADDNICK", NS_ADDNICK_SYNTAX); } else if (!(target = findnick(nick))) { notice_lang(s_NickServ, u, NICK_X_NOT_REGISTERED, nick); } else if (time(NULL) < u->lastnickreg + NSRegDelay) { notice_lang(s_NickServ, u, NS_ADDNICK_PLEASE_WAIT, NSRegDelay); } else if (u->na && (u->na->status & NS_VERBOTEN)) { alog("%s: %s@%s tried to use ADDNICK from forbidden nick %s.", s_NickServ, u->username, u->host, u->nick); notice_lang(s_NickServ, u, NICK_X_FORBIDDEN, u->nick); } else if (u->na && (u->na->nc->flags & NI_SUSPENDED)) { alog("%s: %s!%s@%s tried to use ADDNICK from suspended nick %s.", s_NickServ, u->nick, u->username, u->host, target->nick); notice_lang(s_NickServ, u, NICK_X_SUSPENDED, u->nick); } else if (u->na && NSNoGroupChange) { notice_lang(s_NickServ, u, NS_ADDNICK_CHANGE_DISABLED, s_NickServ); } else if (u->na && !nick_identified(u)) { notice_lang(s_NickServ, u, NICK_IDENTIFY_REQUIRED, s_NickServ); } else if (target && (target->nc->flags & NI_SUSPENDED)) { alog("%s: %s!%s@%s tried to use GROUP from SUSPENDED nick %s", s_NickServ, u->nick, u->username, u->host, target->nick); notice_lang(s_NickServ, u, NICK_X_SUSPENDED, target->nick); } else if (target->status & NS_VERBOTEN) { notice_lang(s_NickServ, u, NICK_X_FORBIDDEN, nick); } else if (u->na && target->nc == u->na->nc) { notice_lang(s_NickServ, u, NS_ADDNICK_SAME, target->nick); } else if (NSMaxAliases && (target->nc->aliases.count >= NSMaxAliases) && !nick_is_services_admin(target->nc)) { notice_lang(s_NickServ, u, NS_ADDNICK_TOO_MANY, target->nick, s_NickServ, s_NickServ); } else if (enc_check_password(pass, target->nc->pass) != 1) { alog("%s: Failed ADDNICK for %s!%s@%s (invalid password).", s_NickServ, u->nick, u->username, u->host); notice_lang(s_NickServ, u, PASSWORD_INCORRECT); bad_password(u); } else { /* If the nick is already registered, drop it. * If not, check that it is valid. */ if (u->na) { delnick(u->na); } else { int prefixlen = strlen(NSGuestNickPrefix); int nicklen = strlen(u->nick); if (nicklen <= prefixlen + 7 && nicklen >= prefixlen + 1 && stristr(u->nick, NSGuestNickPrefix) == u->nick && strspn(u->nick + prefixlen, "1234567890") == nicklen - prefixlen) { notice_lang(s_NickServ, u, NICK_CANNOT_BE_REGISTERED, u->nick); return MOD_CONT; } } na = makealias(u->nick, target->nc); if (na) { na->last_usermask = scalloc(strlen(common_get_vident(u)) + strlen(common_get_vhost(u)) + 2, 1); sprintf(na->last_usermask, "%s@%s", common_get_vident(u), common_get_vhost(u)); na->last_realname = sstrdup(u->realname); na->time_registered = na->last_seen = time(NULL); na->status = (int16) (NS_IDENTIFIED | NS_RECOGNIZED); if (!(na->nc->flags & NI_SERVICES_ROOT)) { for (i = 0; i < RootNumber; i++) { if (!stricmp(ServicesRoots[i], u->nick)) { na->nc->flags |= NI_SERVICES_ROOT; break; } } } u->na = na; na->u = u; #ifdef USE_RDB /* Is this really needed? Since this is a new alias it will get * its unique id on the next update, since it was previously * deleted by delnick. Must observe... */ if (rdb_open()) { rdb_save_ns_alias(na); rdb_close(); } #endif send_event(EVENT_GROUP, 1, u->nick); alog("%s: %s!%s@%s makes %s join group of %s (%s) (e-mail: %s)", s_NickServ, u->nick, u->username, u->host, u->nick, target->nick, target->nc->display, (target->nc->email ? target->nc->email : "none")); notice_lang(s_NickServ, u, NS_ADDNICK_SUCCESS, target->nick); u->lastnickreg = time(NULL); snprintf(tsbuf, sizeof(tsbuf), "%lu", (unsigned long int) u->timestamp); if (ircd->modeonreg) { len = strlen(ircd->modeonreg); strncpy(modes,ircd->modeonreg,512); if(ircd->rootmodeonid && is_services_root(u)) { strncat(modes,ircd->rootmodeonid,512-len); } else if(ircd->adminmodeonid && is_services_admin(u)) { strncat(modes,ircd->adminmodeonid,512-len); } else if(ircd->opermodeonid && is_services_oper(u)) { strncat(modes,ircd->opermodeonid,512-len); } if (ircd->tsonmode) { common_svsmode(u, modes, tsbuf); } else { common_svsmode(u, modes, NULL); } } check_memos(u); } else { alog("%s: makealias(%s) failed", s_NickServ, u->nick); notice_lang(s_NickServ, u, NS_ADDNICK_FAILED); } } return MOD_CONT; }
Term Yap_syntax_error(TokEntry *errtok, int sno) { return syntax_error(errtok, sno, CurrentModule); }
/** * The /hs set command. * @param u The user who issued the command * @param MOD_CONT to continue processing other modules, MOD_STOP to stop processing. **/ static int myDoSet(User * u) { char *nick = strtok(NULL, " "); char *rawhostmask = strtok(NULL, " "); char *hostmask = smalloc(HOSTMAX); NickAlias *na; int32 tmp_time; char *s; char *vIdent = NULL; if (!nick || !rawhostmask) { syntax_error(s_HostServ, u, "SET", HOST_SET_SYNTAX); free(hostmask); return MOD_CONT; } vIdent = myStrGetOnlyToken(rawhostmask, '@', 0); /* Get the first substring, @ as delimiter */ if (vIdent) { rawhostmask = myStrGetTokenRemainder(rawhostmask, '@', 1); /* get the remaining string */ if (!rawhostmask) { syntax_error(s_HostServ, u, "SET", HOST_SET_SYNTAX); free(vIdent); free(hostmask); return MOD_CONT; } if (strlen(vIdent) > USERMAX - 1) { notice_lang(s_HostServ, u, HOST_SET_IDENTTOOLONG, USERMAX); free(vIdent); free(rawhostmask); free(hostmask); return MOD_CONT; } else { for (s = vIdent; *s; s++) { if (!isvalidchar(*s)) { notice_lang(s_HostServ, u, HOST_SET_IDENT_ERROR); free(vIdent); free(rawhostmask); free(hostmask); return MOD_CONT; } } } if (!ircd->vident) { notice_lang(s_HostServ, u, HOST_NO_VIDENT); free(vIdent); free(rawhostmask); free(hostmask); return MOD_CONT; } } if (strlen(rawhostmask) < HOSTMAX) snprintf(hostmask, HOSTMAX, "%s", rawhostmask); else { notice_lang(s_HostServ, u, HOST_SET_TOOLONG, HOSTMAX); if (vIdent) { free(vIdent); free(rawhostmask); } free(hostmask); return MOD_CONT; } if (!isValidHost(hostmask, 3)) { notice_lang(s_HostServ, u, HOST_SET_ERROR); if (vIdent) { free(vIdent); free(rawhostmask); } free(hostmask); return MOD_CONT; } tmp_time = time(NULL); if ((na = findnick(nick))) { if (na->status & NS_VERBOTEN) { notice_lang(s_HostServ, u, NICK_X_FORBIDDEN, nick); if (vIdent) { free(vIdent); free(rawhostmask); } free(hostmask); return MOD_CONT; } if (vIdent && ircd->vident) { alog("vHost for user \002%s\002 set to \002%s@%s\002 by oper \002%s\002", nick, vIdent, hostmask, u->nick); } else { alog("vHost for user \002%s\002 set to \002%s\002 by oper \002%s\002", nick, hostmask, u->nick); } addHostCore(nick, vIdent, hostmask, u->nick, tmp_time); if (vIdent) { notice_lang(s_HostServ, u, HOST_IDENT_SET, nick, vIdent, hostmask); } else { notice_lang(s_HostServ, u, HOST_SET, nick, hostmask); } } else { notice_lang(s_HostServ, u, HOST_NOREG, nick); } free(hostmask); if (vIdent) { free(vIdent); free(rawhostmask); } return MOD_CONT; }
int validate (token_t *token_array) { int i = 0; int res = 1; int in_subshell = 0; int token_array_len = 0; while (!(token_array[i]->line_num == -1)) { token_array_len++; i++; } i = 0; while (i < token_array_len && !(token_array[i]->line_num == -1)) { char *operand = token_array[i]->word; // if (!is_char_validated(operand)) syntax_error(token_array[i]->line_num); if (!is_valid_operator(operand) && !is_valid_word(operand)) syntax_error(token_array[i]->line_num); if (operand[0] == '(') { in_subshell = 1; if (i + 1 >= token_array_len) { res = 0; syntax_error(token_array_len); } else { if (token_array[i + 1]->word[0] != ')') { token_t *sub_token_array = checked_malloc(sizeof (token_t) * 128); tokenize (token_array[i+1]->word, sub_token_array, token_array[i+1]->line_num); // int j = 0; // printf("subshell\n" ); // while (sub_token_array[j]->line_num != -1) { // printf ("token %d\n word:'%s' line_number:%d\n", j, sub_token_array[j]->word, sub_token_array[j]->line_num); // j++; // } if (validate (sub_token_array)) { i++; } } } i++; continue; } if (operand[0] == ')') { if (i - 1 < 0) { res = 0; syntax_error(0); } else { if (!in_subshell) { res = 0; // error_number = (i - 1 >= 0) ? token_array[i - 1]->line_num: token_array[i]->line_num; syntax_error(token_array[i]->line_num); } else { in_subshell = 0; } } i++; continue; } if (!strcmp(operand, ";") || !strcmp(operand, "||") || !strcmp(operand, "|") || !strcmp(operand, "&&")) { if (i - 1 < 0) { res = 0; syntax_error(token_array[i]->line_num); } // else // { // if // } if (!strcmp(operand, ";")) { if (i < token_array_len - 1 && (!strcmp(token_array[i + 1]->word, "&&") || !strcmp(token_array[i + 1]->word, "||") || !strcmp(token_array[i + 1]->word, "|") || token_array[i + 1]->word[0] == '>' || token_array[i + 1]->word[0] == '<' || !strcmp(token_array[i+1]->word, ";"))) { res = 0; syntax_error(token_array[i]->line_num); } if (i >= token_array_len - 1) { res = 0; syntax_error(token_array[i]->line_num); } if (i - 1 >= 0) { char *tmp = token_array[i - 1]->word; int j = strlen(tmp) - 1; while (j >= 0) { if (tmp[j] == ' ' || tmp[j] == '\t') {j--; continue;} if (tmp[j] == '>' || tmp[j] == '<') { res = 0; syntax_error(token_array[i - 1]->line_num); } j--; } } } else { if (i < token_array_len - 1 && (!strcmp(token_array[i + 1]->word, "&&") || !strcmp(token_array[i + 1]->word, "||") || !strcmp(token_array[i + 1]->word, "|") )) { res = 0; syntax_error(token_array[i]->line_num); } if (i >= token_array_len - 1) { res = 0; syntax_error(token_array[i]->line_num); } } } if (!strcmp(operand, "<") || !strcmp(operand, ">")) { if (i == token_array_len - 1 || i == 0) { res = 0; syntax_error(token_array[i]->line_num); } else { if (!strcmp(token_array[i+1]->word, ">") || !strcmp(token_array[i+1]->word, "<")) { res = 0; syntax_error(token_array[i]->line_num); } } } i++; } return res; }
static int syntax_error_and_return(int line_nb) { syntax_error(line_nb); return (1); }
int eat_int(tokenizer_t t){ token tok = cur_tok(t); if(tok.kind != tok_int) syntax_error(t); next_tok(t); return tok.ival; }
void eat_plus(tokenizer_t t){ token tok = cur_tok(t); if (tok.kind != tok_plus) syntax_error(t); next_tok(t); }
/** * ChanKill - Akill an entire channel (got botnet?) * * /msg OperServ ChanKill +expire #channel reason * @param u The user who issued the command * @param MOD_CONT to continue processing other modules, MOD_STOP to stop processing. * **/ int do_chankill(User * u) { char *expiry, *channel, *reason; time_t expires; char breason[BUFSIZE]; char mask[USERMAX + HOSTMAX + 2]; struct c_userlist *cu, *next; Channel *c; channel = strtok(NULL, " "); if (channel && *channel == '+') { expiry = channel; channel = strtok(NULL, " "); } else { expiry = NULL; } expires = expiry ? dotime(expiry) : ChankillExpiry; if (expiry && isdigit(expiry[strlen(expiry) - 1])) expires *= 86400; if (expires != 0 && expires < 60) { notice_lang(s_OperServ, u, BAD_EXPIRY_TIME); return MOD_CONT; } else if (expires > 0) { expires += time(NULL); } if (channel && (reason = strtok(NULL, ""))) { if (AddAkiller) { snprintf(breason, sizeof(breason), "[%s] %s", u->nick, reason); reason = sstrdup(breason); } if ((c = findchan(channel))) { for (cu = c->users; cu; cu = next) { next = cu->next; if (is_oper(cu->user)) { continue; } (void) strncpy(mask, "*@", 3); /* Use *@" for the akill's, */ strncat(mask, cu->user->host, HOSTMAX); add_akill(NULL, mask, s_OperServ, expires, reason); check_akill(cu->user->nick, cu->user->username, cu->user->host, NULL, NULL); } if (WallOSAkill) { xanadu_cmd_global(s_OperServ, "%s used CHANKILL on %s (%s)", u->nick, channel, reason); } } else { notice_lang(s_OperServ, u, CHAN_X_NOT_IN_USE, channel); } if (AddAkiller) { free(reason); } } else { syntax_error(s_OperServ, u, "CHANKILL", OPER_CHANKILL_SYNTAX); } return MOD_CONT; }
std::vector<command> parse_line() { line = ""; std::vector<command> pipes; std::vector<std::string> argvs; std::string argv, file1, file2; int file_num = 0, pipe_num = 1; int user_out = 0, user_in = 0; while(true) { char c = std::cin.get(); if(!std::cin.good() || std::cin.eof()) exit(0); if(c != '\n' && c != '\r') line.push_back(c); //if(c == '"') //{ // std::getline(std::cin, argv, '"'); // line += argv; //} //else if(c == '\'') //{ // std::getline(std::cin, argv, '\''); // line += argv; //} if(c == ' ' || c == '|' || c == '\n') { if(argv.size() != 0) { argv.erase(std::remove(argv.begin(), argv.end(), '\r'), argv.end()); argvs.push_back(argv); argv = ""; } } if(c == ' ' || c == '\r') {} else if(c == '/') { syntax_error(c); argv = ""; file1 = ""; file2 = ""; user_out = 0; user_in = 0; argvs.resize(0); pipes.resize(0); file_num=0; pipe_num=1; } else if(c == '|') { while(true) { char nc = std::cin.peek(); if(nc >= 48 && nc <= 57)// is 0~9 argv.push_back(std::cin.get()); else break; } pipe_num = std::atoi(argv.c_str()); if(pipe_num == 0) pipe_num = 1; pipes.push_back({pipe_num, 0, false, argvs, file1, file2, user_out, user_in}); line += argv; argv = ""; file1 = ""; file2 = ""; user_out = 0; user_in = 0; argvs.resize(0); pipe_num = 1; } else if(c == '>') { int file_num = 1; // ls >f, ls > f if(argv.size() != 0) { // ls 2> f, ls 2>f int num = std::atoi(argv.c_str()); if(num == 0) // ls>f argvs.push_back(argv); else file_num = num; } line += argv; argv = ""; int tag = parse_next_word(argv); if( tag == 0) { syntax_error(std::cin.peek()); pipes.resize(0); argvs.resize(0); } int to_user = atoi(argv.c_str()); if(tag == 1 || to_user == 0) // file { if(file_num == 1) file1 = argv; else file2 = argv; } else { user_out = to_user; } argv = ""; } else if(c == '<') { int file_num = 1; // ls >f, ls > f if(argv.size() != 0) { // ls 2> f, ls 2>f int num = std::atoi(argv.c_str()); if(num == 0) // ls>f argvs.push_back(argv); else file_num = num; } line += argv; argv = ""; int tag = parse_next_word(argv); if( tag == 0) { syntax_error(std::cin.peek()); pipes.resize(0); argvs.resize(0); } int to_user = atoi(argv.c_str()); if(tag == 1 || to_user == 0) // file {} else { user_in = to_user; } argv = ""; } else if(c == '\n') { if(argvs.size() > 0) pipes.push_back({pipe_num, 0, true, argvs, file1, file2, user_out, user_in}); break; } else argv.push_back(c); } return pipes; }
void zzsyn(char * text, int tok, char * egroup, SetWordType * eset, int etok, int k, char * bad_text) { static char msg [MAX_ERROR]; int len; #ifndef ALLOW_WARNINGS text = NULL; /* avoid "unused parameter" warning */ #endif /* Initial message: give location of error */ msg[0] = (char) 0; /* make sure string is empty to start! */ if (tok == zzEOF_TOKEN) strcat (msg, "at end of input"); else sprintf (msg, "found \"%s\"", bad_text); len = strlen (msg); /* Caller supplied neither a single token nor set of tokens expected... */ if (!etok && !eset) { syntax_error (msg); return; } else { strcat (msg, ", "); len += 2; } /* I'm not quite sure what this is all about, or where k would be != 1... */ if (k != 1) { sprintf (msg+len, "; \"%s\" not", bad_text); if (zzset_deg (eset) > 1) strcat (msg, " in"); len = strlen (msg); } /* This is the code that usually gets run */ if (zzset_deg (eset) > 0) { if (zzset_deg (eset) == 1) strcat (msg, "expected "); else strcat (msg, "expected one of: "); append_token_set (msg, eset); } else { sprintf (msg+len, "expected %s", zztokens[etok]); if (etok == ENTRY_CLOSE) { strcat (msg, " (skipping to next \"@\")"); initialize_lexer_state (); } } len = strlen (msg); if (egroup && strlen (egroup) > 0) sprintf (msg+len, " in %s", egroup); syntax_error (msg); }
/** * The /ns saset command. * @param u The user who issued the command * @param MOD_CONT to continue processing other modules, MOD_STOP to stop processing. **/ static int do_saset(User * u) { char *nick = strtok(NULL, " "); char *cmd = strtok(NULL, " "); char *param = strtok(NULL, " "); NickAlias *na; if (readonly) { notice_lang(s_NickServ, u, NICK_SASET_DISABLED); return MOD_CONT; } if (!nick) { syntax_error(s_NickServ, u, "SASET", NICK_SASET_SYNTAX); return MOD_CONT; } if (!(na = findnick(nick))) { notice_lang(s_NickServ, u, NICK_SASET_BAD_NICK, nick); return MOD_CONT; } if (!param && (!cmd || (stricmp(cmd, "URL") != 0 && stricmp(cmd, "EMAIL") != 0 && stricmp(cmd, "GREET") != 0 && stricmp(cmd, "ICQ") != 0))) { syntax_error(s_NickServ, u, "SASET", NICK_SASET_SYNTAX); } else if (!na) { notice_lang(s_NickServ, u, NICK_NOT_REGISTERED, nick); } else if (na->status & NS_VERBOTEN) { notice_lang(s_NickServ, u, NICK_X_FORBIDDEN, na->nick); } else if (na->nc->flags & NI_SUSPENDED) { notice_lang(s_NickServ, u, NICK_X_SUSPENDED, na->nick); } else if (stricmp(cmd, "DISPLAY") == 0) { do_saset_display(u, na->nc, param); } else if (stricmp(cmd, "PASSWORD") == 0) { do_saset_password(u, na->nc, param); } else if (stricmp(cmd, "URL") == 0) { do_saset_url(u, na->nc, param); } else if (stricmp(cmd, "EMAIL") == 0) { do_saset_email(u, na->nc, param); } else if (stricmp(cmd, "ICQ") == 0) { do_saset_icq(u, na->nc, param); } else if (stricmp(cmd, "GREET") == 0) { do_saset_greet(u, na->nc, param); } else if (stricmp(cmd, "KILL") == 0) { do_saset_kill(u, na->nc, param); } else if (stricmp(cmd, "SECURE") == 0) { do_saset_secure(u, na->nc, param); } else if (stricmp(cmd, "PRIVATE") == 0) { do_saset_private(u, na->nc, param); } else if (stricmp(cmd, "MSG") == 0) { do_saset_msg(u, na->nc, param); } else if (stricmp(cmd, "HIDE") == 0) { do_saset_hide(u, na->nc, param); } else if (stricmp(cmd, "NOEXPIRE") == 0) { do_saset_noexpire(u, na, param); } else if (stricmp(cmd, "AUTOOP") == 0) { do_saset_autoop(u, na->nc, param); } else if (stricmp(cmd, "LANGUAGE") == 0) { do_saset_language(u, na->nc, param); } else { notice_lang(s_NickServ, u, NICK_SASET_UNKNOWN_OPTION, cmd); } return MOD_CONT; }
static foreign_t turtle_read_string(term_t C0, term_t Stream, term_t C, term_t Value) { int c; charbuf b; IOSTREAM *in; int endlen = 1; if ( !PL_get_integer(C0, &c) ) return type_error(C0, "code"); if ( c != '"' ) return FALSE; if ( !PL_get_stream_handle(Stream, &in) ) return FALSE; init_charbuf(&b); c = Sgetcode(in); if ( c == '"' ) { c = Sgetcode(in); if ( c == '"' ) /* """...""" */ { endlen = 3; c = Sgetcode(in); } else { PL_release_stream(in); return (PL_unify_integer(C, c) && PL_unify_atom(Value, ATOM_)); } } for(;;c = Sgetcode(in)) { if ( c == -1 ) { free_charbuf(&b); PL_release_stream(in); return syntax_error("eof_in_string", in); } else if ( c == '"' ) { int count = 1; for(count=1; count<endlen; ) { if ( (c=Sgetcode(in)) == '"' ) count++; else break; } if ( count == endlen ) { int rc; c = Sgetcode(in); rc = (PL_unify_integer(C, c) && PL_unify_wchars(Value, PL_ATOM, b.here-b.base, b.base)); free_charbuf(&b); PL_release_stream(in); return rc; } while(count-- > 0) add_charbuf(&b, '"'); add_charbuf(&b, c); } else if ( c == '\\' ) { int esc; c = Sgetcode(in); if ( !string_escape(in, c, &esc) ) { free_charbuf(&b); PL_release_stream(in); return FALSE; } add_charbuf(&b, esc); } else { add_charbuf(&b, c); } } }
static int do_akill(User * u) { char *cmd = strtok(NULL, " "); char breason[BUFSIZE]; if (!cmd) cmd = ""; if (!stricmp(cmd, "ADD")) { int deleted = 0; char *expiry, *mask, *reason; time_t expires, now = time(NULL); mask = strtok(NULL, " "); if (mask && *mask == '+') { expiry = mask; mask = strtok(NULL, " "); } else { expiry = NULL; } expires = expiry ? dotime(expiry) : AutokillExpiry; /* If the expiry given does not contain a final letter, it's in days, * said the doc. Ah well. */ if (expiry && isdigit(expiry[strlen(expiry) - 1])) expires *= 86400; /* Do not allow less than a minute expiry time */ if (expires != 0 && expires < 60) { notice_lang(s_OperServ, u, BAD_EXPIRY_TIME); return MOD_CONT; } else if (expires > 0) { expires += time(NULL); } if (mask && (reason = strtok(NULL, ""))) { /* We first do some sanity check on the proposed mask. */ if (strchr(mask, '!')) { notice_lang(s_OperServ, u, OPER_AKILL_NO_NICK); return MOD_CONT; } if (!strchr(mask, '@')) { notice_lang(s_OperServ, u, BAD_USERHOST_MASK); return MOD_CONT; } if (mask && strspn(mask, "~@.*?") == strlen(mask)) { notice_lang(s_OperServ, u, USERHOST_MASK_TOO_WIDE, mask); return MOD_CONT; } /** * Changed sprintf() to snprintf()and increased the size of * breason to match bufsize * -Rob **/ if (AddAkiller) { snprintf(breason, sizeof(breason), "[%s] %s", u->nick, reason); reason = sstrdup(breason); } deleted = add_akill(u, mask, u->nick, expires, reason); if (deleted < 0) { if (AddAkiller) { free(reason); } return MOD_CONT; } else if (deleted) { notice_lang(s_OperServ, u, OPER_AKILL_DELETED_SEVERAL, deleted); } notice_lang(s_OperServ, u, OPER_AKILL_ADDED, mask); if (WallOSAkill) { char buf[128]; if (!expires) { strcpy(buf, "does not expire"); } else { int wall_expiry = expires - now; char *s = NULL; if (wall_expiry >= 86400) { wall_expiry /= 86400; s = "day"; } else if (wall_expiry >= 3600) { wall_expiry /= 3600; s = "hour"; } else if (wall_expiry >= 60) { wall_expiry /= 60; s = "minute"; } snprintf(buf, sizeof(buf), "expires in %d %s%s", wall_expiry, s, (wall_expiry == 1) ? "" : "s"); } anope_cmd_global(s_OperServ, "%s added an AKILL for %s (%s) (%s)", u->nick, mask, reason, buf); } if (readonly) { notice_lang(s_OperServ, u, READ_ONLY_MODE); } if (AddAkiller) { free(reason); } } else { syntax_error(s_OperServ, u, "AKILL", OPER_AKILL_SYNTAX); } } else if (!stricmp(cmd, "DEL")) { char *mask; int res = 0; mask = strtok(NULL, " "); if (!mask) { syntax_error(s_OperServ, u, "AKILL", OPER_AKILL_SYNTAX); return MOD_CONT; } if (akills.count == 0) { notice_lang(s_OperServ, u, OPER_AKILL_LIST_EMPTY); return MOD_CONT; } if (isdigit(*mask) && strspn(mask, "1234567890,-") == strlen(mask)) { /* Deleting a range */ res = slist_delete_range(&akills, mask, NULL); if (res == 0) { notice_lang(s_OperServ, u, OPER_AKILL_NO_MATCH); return MOD_CONT; } else if (res == 1) { notice_lang(s_OperServ, u, OPER_AKILL_DELETED_ONE); } else { notice_lang(s_OperServ, u, OPER_AKILL_DELETED_SEVERAL, res); } } else { if ((res = slist_indexof(&akills, mask)) == -1) { notice_lang(s_OperServ, u, OPER_AKILL_NOT_FOUND, mask); return MOD_CONT; } slist_delete(&akills, res); notice_lang(s_OperServ, u, OPER_AKILL_DELETED, mask); } if (readonly) notice_lang(s_OperServ, u, READ_ONLY_MODE); } else if (!stricmp(cmd, "LIST")) { char *mask; int res, sent_header = 0; if (akills.count == 0) { notice_lang(s_OperServ, u, OPER_AKILL_LIST_EMPTY); return MOD_CONT; } mask = strtok(NULL, " "); if (!mask || (isdigit(*mask) && strspn(mask, "1234567890,-") == strlen(mask))) { res = slist_enum(&akills, mask, &akill_list_callback, u, &sent_header); if (res == 0) { notice_lang(s_OperServ, u, OPER_AKILL_NO_MATCH); return MOD_CONT; } else { notice_lang(s_OperServ, u, END_OF_ANY_LIST, "Akill"); } } else { int i; char amask[BUFSIZE]; for (i = 0; i < akills.count; i++) { snprintf(amask, sizeof(amask), "%s@%s", ((Akill *) akills.list[i])->user, ((Akill *) akills.list[i])->host); if (!stricmp(mask, amask) || match_wild_nocase(mask, amask)) akill_list(i + 1, akills.list[i], u, &sent_header); } if (!sent_header) notice_lang(s_OperServ, u, OPER_AKILL_NO_MATCH); else { notice_lang(s_OperServ, u, END_OF_ANY_LIST, "Akill"); } } } else if (!stricmp(cmd, "VIEW")) { char *mask; int res, sent_header = 0; if (akills.count == 0) { notice_lang(s_OperServ, u, OPER_AKILL_LIST_EMPTY); return MOD_CONT; } mask = strtok(NULL, " "); if (!mask || (isdigit(*mask) && strspn(mask, "1234567890,-") == strlen(mask))) { res = slist_enum(&akills, mask, &akill_view_callback, u, &sent_header); if (res == 0) { notice_lang(s_OperServ, u, OPER_AKILL_NO_MATCH); return MOD_CONT; } } else { int i; char amask[BUFSIZE]; for (i = 0; i < akills.count; i++) { snprintf(amask, sizeof(amask), "%s@%s", ((Akill *) akills.list[i])->user, ((Akill *) akills.list[i])->host); if (!stricmp(mask, amask) || match_wild_nocase(mask, amask)) akill_view(i + 1, akills.list[i], u, &sent_header); } if (!sent_header) notice_lang(s_OperServ, u, OPER_AKILL_NO_MATCH); } } else if (!stricmp(cmd, "CLEAR")) { slist_clear(&akills, 1); notice_lang(s_OperServ, u, OPER_AKILL_CLEAR); } else { syntax_error(s_OperServ, u, "AKILL", OPER_AKILL_SYNTAX); } return MOD_CONT; }
tokenizer_t tokenize(tokenizer_t t){ int i = 0, c = t->c; char a[10]; FILE *fp = t->fp; if (t->num > 50) syntax_error(t); while (c == ' '){//スペース飛ばす t->error[t->num] = c; t->num++; c = fgetc(fp); } if (!isdigit(c)){//数字じゃない時 t->error[t->num] = c; t->num++; switch (c){ case '+': t->tok.kind = TOK_PLUS; break; case '(': t->tok.kind = TOK_LPAREN; break; case ')': t->tok.kind = TOK_RPAREN; break; case '{': t->tok.kind = TOK_LBRACE; break; case '}': t->tok.kind = TOK_RBRACE; break; case '*': t->tok.kind = TOK_MUL; break; case '-': t->tok.kind = TOK_MINUS; break; case '/': t->tok.kind = TOK_DIV; break; case '%': t->tok.kind = TOK_REM; break; case '!': t->tok.kind = TOK_BANG; break; case '<': t->tok.kind = TOK_LT; break; case '>': t->tok.kind = TOK_GT; break; case '=': t->tok.kind = TOK_EQ; break; case ';': t->tok.kind = TOK_SEMICOLON; break; case ',': t->tok.kind = TOK_COMMA; break; case '\n': t->tok.kind = tok_nl; t->line++; memset(t->error, 0, 50); break; case EOF: t->tok.kind = tok_eof; break; default: t->tok.kind = tok_other; break; } t->c = fgetc(fp); t->fp = fp; return t; } while(isdigit(c)){ t->error[t->num] = c; t->num++; if (i== 9) syntax_error(t); a[i++] = (char)c; c = fgetc(fp); } t->c = c; t->fp = fp; t->tok.kind = tok_int; a[i] = 0; t->tok.ival = atoi(a); return t; }
int main(int argc, const char **argv) { if (argc < 3) return syntax_error(argv, 5); int csize = atoi(argv[1]), climit0 = atoi(argv[2]); if (csize < 1 || csize > 4) return syntax_error(argv, 6); if (climit0 < 0) return syntax_error(argv, 7); int exit_code = 0; size_t count = 0; size_t cmax = csize == 4 ? 0xffffffff : 0xffffffff & ((1 << (csize * 8)) - 1); size_t climit = climit0 ? S_MIN((size_t)climit0, cmax) : cmax; #ifdef COUNTER_USE_BITSET #define COUNTER_SET(val) sb_set(&bs, val) #define COUNTER_POPCOUNT sb_popcount(bs) sb_t *bs = sb_alloc(0); sb_eval(&bs, cmax); #else #define COUNTER_SET(val) sm_uu32_insert(&m, val, 1) #define COUNTER_POPCOUNT sm_size(m) sm_t *m = sm_alloc(SM_U32U32, 0); #endif unsigned char buf[3 * 4 * 128]; int i; ssize_t l; for (;;) { l = read(0, buf, sizeof(buf)); l = (l / csize) * csize; if (l <= 0) break; #define CNTLOOP(inc, val) \ for (i = 0; i < l; i += inc) { \ COUNTER_SET(val); \ count++; \ if (COUNTER_POPCOUNT >= climit) \ goto done; \ } switch (csize) { case 1: CNTLOOP(1, buf[i]); break; case 2: CNTLOOP(2, (size_t)(buf[i] << 8 | buf[i + 1])); break; case 3: CNTLOOP(3, (size_t)(buf[i] << 16 | buf[i + 1] << 8 | buf[i + 2])); break; case 4: CNTLOOP(4, (size_t)buf[i] << 24 | (size_t)buf[i + 1] << 16 | (size_t)buf[i + 2] << 8 | (size_t)buf[i + 3]); break; default: goto done; } #undef CNTLOOP } done: printf(FMT_ZU ", " FMT_ZU, count, COUNTER_POPCOUNT); #ifdef COUNTER_USE_BITSET sb_free(&bs); #else sm_free(&m); #endif return exit_code; }
static void do_clearmodes(User * u) { int i, all; int count; /* For saving ban info */ char *s; char *argv[3]; char *chan; Channel *c; Ban **bans; /* For saving ban info */ struct c_userlist *cu, *next; chan = strtok(NULL, " "); all = 0; if (!chan) { syntax_error(s_OperServ, u, "CLEARMODES", OPER_CLEARMODES_SYNTAX); } else if (!(c = findchan(chan))) { notice_lang(s_OperServ, u, CHAN_X_NOT_IN_USE, chan); } else if (c->bouncy_modes) { notice_lang(s_OperServ, u, OPER_BOUNCY_MODES_U_LINE); return; } else { s = strtok(NULL, " "); if (s) { if (stricmp(s, "ALL") == 0) { all = 1; } else { syntax_error(s_OperServ, u, "CLEARMODES", OPER_CLEARMODES_SYNTAX); return; } } if (WallOSClearmodes) { wallops(s_OperServ, "%s used CLEARMODES%s on %s", u->nick, all ? " ALL" : "", chan); } if (all) { /* Clear mode +o */ for (cu = c->chanops; cu; cu = next) { next = cu->next; argv[0] = sstrdup(chan); argv[1] = sstrdup("-o"); argv[2] = sstrdup(cu->user->nick); send_cmd(MODE_SENDER(s_ChanServ), "MODE %s %s :%s", argv[0], argv[1], argv[2]); do_cmode(s_ChanServ, 3, argv); free(argv[2]); free(argv[1]); free(argv[0]); } /* Clear mode +v */ for (cu = c->voices; cu; cu = next) { next = cu->next; argv[0] = sstrdup(chan); argv[1] = sstrdup("-v"); argv[2] = sstrdup(cu->user->nick); send_cmd(MODE_SENDER(s_ChanServ), "MODE %s %s :%s", argv[0], argv[1], argv[2]); do_cmode(s_ChanServ, 3, argv); free(argv[2]); free(argv[1]); free(argv[0]); } } /* Clear modes */ send_cmd(MODE_SENDER(s_OperServ), "MODE %s -ciklmMnOpsRt :%s", chan, c->key ? c->key : ""); argv[0] = sstrdup(chan); argv[1] = sstrdup("-ciklmMnOpsRt"); argv[2] = c->key ? c->key : sstrdup(""); do_cmode(s_OperServ, 2, argv); free(argv[0]); free(argv[1]); free(argv[2]); c->key = NULL; c->limit = 0; /* Clear bans */ count = c->bancount; bans = smalloc(sizeof(Ban *) * count); for (i = 0; i < count; i++) { bans[i] = smalloc(sizeof(Ban)); bans[i]->mask = sstrdup(c->newbans[i]->mask); } for (i = 0; i < count; i++) { argv[0] = sstrdup(chan); argv[1] = sstrdup("-b"); argv[2] = bans[i]->mask; send_cmd(MODE_SENDER(s_OperServ), "MODE %s %s :%s", argv[0], argv[1], argv[2]); do_cmode(s_OperServ, 3, argv); free(argv[2]); free(argv[1]); free(argv[0]); free(bans[i]); } free(bans); if (all) { notice_lang(s_OperServ, u, OPER_CLEARMODES_ALL_DONE, chan); } else { notice_lang(s_OperServ, u, OPER_CLEARMODES_DONE, chan); } } }
void block(char *name, int level) { LIST *S = (LIST*)malloc(sizeof(LIST)); SYMBOL *tmp = NULL; /* initial block call */ if(is_program_block == 1) { is_program_block = 0; if(token == TK_LBRAC) { debug(level,"BLOCK"); push_scope(name); new_function(name, PROG); debug_lex(level+1); declerations(level+1); subprograms(level+1); tmp = lookup(name); tmp->func.genquad = qlabel; main_start_quad = qlabel; genquad("begin_block", program_name, "_", "_"); sequence(S, level+1); if(token == TK_RBRAC) { pop_scope(); debug_lex(); } else { /* syntax error lpar expected */ syntax_error("a '}' expected"); } } else { /* syntax error rpar expected */ syntax_error("'{' expected"); } backpatch(S->next, int2string(nextquad())); genquad("halt", "_", "_", "_"); genquad("end_block", program_name, "_", "_"); } else { if(token == TK_LBRAC) { debug(level,"BLOCK"); debug_lex(level+1); declerations(level+1); subprograms(level+1); tmp = lookup(name); tmp->func.genquad = qlabel; genquad("begin_block", name, "_", "_"); fprintf(stderr, "quad quad %s %d\n", tmp->name, tmp->func.genquad); sequence(S, level+1); if(token == TK_RBRAC) { if (!strcmp(assembly, "x86")) { generate_final_x86( program_name); } else { generate_final( program_name); } pop_scope(); debug_lex(); } else { /* syntax error lpar expected */ syntax_error("a '}' expected"); } } else { /* syntax error rpar expected */ syntax_error("'{' expected"); } backpatch(S->next, int2string(nextquad())); genquad("end_block", name,"_", "_"); } }
static void do_oper(User * u) { MYSQL_ROW row; unsigned int nick_id, fields, rows, err; MYSQL_RES *result; char *cmd, *nick; cmd = strtok(NULL, " "); if (!cmd) cmd = ""; if (stricmp(cmd, "ADD") == 0) { if (!is_services_admin(u)) { notice_lang(s_OperServ, u, PERMISSION_DENIED); return; } nick = strtok(NULL, " "); if (nick) { if (!(nick_id = mysql_findnick(nick))) { notice_lang(s_OperServ, u, NICK_X_NOT_REGISTERED, nick); return; } else if (num_serv_opers() >= MAX_SERVOPERS) { notice_lang(s_OperServ, u, OPER_OPER_TOO_MANY, MAX_SERVOPERS); return; } nick_id = mysql_getlink(nick_id); result = mysql_simple_query(mysqlconn, &err, "INSERT INTO oper (nick_id) VALUES (%u)", nick_id); switch (err) { case 0: mysql_free_result(result); notice_lang(s_OperServ, u, OPER_OPER_ADDED, nick); break; case ER_DUP_ENTRY: notice_lang(s_OperServ, u, OPER_OPER_EXISTS, nick); break; default: handle_mysql_error(mysqlconn, "insert_oper"); break; /* never reached */ } } else { syntax_error(s_OperServ, u, "OPER", OPER_OPER_ADD_SYNTAX); } } else if (stricmp(cmd, "DEL") == 0) { if (!is_services_admin(u)) { notice_lang(s_OperServ, u, PERMISSION_DENIED); return; } nick = strtok(NULL, " "); if (nick) { if (!(nick_id = mysql_findnick(nick))) { notice_lang(s_OperServ, u, NICK_X_NOT_REGISTERED, nick); return; } nick_id = mysql_getlink(nick_id); result = smysql_bulk_query(mysqlconn, &fields, &rows, "DELETE FROM oper WHERE nick_id=%u", nick_id); if (rows) { notice_lang(s_OperServ, u, OPER_OPER_REMOVED, nick); } else { notice_lang(s_OperServ, u, OPER_OPER_NOT_FOUND, nick); } mysql_free_result(result); } else { syntax_error(s_OperServ, u, "OPER", OPER_OPER_DEL_SYNTAX); } } else if (stricmp(cmd, "LIST") == 0) { notice_lang(s_OperServ, u, OPER_OPER_LIST_HEADER); result = smysql_bulk_query(mysqlconn, &fields, &rows, "SELECT nick.nick FROM nick, oper " "WHERE nick.nick_id=oper.nick_id ORDER BY nick.nick"); while ((row = smysql_fetch_row(mysqlconn, result))) notice(s_OperServ, u->nick, "%s", row[0]); } else { syntax_error(s_OperServ, u, "OPER", OPER_OPER_SYNTAX); } }
/* This does the dirty work. gc_currently_forbidden is 1 when this is called. */ int button_item_to_widget_value(Lisp_Object gui_object_instance, Lisp_Object gui_item, widget_value * wv, int allow_text_field_p, int no_keys_p, int menu_entry_p, int accel_p) { /* This function cannot GC because gc_currently_forbidden is set when it's called */ Lisp_Gui_Item *pgui = 0; /* degenerate case */ if (STRINGP(gui_item)) { wv->type = TEXT_TYPE; if (accel_p) wv->name = add_accel_and_to_external(gui_item); else LISP_STRING_TO_EXTERNAL_MALLOC(gui_item, wv->name, Qlwlib_encoding); return 1; } else if (!GUI_ITEMP(gui_item)) syntax_error("need a string or a gui_item here", gui_item); pgui = XGUI_ITEM(gui_item); if (!NILP(pgui->filter)) syntax_error(":filter keyword not permitted on leaf nodes", gui_item); #ifdef HAVE_MENUBARS if (menu_entry_p && !gui_item_included_p(gui_item, Vmenubar_configuration)) { /* the include specification says to ignore this item. */ return 0; } #endif /* HAVE_MENUBARS */ if (!STRINGP(pgui->name)) pgui->name = Feval(pgui->name); CHECK_STRING(pgui->name); if (accel_p) { Lisp_Object tmp = gui_item_accelerator(gui_item); wv->name = add_accel_and_to_external(pgui->name); wv->accel = LISP_TO_VOID(tmp); } else { LISP_STRING_TO_EXTERNAL_MALLOC(pgui->name, wv->name, Qlwlib_encoding); wv->accel = LISP_TO_VOID(Qnil); } if (!NILP(pgui->suffix)) { Lisp_Object suffix2; /* Shortcut to avoid evaluating suffix each time */ if (STRINGP(pgui->suffix)) suffix2 = pgui->suffix; else { suffix2 = Feval(pgui->suffix); CHECK_STRING(suffix2); } LISP_STRING_TO_EXTERNAL_MALLOC(suffix2, wv->value, Qlwlib_encoding); } wv_set_evalable_slot(wv->enabled, pgui->active); wv_set_evalable_slot(wv->selected, pgui->selected); if (!NILP(pgui->callback) || !NILP(pgui->callback_ex)) { Lisp_Object tmp = cons3(gui_object_instance, pgui->callback, pgui->callback_ex); wv->call_data = LISP_TO_VOID(tmp); } if (no_keys_p #ifdef HAVE_MENUBARS || (menu_entry_p && !menubar_show_keybindings) #endif ) { wv->key = 0; } else if (!NILP(pgui->keys)) { /* Use this string to generate key bindings */ CHECK_STRING(pgui->keys); pgui->keys = Fsubstitute_command_keys(pgui->keys); if (XSTRING_LENGTH(pgui->keys) > 0) LISP_STRING_TO_EXTERNAL_MALLOC(pgui->keys, wv->key, Qlwlib_encoding); else wv->key = 0; } else if (SYMBOLP(pgui->callback)) { /* Show the binding of this command. */ char buf[1024]; /* #### */ /* #### Warning, dependency here on current_buffer and point */ where_is_to_char(pgui->callback, buf); if (buf[0]) C_STRING_TO_EXTERNAL_MALLOC(buf, wv->key, Qlwlib_encoding); else wv->key = 0; } CHECK_SYMBOL(pgui->style); if (NILP(pgui->style)) { Bufbyte *intname = NULL; Bytecount intlen; /* If the callback is nil, treat this item like unselectable text. This way, dashes will show up as a separator. */ if (!wv->enabled) wv->type = BUTTON_TYPE; TO_INTERNAL_FORMAT(C_STRING, wv->name, ALLOCA, (intname, intlen), Qlwlib_encoding); if (intname != NULL && separator_string_p(intname)) { wv->type = SEPARATOR_TYPE; wv->value = menu_separator_style_and_to_external(intname); } else { #if 0 /* #### - this is generally desirable for menubars, but it breaks a package that uses dialog boxes and next_command_event magic to use the callback slot in dialog buttons for data instead of a real callback. Code is data, right? The beauty of LISP abuse. --Stig */ if (NILP(callback)) wv->type = TEXT_TYPE; else #endif wv->type = BUTTON_TYPE; } } else if (EQ(pgui->style, Qbutton)) wv->type = BUTTON_TYPE; else if (EQ(pgui->style, Qtoggle)) wv->type = TOGGLE_TYPE; else if (EQ(pgui->style, Qradio)) wv->type = RADIO_TYPE; else if (EQ(pgui->style, Qtext)) { wv->type = TEXT_TYPE; #if 0 wv->value = wv->name; wv->name = "value"; #endif } else syntax_error_2("Unknown style", pgui->style, gui_item); if (!allow_text_field_p && (wv->type == TEXT_TYPE)) syntax_error("Text field not allowed in this context", gui_item); if (!NILP(pgui->selected) && EQ(pgui->style, Qtext)) syntax_error (":selected only makes sense with :style toggle, radio or button", gui_item); return 1; }
/* Parser entry point. Opens and parses the test sets in the given file. */ struct TestFile *parse_test_file(const char *path) { struct TestFile *tf = NEW0(struct TestFile); tf->fd = open(path, O_RDONLY); if (tf->fd == -1) { fprintf(stderr, "Opening file %s: %s\n", path, strerror(errno)); return NULL; } tf->path = path; if (fstat(tf->fd, &tf->statbuf)) { fprintf(stderr, "Stat file %s: %s\n", path, strerror(errno)); goto close_it; } if (tf->statbuf.st_size < 1) { fprintf(stderr, "File %s is empty!\n", path); goto close_it; } tf->file_buf = (char *)mmap(NULL, tf->statbuf.st_size, PROT_READ, MAP_SHARED, tf->fd, 0); if (!tf->file_buf) { fprintf(stderr, "Mapping file %s: %s\n", path, strerror(errno)); goto close_it; } tf->file_end = tf->file_buf + tf->statbuf.st_size; if (!next_line(tf)) { syntax_error(tf); goto close_it; } for (;;) { size_t toklen; char *token = next_token(tf, &toklen); if (same_token("set", 3, token, toklen)) { struct TestSet *set = parse_set(tf); if (!set) // parse failure already reported goto close_it; set->next = tf->sets; tf->sets = set; } else if (token == END_OF_LINE) { if (!next_line(tf)) { // EOF if (!tf->sets) { goto no_sets; } goto done; } // else swallow blank line } else { no_sets: fail(tf, tf->read_pos, "expected a test set"); goto close_it; } } close_it: if (tf->sets) { free_sets(tf->sets); tf->sets = NULL; } close_testfile(tf); done: return tf; }
/** * The /cs clear command. * @param u The user who issued the command * @param MOD_CONT to continue processing other modules, MOD_STOP to stop processing. **/ int do_clear(User * u) { char *chan = strtok(NULL, " "); char *what = strtok(NULL, " "); char tmp[BUFSIZE]; Channel *c; ChannelInfo *ci; if (!what) { syntax_error(s_ChanServ, u, "CLEAR", CHAN_CLEAR_SYNTAX); } else if (!(c = findchan(chan))) { notice_lang(s_ChanServ, u, CHAN_X_NOT_IN_USE, chan); } else if (!(ci = c->ci)) { notice_lang(s_ChanServ, u, CHAN_X_NOT_REGISTERED, chan); } else if (ci->flags & CI_VERBOTEN) { notice_lang(s_ChanServ, u, CHAN_X_FORBIDDEN, chan); } else if (!u || !check_access(u, ci, CA_CLEAR)) { notice_lang(s_ChanServ, u, PERMISSION_DENIED); } else if (stricmp(what, "bans") == 0) { char *av[2]; int i; /* Save original ban info */ int count = c->bancount; char **bans = scalloc(sizeof(char *) * count, 1); for (i = 0; i < count; i++) bans[i] = sstrdup(c->bans[i]); for (i = 0; i < count; i++) { av[0] = sstrdup("-b"); av[1] = bans[i]; anope_cmd_mode(whosends(ci), chan, "%s %s", av[0], av[1]); chan_set_modes(whosends(ci), c, 2, av, 0); free(av[1]); free(av[0]); } notice_lang(s_ChanServ, u, CHAN_CLEARED_BANS, chan); free(bans); } else if (ircd->except && stricmp(what, "excepts") == 0) { char *av[2]; int i; /* Save original except info */ int count = c->exceptcount; char **excepts = scalloc(sizeof(char *) * count, 1); for (i = 0; i < count; i++) excepts[i] = sstrdup(c->excepts[i]); for (i = 0; i < count; i++) { av[0] = sstrdup("-e"); av[1] = excepts[i]; anope_cmd_mode(whosends(ci), chan, "%s %s", av[0], av[1]); chan_set_modes(whosends(ci), c, 2, av, 0); free(av[1]); free(av[0]); } notice_lang(s_ChanServ, u, CHAN_CLEARED_EXCEPTS, chan); free(excepts); } else if (ircd->invitemode && stricmp(what, "invites") == 0) { char *av[2]; int i; /* Save original except info */ int count = c->invitecount; char **invites = scalloc(sizeof(char *) * count, 1); for (i = 0; i < count; i++) invites[i] = sstrdup(c->invite[i]); for (i = 0; i < count; i++) { av[0] = sstrdup("-I"); av[1] = invites[i]; anope_cmd_mode(whosends(ci), chan, "%s %s", av[0], av[1]); chan_set_modes(whosends(ci), c, 2, av, 0); free(av[1]); free(av[0]); } notice_lang(s_ChanServ, u, CHAN_CLEARED_INVITES, chan); free(invites); } else if (stricmp(what, "modes") == 0) { char buf[BUFSIZE], *end = buf; char *argv[2]; if (c->mode) { /* Clear modes the bulk of the modes */ anope_cmd_mode(whosends(ci), c->name, "%s", ircd->modestoremove); argv[0] = sstrdup(ircd->modestoremove); chan_set_modes(whosends(ci), c, 1, argv, 0); free(argv[0]); /* to prevent the internals from complaining send -k, -L, -f by themselves if we need to send them - TSL */ if (c->key) { anope_cmd_mode(whosends(ci), c->name, "-k %s", c->key); argv[0] = sstrdup("-k"); argv[1] = c->key; chan_set_modes(whosends(ci), c, 2, argv, 0); free(argv[0]); } if (ircd->Lmode && c->redirect) { anope_cmd_mode(whosends(ci), c->name, "-L %s", c->redirect); argv[0] = sstrdup("-L"); argv[1] = c->redirect; chan_set_modes(whosends(ci), c, 2, argv, 0); free(argv[0]); } if (ircd->fmode && c->flood) { if (flood_mode_char_remove) { anope_cmd_mode(whosends(ci), c->name, "%s %s", flood_mode_char_remove, c->flood); argv[0] = sstrdup(flood_mode_char_remove); argv[1] = c->flood; chan_set_modes(whosends(ci), c, 2, argv, 0); free(argv[0]); } else { if (debug) { alog("debug: flood_mode_char_remove was not set unable to remove flood/throttle modes"); } } } check_modes(c); } /* TODO: decide if the above implementation is better than this one. */ if (0) { CBModeInfo *cbmi = cbmodeinfos; CBMode *cbm; do { if (c->mode & cbmi->flag) *end++ = cbmi->mode; } while ((++cbmi)->flag != 0); cbmi = cbmodeinfos; do { if (cbmi->getvalue && (c->mode & cbmi->flag) && !(cbmi->flags & CBM_MINUS_NO_ARG)) { char *value = cbmi->getvalue(c); if (value) { *end++ = ' '; while (*value) *end++ = *value++; /* Free the value */ cbm = &cbmodes[(int) cbmi->mode]; cbm->setvalue(c, NULL); } } } while ((++cbmi)->flag != 0); *end = 0; anope_cmd_mode(whosends(ci), c->name, "-%s", buf); c->mode = 0; check_modes(c); } notice_lang(s_ChanServ, u, CHAN_CLEARED_MODES, chan); } else if (stricmp(what, "ops") == 0) { char *av[3]; struct c_userlist *cu, *next; if (ircd->svsmode_ucmode) { av[0] = sstrdup(chan); anope_cmd_svsmode_chan(av[0], "-o", NULL); if (ircd->owner) { anope_cmd_svsmode_chan(av[0], ircd->ownerunset, NULL); } if (ircd->protect || ircd->admin) { anope_cmd_svsmode_chan(av[0], ircd->adminunset, NULL); } for (cu = c->users; cu; cu = next) { next = cu->next; av[0] = sstrdup(chan); if (!chan_has_user_status(c, cu->user, CUS_OP)) { if (!chan_has_user_status(c, cu->user, CUS_PROTECT)) { if (!chan_has_user_status(c, cu->user, CUS_OWNER)) { continue; } else { snprintf(tmp, BUFSIZE, "%so", ircd->ownerunset); av[1] = sstrdup(tmp); } } else { snprintf(tmp, BUFSIZE, "%so", ircd->adminunset); av[1] = sstrdup(tmp); } } else { av[1] = sstrdup("-o"); } av[2] = sstrdup(cu->user->nick); do_cmode(s_ChanServ, 3, av); free(av[2]); free(av[1]); free(av[0]); } } else { for (cu = c->users; cu; cu = next) { next = cu->next; av[0] = sstrdup(chan); if (!chan_has_user_status(c, cu->user, CUS_OP)) { if (!chan_has_user_status(c, cu->user, CUS_PROTECT)) { if (!chan_has_user_status(c, cu->user, CUS_OWNER)) { continue; } else { snprintf(tmp, BUFSIZE, "%so", ircd->ownerunset); av[1] = sstrdup(tmp); } } else { snprintf(tmp, BUFSIZE, "%so", ircd->adminunset); av[1] = sstrdup(tmp); } } else { av[1] = sstrdup("-o"); } av[2] = sstrdup(cu->user->nick); anope_cmd_mode(whosends(ci), av[0], "%s :%s", av[1], av[2]); do_cmode(s_ChanServ, 3, av); free(av[2]); free(av[1]); free(av[0]); } } notice_lang(s_ChanServ, u, CHAN_CLEARED_OPS, chan); } else if (ircd->halfop && stricmp(what, "hops") == 0) { char *av[3]; struct c_userlist *cu, *next; for (cu = c->users; cu; cu = next) { next = cu->next; if (!chan_has_user_status(c, cu->user, CUS_HALFOP)) continue; av[0] = sstrdup(chan); av[1] = sstrdup("-h"); av[2] = sstrdup(cu->user->nick); if (ircd->svsmode_ucmode) { anope_cmd_svsmode_chan(av[0], av[1], NULL); do_cmode(s_ChanServ, 3, av); break; } else { anope_cmd_mode(whosends(ci), av[0], "%s :%s", av[1], av[2]); } do_cmode(s_ChanServ, 3, av); free(av[2]); free(av[1]); free(av[0]); } notice_lang(s_ChanServ, u, CHAN_CLEARED_HOPS, chan); } else if (stricmp(what, "voices") == 0) { char *av[3]; struct c_userlist *cu, *next; for (cu = c->users; cu; cu = next) { next = cu->next; if (!chan_has_user_status(c, cu->user, CUS_VOICE)) continue; av[0] = sstrdup(chan); av[1] = sstrdup("-v"); av[2] = sstrdup(cu->user->nick); if (ircd->svsmode_ucmode) { anope_cmd_svsmode_chan(av[0], av[1], NULL); do_cmode(s_ChanServ, 3, av); break; } else { anope_cmd_mode(whosends(ci), av[0], "%s :%s", av[1], av[2]); } do_cmode(s_ChanServ, 3, av); free(av[2]); free(av[1]); free(av[0]); } notice_lang(s_ChanServ, u, CHAN_CLEARED_VOICES, chan); } else if (stricmp(what, "users") == 0) { char *av[3]; struct c_userlist *cu = NULL, *next = NULL; char buf[256]; snprintf(buf, sizeof(buf), "CLEAR USERS command from %s", u->nick); for (cu = c->users; cu; cu = next) { next = cu->next; if ((cu->user->mode & UMODE_q)) { continue; } av[0] = sstrdup(chan); av[1] = sstrdup(cu->user->nick); av[2] = sstrdup(buf); anope_cmd_kick(whosends(ci), av[0], av[1], av[2]); do_kick(s_ChanServ, 3, av); free(av[2]); free(av[1]); free(av[0]); } notice_lang(s_ChanServ, u, CHAN_CLEARED_USERS, chan); } else { syntax_error(s_ChanServ, u, "CLEAR", CHAN_CLEAR_SYNTAX); } return MOD_CONT; }
static struct TestSet *parse_set(struct TestFile *tf) { struct TestSet *set = NEW0(struct TestSet); char *tok; size_t len; assert(tf->next_pos); assert(tf->next_pos > tf->read_pos); set->name = expect_name(tf, &set->name_len, "set"); if (!set->name) goto err; if (expect_eol(tf)) goto err; // set contents: dep, tolerance, setup, teardown, test case, fortran set->tolerance = 0.0; // XXX magic number == BAD for (;;) { tok = next_token(tf, &len); if (tok == END_OF_LINE) { if (!next_line(tf)) { syntax_error(tf); goto err; // EOF } } else if (tok) { if (same_token("dep", 3, tok, len)) { struct TestDependency *dep = parse_dependency(tf); if (!dep) goto err; dep->next = set->deps; set->deps = dep; set->n_deps++; } else if (same_token("use", 3, tok, len)) { struct TestModule *mod = parse_module(tf); if (!mod) goto err; mod->next = set->mods; set->mods = mod; set->n_mods++; } else if (same_token("tolerance", 9, tok, len)) { char *tolend; tok = next_token(tf, &len); if (!tok || tok == END_OF_LINE) { fail(tf, tf->read_pos, "expected tolerance value"); goto err; } set->tolerance = strtod(tf->read_pos, &tolend); if (tolend == tf->read_pos || tolend != tf->next_pos) { fail(tf, tf->read_pos, "not a floating point value"); goto err; } tf->next_pos = tolend; } else if (same_token("setup", 5, tok, len)) { if (set->setup) { fail(tf, tf->next_pos, "more than one setup case specified"); goto err; } set->setup = parse_support(tf, "setup"); if (!set->setup) goto err; } else if (same_token("teardown", 8, tok, len)) { if (set->teardown) { fail(tf, tf->next_pos, "more than one teardown case specified"); goto err; } set->teardown = parse_support(tf, "teardown"); if (!set->teardown) goto err; } else if (same_token("test", 4, tok, len)) { struct TestCase *test = parse_test_case(tf); if (!test) goto err; test->next = set->tests; set->tests = test; set->n_tests++; } else if (same_token("end", 3, tok, len)) { tf->next_pos = tf->read_pos; break; // end of test set } else { // fortran code struct Code *code; tf->next_pos = tf->read_pos = tf->line_pos; code = parse_fortran(tf, NULL); // XXX check for parse fail? code->next = set->code; set->code = code; } } else { // EOF fail(tf, tf->read_pos, "expected end set"); goto err; } } // end set name if (parse_end_sequence(tf, "set", set->name, set->name_len)) goto err; return set; err: free_sets(set); return NULL; }
command_t make_simple_command(char *buffer) { if(!strlen(buffer)) syntax_error(); command_t command = checked_malloc(sizeof(struct command)); command->type = SIMPLE_COMMAND; command->status = -1; command->input = NULL; command->output = NULL; command->u.word = checked_malloc(8*sizeof(char*)); size_t word_size = 8; size_t input_size = 8;size_t output_size = 8; size_t cur_word_size; size_t index = 0; bool in_word = false; bool in_input = false; bool in_output = false; bool input = false; bool output = false; int i; for(i = 0; buffer[i]; i++) { if(buffer[i] == '<') { if(i == 0 || input || output || in_input || in_output) syntax_error(); command->input = checked_malloc(8*sizeof(char)); in_input = true; } else if(buffer[i] == '>') { if(i == 0 || output || in_output) syntax_error(); command->output = checked_malloc(8*sizeof(char)); in_input = false; in_output = true; } else if(isalnum(buffer[i]) || strchr("!%+,-./:@^_", buffer[i])) { if(in_input) { input = true; char* string = command->input; if(strlen(string) >= input_size) checked_grow_alloc(string, &input_size); string[strlen(string)] = buffer[i]; } else if(in_output) { output = true; char* string = command->output; if(strlen(string) >= output_size) checked_grow_alloc(string, &output_size); string[strlen(string)] = buffer[i]; } else if(!in_word) { if((input || output) && !in_input && !in_output) syntax_error(); if(index >= word_size) checked_grow_alloc(command->u.word, &word_size); command->u.word[index] = checked_malloc(8*sizeof(char)); cur_word_size = 8; command->u.word[index][0] = buffer[i]; in_word = true; } else if(in_word) { char *string = command->u.word[index]; if(strlen(string) >= cur_word_size) checked_grow_alloc(string, &cur_word_size); string[strlen(string)] = buffer[i]; } } else if(strchr("\t ", buffer[i])) { if(in_word) { in_word = false; index++; } else if(input && in_input) in_input = false; else if(output && in_output) in_output = false; } else if(buffer[i] == EOF) { if(index >= word_size) checked_grow_alloc(command->u.word, &word_size); return command; } else syntax_error(); } memset((void *) buffer, '\0', 1024); if(index >= word_size) checked_grow_alloc(command->u.word, &word_size); return command; }
/* check for end of line, issue error, if not */ void eol(char *s) { s = skip(s); if (*s!='\0' && *s!=commentchar) syntax_error(6); }
/* statements -> lstatement [statements] */ void parse_statements(ast_node* block) { if (parse_lstatement(block)) while (parse_lstatement(block)); else syntax_error("'ID', 'skip', 'if', 'while' or 'await'"); }
int main (int argc, char **argv) { MsOle *ole; int lp, exit = 0, interact = 0; char *buffer = g_new (char, 1024) ; if (argc<2) syntax_error(0); if (!g_strcasecmp (argv [1], "regression")) { do_regression_tests (); return 0; } printf ("Ole file '%s'\n", argv[1]); if (ms_ole_open_vfs (&ole, argv[1], TRUE, NULL) != MS_OLE_ERR_OK) { printf ("Creating new file '%s'\n", argv[1]); if (ms_ole_create_vfs (&ole, argv[1], TRUE, NULL) != MS_OLE_ERR_OK) syntax_error ("Can't open file or create new one"); } if (argc<=2) syntax_error ("Need command or -i"); if (argc>2 && argv[argc-1][0]=='-' && argv[argc-1][1]=='i') interact=1; else { char *str=g_strdup(argv[2]) ; for (lp=3;lp<argc;lp++) str = g_strconcat(str," ",argv[lp],NULL); /* FIXME Mega leak :-) */ buffer = str; /* and again */ } cur_dir = g_strdup ("/"); do { char *ptr; if (interact) { fprintf (stdout,"> "); fflush (stdout); fgets (buffer, 1023, stdin); } arg_data = g_strsplit (g_strchomp (buffer), delim, -1); arg_cur = 0; if (!arg_data && interact) continue; if (!interact) printf ("Command : '%s'\n", arg_data[0]); ptr = arg_data[arg_cur++]; if (!ptr) continue; if (g_strcasecmp (ptr, "ls") == 0) list_files (ole); else if (g_strcasecmp (ptr, "cd") == 0) enter_dir (ole); else if (g_strcasecmp (ptr, "dump") == 0) do_dump (ole); else if (g_strcasecmp (ptr, "biff") == 0) do_biff (ole); else if (g_strcasecmp (ptr, "biffraw") == 0) do_biff_raw (ole); else if (g_strcasecmp (ptr, "get") == 0) do_get (ole); else if (g_strcasecmp (ptr, "put") == 0) do_put (ole); else if (g_strcasecmp (ptr, "copyin") == 0) do_copyin (ole); else if (g_strcasecmp (ptr, "copyout") == 0) do_copyout (ole); else if (g_strcasecmp (ptr, "summary") == 0) do_summary (ole); else if (g_strcasecmp (ptr, "docsummary") == 0) do_docsummary (ole); else if (g_strcasecmp (ptr, "debug") == 0) ms_ole_debug (ole, 1); else if (g_strcasecmp (ptr, "tree") == 0) ms_ole_debug (ole, 2); else if (g_strcasecmp (ptr, "vba") == 0) dump_vba (ole); else if (g_strcasecmp (ptr, "help") == 0 || g_strcasecmp (ptr, "?") == 0 || g_strcasecmp (ptr, "info") == 0 || g_strcasecmp (ptr, "man") == 0) list_commands (); else if (g_strcasecmp (ptr, "exit") == 0 || g_strcasecmp (ptr, "quit") == 0 || g_strcasecmp (ptr, "q") == 0 || g_strcasecmp (ptr, "bye") == 0) exit = 1; } while (!exit && interact); ms_ole_destroy (&ole); return 0; }
/* * Tokenize an 'if' statement condition. */ static struct condition * tokenize_if( const char * pnt ) { struct condition * list; struct condition * last; struct condition * prev; /* eat the open bracket */ while ( *pnt == ' ' || *pnt == '\t' ) pnt++; if ( *pnt != '[' ) syntax_error( "bad 'if' condition" ); pnt++; list = last = NULL; for ( ; ; ) { struct condition * cond; /* advance to the next token */ while ( *pnt == ' ' || *pnt == '\t' ) pnt++; if ( *pnt == '\0' ) syntax_error( "unterminated 'if' condition" ); if ( *pnt == ']' ) return list; /* allocate a new token */ cond = malloc( sizeof(*cond) ); memset( cond, 0, sizeof(*cond) ); if ( last == NULL ) { list = last = cond; prev = NULL; } else { prev = last; last->next = cond; last = cond; } /* determine the token value */ if ( *pnt == '-' && pnt[1] == 'a' ) { if ( ! prev || ( prev->op != op_variable && prev->op != op_constant ) ) syntax_error( "incorrect argument" ); cond->op = op_and; pnt += 2; continue; } if ( *pnt == '-' && pnt[1] == 'o' ) { if ( ! prev || ( prev->op != op_variable && prev->op != op_constant ) ) syntax_error( "incorrect argument" ); cond->op = op_or; pnt += 2; continue; } if ( *pnt == '!' && pnt[1] == '=' ) { if ( ! prev || ( prev->op != op_variable && prev->op != op_constant ) ) syntax_error( "incorrect argument" ); cond->op = op_neq; pnt += 2; continue; } if ( *pnt == '=' ) { if ( ! prev || ( prev->op != op_variable && prev->op != op_constant ) ) syntax_error( "incorrect argument" ); cond->op = op_eq; pnt += 1; continue; } if ( *pnt == '!' ) { if ( prev && ( prev->op != op_and && prev->op != op_or && prev->op != op_bang ) ) syntax_error( "incorrect argument" ); cond->op = op_bang; pnt += 1; continue; } if ( *pnt == '"' ) { const char * word; if ( prev && ( prev->op == op_variable || prev->op == op_constant ) ) syntax_error( "incorrect argument" ); /* advance to the word */ pnt++; if ( *pnt == '$' ) { cond->op = op_variable; pnt++; } else { cond->op = op_constant; } /* find the end of the word */ word = pnt; for ( ; ; ) { if ( *pnt == '\0' ) syntax_error( "unterminated double quote" ); if ( *pnt == '"' ) break; pnt++; } /* store a copy of this word */ { char * str = malloc( pnt - word + 1 ); memcpy( str, word, pnt - word ); str [pnt - word] = '\0'; if ( cond->op == op_variable ) { cond->nameindex = get_varnum( str ); free( str ); } else /* op_constant */ { cond->str = str; } } pnt++; continue; } /* unknown token */ syntax_error( "bad if condition" ); } }
/* Very simple, very incomplete. */ void parse(void) { char *s,*line,*inst,*ext[MAX_QUALIFIERS?MAX_QUALIFIERS:1],*op[MAX_OPERANDS]; int inst_len,ext_len[MAX_QUALIFIERS?MAX_QUALIFIERS:1],op_len[MAX_OPERANDS]; int i,ext_cnt,op_cnt,par_cnt; instruction *ip; while(line=read_next_line()){ s=line; if(isalnum((unsigned char)*s)){ /* Handle labels at beginning of line */ char *labname,*equ; symbol *label; while(*s&&!isspace((unsigned char)*s)&&*s!=':') s++; labname=cnvstr(line,s-line); s=skip(s+1); if(!strncmp(s,"equ",3)&&isspace((unsigned char)s[3])){ s=skip(s+3); label=new_abs(labname,parse_expr(&s)); }else{ label=new_labsym(0,labname); add_atom(0,new_label_atom(label)); } free(labname); } s=parse_cpu_special(s); if(handle_directive(s)) continue; /* skip spaces */ s=skip(s); if(!*s) continue; /* read mnemonic name */ inst=s; if(!ISIDSTART(*s)){ syntax_error(10); continue; } #if MAX_QUALIFIERS==0 while(*s&&!isspace((unsigned char)*s)) s++; #else while(*s&&*s!='.'&&!isspace((unsigned char)*s)) s++; #endif inst_len=s-inst; /* read qualifiers */ ext_cnt=0; while(*s=='.'&&ext_cnt<MAX_QUALIFIERS){ s++; ext[ext_cnt]=s; while(*s&&*s!='.'&&!isspace((unsigned char)*s)) s++; ext_len[ext_cnt]=s-ext[ext_cnt]; if(ext_len[ext_cnt]<=0) syntax_error(1); else ext_cnt++; } if(!isspace((unsigned char)*s)) syntax_error(2); /* read operands, terminated by comma (unless in parentheses) */ s=skip(s); op_cnt=0; while(*s&&op_cnt<MAX_OPERANDS){ op[op_cnt]=s; s=skip_operand(s); op_len[op_cnt]=s-op[op_cnt]; if(op_len[op_cnt]<=0) syntax_error(5); else op_cnt++; s=skip(s); if(*s!=','){ break; }else{ s=skip(s+1); } } s=skip(s); if(*s!=0) syntax_error(6); ip=new_inst(inst,inst_len,op_cnt,op,op_len); #if MAX_QUALIFIERS>0 if(ip){ for(i=0;i<ext_cnt;i++) ip->qualifiers[i]=cnvstr(ext[i],ext_len[i]); for(;i<MAX_QUALIFIERS;i++) ip->qualifiers[i]=0; } #endif if(ip){ add_atom(0,new_inst_atom(ip)); }else ; } }