void Bytecodes::verify() {
#if USE_DEBUG_PRINTING
GUARANTEE(number_of_java_codes -1 <= 0xff, "Too many bytecodes");
int index = 0;
for(BytecodeData* p = data; p->_name != NULL; p++) {
GUARANTEE(p->_index == index, "index must match");
Code code = (Code) index;
if (is_defined(code)) {
GUARANTEE((int) jvm_strlen(p->_format) == length_for(code),
"checking length");
}
if (wide_is_defined(code)) {
GUARANTEE((int) jvm_strlen(p->_wide_format) == wide_length_for(code),
"checking length");
}
if (is_defined(code)) {
if ((code == Bytecodes::_goto) ||
(code == Bytecodes::_goto_w) ||
(code >= Bytecodes::_ireturn && code <= Bytecodes::_return) ||
(code == Bytecodes::_ret) ||
(code == Bytecodes::_tableswitch) ||
(code == Bytecodes::_lookupswitch) ||
(code == Bytecodes::_athrow) ||
(code == Bytecodes::_fast_invokenative)) {
GUARANTEE(!can_fall_through(code), "cannot fall through");
} else {
GUARANTEE(can_fall_through(code), "can fall through");
}
}
index++;
}
#endif
}
int write_instruction(char **my_tab, int fd[2])
{
int i;
if (my_tab && my_tab[0] && my_tab[0][0] != COMMENT_CHAR)
{
i = 0;
while (my_tab[i])
{
if (my_tab[i][0] != '\0')
{
if (is_defined(my_tab[i]) == 1)
{
if (write_mnemonique(my_tab[i], fd[1]) == 1)
return (1);
if (write_encoding_byte(my_tab, fd[1]) == 1)
return (1);
}
else
if (write_argument(my_tab, fd, i) == 1)
return (1);
}
i = i + 1;
}
}
return (0);
}
static int wide_length_for(Code code) {
if (!is_defined(code)) {
return 0;
}
const char* wf = wide_format(code);
return (wf == NULL) ? 0 : (int)strlen(wf);
}
static void
yyputline( char *outtext)
{
char token_buf[MAX_LINE+1];
char token_val[MAX_LINE+1];
char *p = token_buf;
static char *symc = ERx(
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_$");
i4 symc_l = STlength(symc);
i4 defidx;
static i4 iterate_level = 0;
/* Check to make sure we don't have runaway recursion */
if (iterate_level++ > MAX_ITERATION)
{
SIfprintf( stderr, E_YAPP006 );
yydump();
}
/* Break up the string into tokens and try to resolve symbols */
while (*outtext != EOS)
{
p = token_buf;
while (STindex(symc, outtext, symc_l) != NULL) {
STlcopy(outtext, p, 1);
CMnext(outtext);
CMnext(p);
}
/* Found a token that may be defined as a symbol */
if (p != token_buf)
{
/* If the token is defined then translate the */
/* value of the substituted text, otherwise just */
/* output the untranslated text. */
STcopy(ERx(""), p);
if (OK == is_defined(token_buf, token_val))
yyputline( token_val );
else
SIprintf("%s", token_buf);
}
/* The text being processed at this point is whitespace, */
/* operators, or some other characters that are not */
/* valid for tokens. */
else
{
SIputc(*outtext, stdout);
CMnext(outtext);
}
}
iterate_level--;
}
/*
* Reads "defined" unary operator of the form "defined <identifier>" or
* "defined(<identifier>)". The token "defined" is already read when the
* function is called.
*
* (C99 6.10.1 Conditional inclusion, paragraph 1)
*/
static Token *read_defined(CppContext *ctx) {
Token *tok = read_cpp_token(ctx);
if (is_punct(tok, '(')) {
tok = read_cpp_token(ctx);
Token *tok1 = read_cpp_token(ctx);
if (!tok1 || !is_punct(tok1, ')'))
error_token(tok1, "')' expected, but got '%s'", token_to_string(tok1));
}
Token *r = copy_token(tok);
r->toktype = TOKTYPE_CPPNUM;
r->val.i = is_defined(ctx, tok);
return r;
}
/* Try to find baseform (lemma) of individual word in POS */
char *morphword(char *word, int pos)
{
int offset, cnt;
int i;
static char retval[WORDBUF];
char *tmp, tmpbuf[WORDBUF], *end;
sprintf(retval,"");
sprintf(tmpbuf, "");
end = "";
if(word == NULL)
return(NULL);
/* first look for word on exception list */
if((tmp = exc_lookup(word, pos)) != NULL)
return(tmp); /* found it in exception list */
if (pos == ADV) { /* only use exception list for adverbs */
return(NULL);
}
if (pos == NOUN) {
if (strend(word, "ful")) {
cnt = strrchr(word, 'f') - word;
strncat(tmpbuf, word, cnt);
end = "ful";
} else
/* check for noun ending with 'ss' or short words */
if (strend(word, "ss") || (strlen(word) <= 2))
return(NULL);
}
/* If not in exception list, try applying rules from tables */
if (tmpbuf[0] == '\0')
strcpy(tmpbuf, word);
offset = offsets[pos];
cnt = cnts[pos];
for(i = 0; i < cnt; i++){
strcpy(retval, wordbase(tmpbuf, (i + offset)));
if(strcmp(retval, tmpbuf) && is_defined(retval, pos)) {
strcat(retval, end);
return(retval);
}
}
return(NULL);
}
AST_StateMember *AST_Value::fe_add_state_member(AST_StateMember *t)
{
AST_Decl *d;
/*
* Can't add to interface which was not yet defined
*/
if (!is_defined())
{
idl_global->err()->error2(UTL_Error::EIDL_DECL_NOT_DEFINED, this, t);
return NULL;
}
/*
* Already defined and cannot be redefined? Or already used?
*/
if ((d = lookup_for_add (t)) != NULL)
{
if (!can_be_redefined(d))
{
idl_global->err()->error3(UTL_Error::EIDL_REDEF, t, this, d);
return NULL;
}
if (referenced(d))
{
idl_global->err()->error3(UTL_Error::EIDL_DEF_USE, t, this, d);
return NULL;
}
if (t->has_ancestor(d))
{
idl_global->err()->redefinition_in_scope(t, d);
return NULL;
}
}
/*
* Add it to scope
*/
add_to_scope(t);
/*
* Add it to set of locally referenced symbols
*/
add_to_referenced(t, I_FALSE);
return t;
}
void Bytecodes::def(Code code, const char* name, const char* format, const char* wide_format, BasicType result_type, int depth, bool can_trap, Code java_code) {
assert(wide_format == NULL || format != NULL, "short form must exist if there's a wide form");
int len = (format != NULL ? (int) strlen(format) : 0);
int wlen = (wide_format != NULL ? (int) strlen(wide_format) : 0);
_name [code] = name;
_result_type [code] = result_type;
_depth [code] = depth;
_lengths [code] = (wlen << 4) | (len & 0xF);
_java_code [code] = java_code;
int bc_flags = 0;
if (can_trap) bc_flags |= _bc_can_trap;
if (java_code != code) bc_flags |= _bc_can_rewrite;
_flags[(u1)code+0*(1<<BitsPerByte)] = compute_flags(format, bc_flags);
_flags[(u1)code+1*(1<<BitsPerByte)] = compute_flags(wide_format, bc_flags);
assert(is_defined(code) == (format != NULL), "");
assert(wide_is_defined(code) == (wide_format != NULL), "");
assert(length_for(code) == len, "");
assert(wide_length_for(code) == wlen, "");
}
static int parse_line_instruction(t_parser *parser, char **my_tab)
{
if (is_defined(my_tab[0]) == 1)
{
if (compressor(&my_tab) == 1)
{
my_putstr_err("Can’t perform malloc", 2);
return (1);
}
if (is_number_valid(my_tab, my_tab[0]) == 1)
parser->current_address += get_incsize(my_tab);
else
return (syntax_error_and_return(parser->line_nb));
if (valid_args(my_tab) == 0)
return (syntax_error_and_return(parser->line_nb));
}
else
return (syntax_error_and_return(parser->line_nb));
return (0);
}
vector<PopWord> TopTensSearch::parsePage(string buffer, string word)
{
vector<PopWord> results;
set<PopWord*, DereferenceLess> unique;
// boost::smatch what;
// boost::regex expr(regex);
//parse the XML document
rapidxml::xml_document<> doc;
doc.parse<0>((char*)buffer.c_str());
rapidxml::xml_node<> *node = doc.first_node();
//Filter the titles
string exp(".*st "+word+"s?( (?!(in|about|from)).*|$)|.(?!\\w+s)* "+word+"s( (?!.*(in|about|from)).*|$)|.* "+word+"s? ((?!color)|(\\w+))s( (?!.*(in|about|from)).*|$)");
boost::regex e(exp, boost::regex::icase);
wninit();
for (rapidxml::xml_node<> *list = node->first_node(); list; list = list->next_sibling())
{
//The list has:
// * title
// * link
// * items
// printf("Title: %s\n", list->first_node("title")->value());
const string test = list->first_node("title")->value();
//Determine if the title is any good
if(boost::regex_match(test, e))
{
int count = 0;
for (rapidxml::xml_node<> *attr = list->first_node("items")->first_node(); attr && count < 5; attr = attr->next_sibling())
{
std::string item = (std::string) attr->value();
boost::regex re(" (in |from |of |- |\\(|:)", boost::regbase::icase);
boost::sregex_token_iterator i(item.begin(), item.end(), re, -1);
boost::sregex_token_iterator j;
std::string found = *i++;
if (i!=j)
{
boost::replace_all(found, " ", "_");
//PopWord* pop = new PopWord(found, test, *i);
set<PopWord*>::iterator it = unique.insert(unique.begin(), new PopWord(found, test, *i));
// if (it != unique.end())
// {
// cout << (*it)->getCount();
(*it)->incrementCount();
// cout << "\t1 |" << (*it)->getStem() << "|\t" << *i << " " << (*it)->getCount() << endl;
// }
// else
// unique.insert(pop);
}
else
{
boost::replace_all(item, " ", "_");
bool inWN = false;
for (int j=1; j <= 4; j++)
{
//If the word is defined for the POS
if (is_defined((char*)item.c_str(), j) != 0)
{
set<PopWord*>::iterator it = unique.insert(unique.begin(), new PopWord(item, test));
(*it)->incrementCount();
inWN=true;
// cout << "\t\t2 " << item << endl;
break;
}
else
{
char* morph = morphstr((char*)item.c_str(),j);
if (morph != NULL)
{
set<PopWord*>::iterator it = unique.insert(unique.begin(), new PopWord(item, test));
(*it)->incrementCount();
inWN=true;
// cout << "\t\t3 " << item << endl;
break;
}
}
}
// if(!inWN)
// std::cout << "Not used\t\t4 "<<item << std::endl;
}
}
}
}
//Iterate through the unique set. Check how apparent the concept is in wikipedia
int maxCount = 0;
set<PopWord*>::iterator it;
for (it=unique.begin(); it !=unique.end(); it++)
{
PopWord ttr = *(*it);
// cout << ttr.getWord() << endl;
//int count = -1;
if (false)
{
string buffer = requestURL("http://en.wikipedia.org/w/api.php?format=json&action=parse&page="+ttr.getStem()+"&prop=links&redirects");
boost::regex re("[\"\\s(:]" + word + "s?[)\"\\s]", boost::regbase::icase);
boost::sregex_token_iterator i(buffer.begin(), buffer.end(), re, -1);
boost::sregex_token_iterator j;
// cout << "-->\t" << buffer << endl;
while (i != j)
{
// cout << "\t" << *i++ << endl;
ttr.incrementCount();
}
// cout << count << endl << endl;
}
// ttr.setCount(count);
if (ttr.getCount() > maxCount)
maxCount=ttr.getCount();
results.push_back(ttr);
}
for (int i =0; i < results.size(); i++)
{
results[i].setCount(results[i].getCount()/maxCount);
}
return results;
}
static bool wide_is_defined(int code) {
return is_defined(code) && _wide_format[code] != NULL;
}
// Conversion
static void check (Code code) {
assert(is_defined(code), "illegal code");
}
/*
* #ifdef
* (C99 6.10.1 Conditional inclusion, paragraph 5)
*/
static int read_ifdef(CppContext *ctx) {
int r = is_defined(ctx, read_cpp_token(ctx));
expect_newline(ctx);
return r;
}
static bool
pp_eval_boolexp( char **strptr, char *goal )
{
bool boolval[2];
i4 notval[2];
i4 oper = OPER_NONE;
i4 curval = 0;
i4 maxval;
i4 goalfound = FALSE;
char *parser = *strptr;
bool rtn;
notval[0] = notval[1] = 0;
maxval = (sizeof(boolval) / sizeof(boolval[0])) - 1;
while (goalfound == FALSE)
{
/* Are we through yet? */
if( CMcmpcase( parser, goal ) == 0 )
{
goalfound = TRUE;
CMnext(parser);
}
/* If the string is empty then bail out */
else if( STlength( parser ) == 0)
break;
/* Have we exhausted our parsing capabilities? */
else if (curval > maxval)
break;
/* If this is white space then just skip over it */
else if( CMwhite( parser ))
CMnext( parser );
/* Is this an end to a parenthetical expression? */
/* its not our goal, but it could be someones */
else if( CMcmpcase( parser, ERx(")") ) == 0 &&
*goal != EOS)
{
goalfound = TRUE;
break;
}
/* Is this a NOT (!) to reverse the value of next boolean? */
else if( CMcmpcase( parser, ERx("!") ) == 0 )
{
/* Use the xor operator to toggle, allows for !(!val) */
notval[curval] ^= 1;
CMnext(parser);
}
/* Is this a parenthetical expression? */
else if( CMcmpcase( parser,ERx("(") ) == 0)
{
CMnext(parser);
boolval[curval++] = pp_eval_boolexp(&parser, ERx(")"));
}
/* Is this an AND (&&) operator? */
else if( STbcompare( parser, 2, ERx("&&"), 2, 0 ) == 0)
{
if (oper != OPER_NONE)
{
SIfprintf( stderr, E_YAPP001 );
SIfprintf( stderr, E_YAPP00F );
yydump();
}
oper = OPER_AND;
CMnext(parser);
CMnext(parser);
boolval[curval++] = pp_eval_boolexp(&parser, ERx("\n"));
}
/* Is this an OR (||) operator? */
else if( STbcompare( parser, 2, ERx("||"), 2, 0 ) == 0)
{
if (oper != OPER_NONE)
{
SIfprintf( stderr, E_YAPP001 );
SIfprintf( stderr, E_YAPP011 );
yydump();
}
oper = OPER_OR;
CMnext(parser);
CMnext(parser);
boolval[curval++] = pp_eval_boolexp(&parser, ERx("\n"));
}
/* Is this the defined() preprocessor macro? */
else if( STbcompare( parser, 7, ERx("defined"), 7, 0 ) == 0 )
{
char defsym[MAX_SYMLEN + 1];
char *defptr;
/* Initialize the symbol name */
STcopy(ERx(""), defsym);
/* Try and find the beginning '(' */
while (STlength(parser) > 0 &&
CMcmpcase(parser, ERx("(") ) != 0)
CMnext(parser);
/* Skip over the open parenthesis, ( */
if (STlength(parser) != 0)
CMnext(parser);
/* Skip over any whitespace following '(' */
while (STlength(parser) > 0 && CMwhite(parser))
CMnext(parser);
/* Save the name of the symbol to look up */
defptr = defsym;
while (STlength(parser) > 0 &&
CMcmpcase(parser, ERx(")") ) != 0 &&
!CMwhite(parser))
{
CMcpychar(parser, defptr);
CMnext(parser);
CMnext(defptr);
}
*defptr = EOS;
/* Try and find the ending ')' */
while (STlength(parser) > 0 &&
CMcmpcase(parser, ERx(")") ) != 0)
CMnext(parser);
/* Skip over the closed parenthesis, ) */
if (STlength(parser) != 0)
CMnext(parser);
/* Make sure there was something in the parenthesis */
if (STlength(defsym) == 0)
{
SIfprintf( stderr, E_YAPP001 );
SIfprintf( stderr, E_YAPP013 );
yydump();
}
boolval[curval++] = (is_defined(defsym, NULL) == OK);
}
/* Thats all we know how to parse, gotta bail out */
else
{
SIfprintf( stderr, E_YAPP001 );
SIfprintf( stderr, E_YAPP014 );
yydump();
}
}
/* Did we ultimately fail to evaluate the expression? */
if (*goal == EOS && goalfound == FALSE)
{
SIfprintf( stderr, E_YAPP001 );
SIfprintf( stderr, E_YAPP015 );
yydump();
}
/* Now make sure something was specified in the current expression */
if (curval == 0)
{
SIfprintf( stderr, E_YAPP001 );
SIfprintf( stderr, E_YAPP016 );
yydump();
}
/* If an operator is found make sure it had an object to operate on */
if (oper != OPER_NONE && curval <= maxval)
{
SIfprintf( stderr, E_YAPP001 );
SIfprintf( stderr, E_YAPP017 );
yydump();
}
/* Save the current location in parse string */
*strptr = parser;
/* Resolve the highest precedence NOT operators */
if (curval > 0 && notval[0] == 1)
boolval[0] = !boolval[0];
if (curval > 1 && notval[1] == 1)
boolval[1] = !boolval[1];
/* Resolve the final expression */
switch (oper)
{
case OPER_OR:
rtn = boolval[0] || boolval[1];
break;
case OPER_AND:
rtn = boolval[0] && boolval[1];
break;
default:
rtn = boolval[0];
break;
}
return rtn;
}
static u_i4
pp_directive( FILE *input, STACK_FRAME *stack , bool ifdef )
{
i4 n, len;
char *words[ MAX_LINE / 2 ], *temp, *p;
char *parse_val, *parse_end;
STACK_FRAME stack_frame;
bool def_dir;
u_i4 rtn = NONE;
stack_frame.prev = stack;
stack_frame.display_mode = TRUE;
p = temp = STalloc( infile->yytext );
CMnext( p );
n = sizeof( words );
STgetwords( p, &n, words );
/* process the directive, watch out for the empty directive */
if (n == 0)
{
; /* empty directive */
}
else if( STequal( words[ 0 ], ERx( "define" ) ) != 0 )
{
/* If a symbol was specified look for the value to give it */
if (n > 1)
{
/* Scan for the 'define' keyword */
parse_val = infile->yytext;
CMnext(parse_val); /* Skip over the '#' */
while (CMwhite(parse_val))
CMnext(parse_val);
/* Scan past the 'define' keyword */
while (!CMwhite(parse_val))
CMnext(parse_val);
/* Scan over white space separating 'define' */
/* keyword and the specified symbol name */
while (CMwhite(parse_val))
CMnext(parse_val);
/* Skip over the symbol name */
while (!CMwhite(parse_val))
CMnext(parse_val);
/* Skip over white space after the symbol name */
while (CMwhite(parse_val))
CMnext(parse_val);
/* At this point we have scanned to the beginning */
/* of the defined value for the symbol, Trim off */
/* any trailing white space */
STtrmwhite(parse_val);
/* Define value found, could be the empty string, "" */
if( active( &stack_frame ) )
{
define( words[ 1 ], parse_val, FALSE );
}
}
rtn = DEFINE;
}
else if( active( &stack_frame ) &&
STequal( words[ 0 ], ERx( "undef" ) ) != 0 )
{
if (n > 1)
{
undefine( words[ 1 ] );
}
rtn = UNDEF;
}
else if( STequal( words[ 0 ], ERx( "if" ) ) != 0 )
{
/* If an expression was specified look for its evaluation */
if (n > 1)
{
/* Scan for the 'if' keyword */
parse_val = infile->yytext;
CMnext(parse_val); /* Skip over the '#' */
while (CMwhite(parse_val))
CMnext(parse_val);
/* Scan past the 'if' keyword */
while (!CMwhite(parse_val))
CMnext(parse_val);
/* Scan over white space separating 'if' */
/* keyword and the expression */
while (CMwhite(parse_val))
CMnext(parse_val);
/* At this point we have scanned to the beginning */
/* of the expression.*/
if( active( &stack_frame ) )
{
/* Evaluate boolean expression found */
stack_frame.display_mode =
pp_eval_boolexp( &parse_val, ERx("") );
}
(void) pp_input( input, &stack_frame, TRUE );
}
rtn = IF;
}
else if( STequal( words[ 0 ], ERx( "ifdef" ) ) != 0 )
{
if( active(&stack_frame) && is_defined(words[1], NULL) == OK)
{
stack_frame.display_mode = TRUE;
}
else
stack_frame.display_mode = FALSE;
(void) pp_input( input, &stack_frame, TRUE );
rtn = IFDEF;
}
else if( STequal( words[ 0 ], ERx( "ifndef" ) ) != 0 )
{
if( active(&stack_frame) && is_defined(words[1], NULL) != OK)
{
stack_frame.display_mode = TRUE;
}
else
stack_frame.display_mode = FALSE;
(void) pp_input( input, &stack_frame, TRUE );
rtn = IFNDEF;
}
else if( STequal( words[ 0 ], ERx( "else" ) ) != 0 )
{
if( !ifdef )
{
SIfprintf( stderr, E_YAPP007 );
yydump();
}
stack_frame.prev->display_mode =
( stack_frame.prev->display_mode == TRUE ) ?
FALSE : TRUE;
rtn = ELSE;
}
else if( STequal( words[ 0 ], ERx( "endif" ) ) != 0 )
{
rtn = ENDIF;
}
else if( STequal( words[ 0 ], ERx( "include" ) ) != 0 )
{
/* Look for the include filename */
if (n > 1)
{
/* Scan for the 'include' keyword */
parse_val = infile->yytext;
CMnext(parse_val); /* Skip over the '#' */
while (CMwhite(parse_val))
CMnext(parse_val);
/* Scan past the include keyword */
while (!CMwhite(parse_val))
CMnext(parse_val);
/* Scan over white space separating 'include' */
/* keyword and the specified filename */
while (CMwhite(parse_val))
CMnext(parse_val);
/* At this point were expecting "file" or <file> */
/* remember the character which ends the filename */
def_dir = TRUE;
if (CMcmpcase(parse_val, ERx("\"")) == 0)
{
parse_end = ERx("\"");
}
else if (CMcmpcase(parse_val, ERx("<")) == 0)
{
parse_end = ERx(">");
def_dir = FALSE;
}
else
{
parse_end = ERx("");
}
/* Save the include file name in the temp string. */
/* Note, this overwrites the parsed words of the */
/* record since but these are no longer needed. */
p = temp;
CMnext(parse_val);
while (*parse_val != EOS)
{
if (CMcmpcase(parse_val, parse_end) == 0)
{
/* Terminate the file name and call */
/* pp_file to process the file. */
STcopy(ERx(""), p);
pp_file(stack, temp, def_dir);
break;
}
CMcpychar(parse_val, p);
CMnext(parse_val);
CMnext(p);
}
}
rtn = DEFINE;
}
/* display everthing but legal directives */
if (rtn == NONE && active( &stack_frame ) )
yyputline( infile->yytext );
MEfree( temp );
return( rtn );
}
static void massage_property_tree(property_tree &tree, context &ctx)
{
std::vector<property_tree::leave> new_leaves;
// for any goal x>=b or x<=b, add the converse inequality as a hypothesis
for (std::vector<property_tree::leave>::const_iterator i = tree->leaves.begin(),
i_end = tree->leaves.end(); i != i_end; ++i)
{
property const &p = i->first;
if (!i->second || p.real.pred() != PRED_BND || !is_defined(p.bnd()) ||
is_bounded(p.bnd())) continue;
number l = upper(p.bnd()), u = lower(p.bnd());
if (l == number::pos_inf) {
l = number::neg_inf;
if (!p.real.real2()) {
real_op const *o = boost::get<real_op const>(p.real.real());
if (o && o->type == UOP_ABS) l = 0;
}
} else {
u = number::pos_inf;
}
new_leaves.push_back(property_tree::leave(property(p.real, interval(l, u)), false));
}
tree->leaves.insert(tree->leaves.end(), new_leaves.begin(), new_leaves.end());
new_leaves.clear();
typedef std::map< predicated_real, property > input_set;
input_set inputs;
// intersect hypothesis properties for common reals
for (std::vector<property_tree::leave>::const_iterator i = tree->leaves.begin(),
i_end = tree->leaves.end(); i != i_end; ++i)
{
if (i->second) {
new_leaves.push_back(*i);
continue;
}
property const &p = i->first;
std::pair< input_set::iterator, bool > ib = inputs.insert(std::make_pair(p.real, p));
if (!ib.second) // there was already a known range
ib.first->second.intersect(p);
}
for (input_set::const_iterator i = inputs.begin(),
i_end = inputs.end(); i != i_end; ++i)
{
ctx.hyp.push_back(i->second);
if (!i->second.real.pred_bnd()) continue;
interval const &bnd = i->second.bnd();
// bail out early if there is an empty set on an input
if (is_empty(bnd))
{
std::cerr << "Warning: the hypotheses on " << dump_real_short(i->first)
<< " are trivially contradictory, skipping.\n";
exit(0);
}
}
tree->leaves = new_leaves;
if (!tree->subtrees.empty() || !tree->leaves.empty())
ctx.goals = tree;
}
char *morphstr(char *origstr, int pos)
{
static char searchstr[WORDBUF], str[WORDBUF];
static int svcnt, svprep;
char word[WORDBUF], *tmp;
int cnt, st_idx = 0, end_idx;
int prep;
char *end_idx1, *end_idx2;
char *append;
if (pos == SATELLITE)
pos = ADJ;
/* First time through for this string */
if (origstr != NULL) {
/* Assume string hasn't had spaces substitued with '_' */
strtolower(strsubst(strcpy(str, origstr), ' ', '_'));
searchstr[0] = '\0';
cnt = cntwords(str, '_');
svprep = 0;
/* first try exception list */
if ((tmp = exc_lookup(str, pos)) && strcmp(tmp, str)) {
svcnt = 1; /* force next time to pass NULL */
return(tmp);
}
/* Then try simply morph on original string */
if (pos != VERB && (tmp = morphword(str, pos)) && strcmp(tmp, str))
return(tmp);
if (pos == VERB && cnt > 1 && (prep = hasprep(str, cnt))) {
/* assume we have a verb followed by a preposition */
svprep = prep;
return(morphprep(str));
} else {
svcnt = cnt = cntwords(str, '-');
while (origstr && --cnt) {
end_idx1 = strchr(str + st_idx, '_');
end_idx2 = strchr(str + st_idx, '-');
if (end_idx1 && end_idx2) {
if (end_idx1 < end_idx2) {
end_idx = (int)(end_idx1 - str);
append = "_";
} else {
end_idx = (int)(end_idx2 - str);
append = "-";
}
} else {
if (end_idx1) {
end_idx = (int)(end_idx1 - str);
append = "_";
} else {
end_idx = (int)(end_idx2 - str);
append = "-";
}
}
if (end_idx < 0) return(NULL); /* shouldn't do this */
strncpy(word, str + st_idx, end_idx - st_idx);
word[end_idx - st_idx] = '\0';
if(tmp = morphword(word, pos))
strcat(searchstr,tmp);
else
strcat(searchstr,word);
strcat(searchstr, append);
st_idx = end_idx + 1;
}
if(tmp = morphword(strcpy(word, str + st_idx), pos))
strcat(searchstr,tmp);
else
strcat(searchstr,word);
if(strcmp(searchstr, str) && is_defined(searchstr,pos))
return(searchstr);
else
return(NULL);
}
} else { /* subsequent call on string */
if (svprep) { /* if verb has preposition, no more morphs */
svprep = 0;
return(NULL);
} else if (svcnt == 1)
return(exc_lookup(NULL, pos));
else {
svcnt = 1;
if ((tmp = exc_lookup(str, pos)) && strcmp(tmp, str))
return(tmp);
else
return(NULL);
}
}
}
void Bytecodes::initialize() {
if (_is_initialized) return;
assert(number_of_codes <= 256, "too many bytecodes");
// initialize bytecode tables - didn't use static array initializers
// (such as {}) so we can do additional consistency checks and init-
// code is independent of actual bytecode numbering.
//
// Note 1: NULL for the format string means the bytecode doesn't exist
// in that form.
//
// Note 2: The result type is T_ILLEGAL for bytecodes where the top of stack
// type after execution is not only determined by the bytecode itself.
// Java bytecodes
// bytecode bytecode name format wide f. result tp stk traps
def(_nop , "nop" , "b" , NULL , T_VOID , 0, false);
def(_aconst_null , "aconst_null" , "b" , NULL , T_OBJECT , 1, false);
def(_iconst_m1 , "iconst_m1" , "b" , NULL , T_INT , 1, false);
def(_iconst_0 , "iconst_0" , "b" , NULL , T_INT , 1, false);
def(_iconst_1 , "iconst_1" , "b" , NULL , T_INT , 1, false);
def(_iconst_2 , "iconst_2" , "b" , NULL , T_INT , 1, false);
def(_iconst_3 , "iconst_3" , "b" , NULL , T_INT , 1, false);
def(_iconst_4 , "iconst_4" , "b" , NULL , T_INT , 1, false);
def(_iconst_5 , "iconst_5" , "b" , NULL , T_INT , 1, false);
def(_lconst_0 , "lconst_0" , "b" , NULL , T_LONG , 2, false);
def(_lconst_1 , "lconst_1" , "b" , NULL , T_LONG , 2, false);
def(_fconst_0 , "fconst_0" , "b" , NULL , T_FLOAT , 1, false);
def(_fconst_1 , "fconst_1" , "b" , NULL , T_FLOAT , 1, false);
def(_fconst_2 , "fconst_2" , "b" , NULL , T_FLOAT , 1, false);
def(_dconst_0 , "dconst_0" , "b" , NULL , T_DOUBLE , 2, false);
def(_dconst_1 , "dconst_1" , "b" , NULL , T_DOUBLE , 2, false);
def(_bipush , "bipush" , "bc" , NULL , T_INT , 1, false);
def(_sipush , "sipush" , "bcc" , NULL , T_INT , 1, false);
def(_ldc , "ldc" , "bk" , NULL , T_ILLEGAL, 1, true );
def(_ldc_w , "ldc_w" , "bkk" , NULL , T_ILLEGAL, 1, true );
def(_ldc2_w , "ldc2_w" , "bkk" , NULL , T_ILLEGAL, 2, true );
def(_iload , "iload" , "bi" , "wbii" , T_INT , 1, false);
def(_lload , "lload" , "bi" , "wbii" , T_LONG , 2, false);
def(_fload , "fload" , "bi" , "wbii" , T_FLOAT , 1, false);
def(_dload , "dload" , "bi" , "wbii" , T_DOUBLE , 2, false);
def(_aload , "aload" , "bi" , "wbii" , T_OBJECT , 1, false);
def(_iload_0 , "iload_0" , "b" , NULL , T_INT , 1, false);
def(_iload_1 , "iload_1" , "b" , NULL , T_INT , 1, false);
def(_iload_2 , "iload_2" , "b" , NULL , T_INT , 1, false);
def(_iload_3 , "iload_3" , "b" , NULL , T_INT , 1, false);
def(_lload_0 , "lload_0" , "b" , NULL , T_LONG , 2, false);
def(_lload_1 , "lload_1" , "b" , NULL , T_LONG , 2, false);
def(_lload_2 , "lload_2" , "b" , NULL , T_LONG , 2, false);
def(_lload_3 , "lload_3" , "b" , NULL , T_LONG , 2, false);
def(_fload_0 , "fload_0" , "b" , NULL , T_FLOAT , 1, false);
def(_fload_1 , "fload_1" , "b" , NULL , T_FLOAT , 1, false);
def(_fload_2 , "fload_2" , "b" , NULL , T_FLOAT , 1, false);
def(_fload_3 , "fload_3" , "b" , NULL , T_FLOAT , 1, false);
def(_dload_0 , "dload_0" , "b" , NULL , T_DOUBLE , 2, false);
def(_dload_1 , "dload_1" , "b" , NULL , T_DOUBLE , 2, false);
def(_dload_2 , "dload_2" , "b" , NULL , T_DOUBLE , 2, false);
def(_dload_3 , "dload_3" , "b" , NULL , T_DOUBLE , 2, false);
def(_aload_0 , "aload_0" , "b" , NULL , T_OBJECT , 1, true ); // rewriting in interpreter
def(_aload_1 , "aload_1" , "b" , NULL , T_OBJECT , 1, false);
def(_aload_2 , "aload_2" , "b" , NULL , T_OBJECT , 1, false);
def(_aload_3 , "aload_3" , "b" , NULL , T_OBJECT , 1, false);
def(_iaload , "iaload" , "b" , NULL , T_INT , -1, true );
def(_laload , "laload" , "b" , NULL , T_LONG , 0, true );
def(_faload , "faload" , "b" , NULL , T_FLOAT , -1, true );
def(_daload , "daload" , "b" , NULL , T_DOUBLE , 0, true );
def(_aaload , "aaload" , "b" , NULL , T_OBJECT , -1, true );
def(_baload , "baload" , "b" , NULL , T_INT , -1, true );
def(_caload , "caload" , "b" , NULL , T_INT , -1, true );
def(_saload , "saload" , "b" , NULL , T_INT , -1, true );
def(_istore , "istore" , "bi" , "wbii" , T_VOID , -1, false);
def(_lstore , "lstore" , "bi" , "wbii" , T_VOID , -2, false);
def(_fstore , "fstore" , "bi" , "wbii" , T_VOID , -1, false);
def(_dstore , "dstore" , "bi" , "wbii" , T_VOID , -2, false);
def(_astore , "astore" , "bi" , "wbii" , T_VOID , -1, false);
def(_istore_0 , "istore_0" , "b" , NULL , T_VOID , -1, false);
def(_istore_1 , "istore_1" , "b" , NULL , T_VOID , -1, false);
def(_istore_2 , "istore_2" , "b" , NULL , T_VOID , -1, false);
def(_istore_3 , "istore_3" , "b" , NULL , T_VOID , -1, false);
def(_lstore_0 , "lstore_0" , "b" , NULL , T_VOID , -2, false);
def(_lstore_1 , "lstore_1" , "b" , NULL , T_VOID , -2, false);
def(_lstore_2 , "lstore_2" , "b" , NULL , T_VOID , -2, false);
def(_lstore_3 , "lstore_3" , "b" , NULL , T_VOID , -2, false);
def(_fstore_0 , "fstore_0" , "b" , NULL , T_VOID , -1, false);
def(_fstore_1 , "fstore_1" , "b" , NULL , T_VOID , -1, false);
def(_fstore_2 , "fstore_2" , "b" , NULL , T_VOID , -1, false);
def(_fstore_3 , "fstore_3" , "b" , NULL , T_VOID , -1, false);
def(_dstore_0 , "dstore_0" , "b" , NULL , T_VOID , -2, false);
def(_dstore_1 , "dstore_1" , "b" , NULL , T_VOID , -2, false);
def(_dstore_2 , "dstore_2" , "b" , NULL , T_VOID , -2, false);
def(_dstore_3 , "dstore_3" , "b" , NULL , T_VOID , -2, false);
def(_astore_0 , "astore_0" , "b" , NULL , T_VOID , -1, false);
def(_astore_1 , "astore_1" , "b" , NULL , T_VOID , -1, false);
def(_astore_2 , "astore_2" , "b" , NULL , T_VOID , -1, false);
def(_astore_3 , "astore_3" , "b" , NULL , T_VOID , -1, false);
def(_iastore , "iastore" , "b" , NULL , T_VOID , -3, true );
def(_lastore , "lastore" , "b" , NULL , T_VOID , -4, true );
def(_fastore , "fastore" , "b" , NULL , T_VOID , -3, true );
def(_dastore , "dastore" , "b" , NULL , T_VOID , -4, true );
def(_aastore , "aastore" , "b" , NULL , T_VOID , -3, true );
def(_bastore , "bastore" , "b" , NULL , T_VOID , -3, true );
def(_castore , "castore" , "b" , NULL , T_VOID , -3, true );
def(_sastore , "sastore" , "b" , NULL , T_VOID , -3, true );
def(_pop , "pop" , "b" , NULL , T_VOID , -1, false);
def(_pop2 , "pop2" , "b" , NULL , T_VOID , -2, false);
def(_dup , "dup" , "b" , NULL , T_VOID , 1, false);
def(_dup_x1 , "dup_x1" , "b" , NULL , T_VOID , 1, false);
def(_dup_x2 , "dup_x2" , "b" , NULL , T_VOID , 1, false);
def(_dup2 , "dup2" , "b" , NULL , T_VOID , 2, false);
def(_dup2_x1 , "dup2_x1" , "b" , NULL , T_VOID , 2, false);
def(_dup2_x2 , "dup2_x2" , "b" , NULL , T_VOID , 2, false);
def(_swap , "swap" , "b" , NULL , T_VOID , 0, false);
def(_iadd , "iadd" , "b" , NULL , T_INT , -1, false);
def(_ladd , "ladd" , "b" , NULL , T_LONG , -2, false);
def(_fadd , "fadd" , "b" , NULL , T_FLOAT , -1, false);
def(_dadd , "dadd" , "b" , NULL , T_DOUBLE , -2, false);
def(_isub , "isub" , "b" , NULL , T_INT , -1, false);
def(_lsub , "lsub" , "b" , NULL , T_LONG , -2, false);
def(_fsub , "fsub" , "b" , NULL , T_FLOAT , -1, false);
def(_dsub , "dsub" , "b" , NULL , T_DOUBLE , -2, false);
def(_imul , "imul" , "b" , NULL , T_INT , -1, false);
def(_lmul , "lmul" , "b" , NULL , T_LONG , -2, false);
def(_fmul , "fmul" , "b" , NULL , T_FLOAT , -1, false);
def(_dmul , "dmul" , "b" , NULL , T_DOUBLE , -2, false);
def(_idiv , "idiv" , "b" , NULL , T_INT , -1, true );
def(_ldiv , "ldiv" , "b" , NULL , T_LONG , -2, true );
def(_fdiv , "fdiv" , "b" , NULL , T_FLOAT , -1, false);
def(_ddiv , "ddiv" , "b" , NULL , T_DOUBLE , -2, false);
def(_irem , "irem" , "b" , NULL , T_INT , -1, true );
def(_lrem , "lrem" , "b" , NULL , T_LONG , -2, true );
def(_frem , "frem" , "b" , NULL , T_FLOAT , -1, false);
def(_drem , "drem" , "b" , NULL , T_DOUBLE , -2, false);
def(_ineg , "ineg" , "b" , NULL , T_INT , 0, false);
def(_lneg , "lneg" , "b" , NULL , T_LONG , 0, false);
def(_fneg , "fneg" , "b" , NULL , T_FLOAT , 0, false);
def(_dneg , "dneg" , "b" , NULL , T_DOUBLE , 0, false);
def(_ishl , "ishl" , "b" , NULL , T_INT , -1, false);
def(_lshl , "lshl" , "b" , NULL , T_LONG , -1, false);
def(_ishr , "ishr" , "b" , NULL , T_INT , -1, false);
def(_lshr , "lshr" , "b" , NULL , T_LONG , -1, false);
def(_iushr , "iushr" , "b" , NULL , T_INT , -1, false);
def(_lushr , "lushr" , "b" , NULL , T_LONG , -1, false);
def(_iand , "iand" , "b" , NULL , T_INT , -1, false);
def(_land , "land" , "b" , NULL , T_LONG , -2, false);
def(_ior , "ior" , "b" , NULL , T_INT , -1, false);
def(_lor , "lor" , "b" , NULL , T_LONG , -2, false);
def(_ixor , "ixor" , "b" , NULL , T_INT , -1, false);
def(_lxor , "lxor" , "b" , NULL , T_LONG , -2, false);
def(_iinc , "iinc" , "bic" , "wbiicc", T_VOID , 0, false);
def(_i2l , "i2l" , "b" , NULL , T_LONG , 1, false);
def(_i2f , "i2f" , "b" , NULL , T_FLOAT , 0, false);
def(_i2d , "i2d" , "b" , NULL , T_DOUBLE , 1, false);
def(_l2i , "l2i" , "b" , NULL , T_INT , -1, false);
def(_l2f , "l2f" , "b" , NULL , T_FLOAT , -1, false);
def(_l2d , "l2d" , "b" , NULL , T_DOUBLE , 0, false);
def(_f2i , "f2i" , "b" , NULL , T_INT , 0, false);
def(_f2l , "f2l" , "b" , NULL , T_LONG , 1, false);
def(_f2d , "f2d" , "b" , NULL , T_DOUBLE , 1, false);
def(_d2i , "d2i" , "b" , NULL , T_INT , -1, false);
def(_d2l , "d2l" , "b" , NULL , T_LONG , 0, false);
def(_d2f , "d2f" , "b" , NULL , T_FLOAT , -1, false);
def(_i2b , "i2b" , "b" , NULL , T_BYTE , 0, false);
def(_i2c , "i2c" , "b" , NULL , T_CHAR , 0, false);
def(_i2s , "i2s" , "b" , NULL , T_SHORT , 0, false);
def(_lcmp , "lcmp" , "b" , NULL , T_VOID , -3, false);
def(_fcmpl , "fcmpl" , "b" , NULL , T_VOID , -1, false);
def(_fcmpg , "fcmpg" , "b" , NULL , T_VOID , -1, false);
def(_dcmpl , "dcmpl" , "b" , NULL , T_VOID , -3, false);
def(_dcmpg , "dcmpg" , "b" , NULL , T_VOID , -3, false);
def(_ifeq , "ifeq" , "boo" , NULL , T_VOID , -1, false);
def(_ifne , "ifne" , "boo" , NULL , T_VOID , -1, false);
def(_iflt , "iflt" , "boo" , NULL , T_VOID , -1, false);
def(_ifge , "ifge" , "boo" , NULL , T_VOID , -1, false);
def(_ifgt , "ifgt" , "boo" , NULL , T_VOID , -1, false);
def(_ifle , "ifle" , "boo" , NULL , T_VOID , -1, false);
def(_if_icmpeq , "if_icmpeq" , "boo" , NULL , T_VOID , -2, false);
def(_if_icmpne , "if_icmpne" , "boo" , NULL , T_VOID , -2, false);
def(_if_icmplt , "if_icmplt" , "boo" , NULL , T_VOID , -2, false);
def(_if_icmpge , "if_icmpge" , "boo" , NULL , T_VOID , -2, false);
def(_if_icmpgt , "if_icmpgt" , "boo" , NULL , T_VOID , -2, false);
def(_if_icmple , "if_icmple" , "boo" , NULL , T_VOID , -2, false);
def(_if_acmpeq , "if_acmpeq" , "boo" , NULL , T_VOID , -2, false);
def(_if_acmpne , "if_acmpne" , "boo" , NULL , T_VOID , -2, false);
def(_goto , "goto" , "boo" , NULL , T_VOID , 0, false);
def(_jsr , "jsr" , "boo" , NULL , T_INT , 0, false);
def(_ret , "ret" , "bi" , "wbii" , T_VOID , 0, false);
def(_tableswitch , "tableswitch" , "" , NULL , T_VOID , -1, false); // may have backward branches
def(_lookupswitch , "lookupswitch" , "" , NULL , T_VOID , -1, false); // rewriting in interpreter
def(_ireturn , "ireturn" , "b" , NULL , T_INT , -1, true);
def(_lreturn , "lreturn" , "b" , NULL , T_LONG , -2, true);
def(_freturn , "freturn" , "b" , NULL , T_FLOAT , -1, true);
def(_dreturn , "dreturn" , "b" , NULL , T_DOUBLE , -2, true);
def(_areturn , "areturn" , "b" , NULL , T_OBJECT , -1, true);
def(_return , "return" , "b" , NULL , T_VOID , 0, true);
def(_getstatic , "getstatic" , "bJJ" , NULL , T_ILLEGAL, 1, true );
def(_putstatic , "putstatic" , "bJJ" , NULL , T_ILLEGAL, -1, true );
def(_getfield , "getfield" , "bJJ" , NULL , T_ILLEGAL, 0, true );
def(_putfield , "putfield" , "bJJ" , NULL , T_ILLEGAL, -2, true );
def(_invokevirtual , "invokevirtual" , "bJJ" , NULL , T_ILLEGAL, -1, true);
def(_invokespecial , "invokespecial" , "bJJ" , NULL , T_ILLEGAL, -1, true);
def(_invokestatic , "invokestatic" , "bJJ" , NULL , T_ILLEGAL, 0, true);
def(_invokeinterface , "invokeinterface" , "bJJ__", NULL , T_ILLEGAL, -1, true);
def(_invokedynamic , "invokedynamic" , "bJJJJ", NULL , T_ILLEGAL, 0, true );
def(_new , "new" , "bkk" , NULL , T_OBJECT , 1, true );
def(_newarray , "newarray" , "bc" , NULL , T_OBJECT , 0, true );
def(_anewarray , "anewarray" , "bkk" , NULL , T_OBJECT , 0, true );
def(_arraylength , "arraylength" , "b" , NULL , T_VOID , 0, true );
def(_athrow , "athrow" , "b" , NULL , T_VOID , -1, true );
def(_checkcast , "checkcast" , "bkk" , NULL , T_OBJECT , 0, true );
def(_instanceof , "instanceof" , "bkk" , NULL , T_INT , 0, true );
def(_monitorenter , "monitorenter" , "b" , NULL , T_VOID , -1, true );
def(_monitorexit , "monitorexit" , "b" , NULL , T_VOID , -1, true );
def(_wide , "wide" , "" , NULL , T_VOID , 0, false);
def(_multianewarray , "multianewarray" , "bkkc" , NULL , T_OBJECT , 1, true );
def(_ifnull , "ifnull" , "boo" , NULL , T_VOID , -1, false);
def(_ifnonnull , "ifnonnull" , "boo" , NULL , T_VOID , -1, false);
def(_goto_w , "goto_w" , "boooo", NULL , T_VOID , 0, false);
def(_jsr_w , "jsr_w" , "boooo", NULL , T_INT , 0, false);
def(_breakpoint , "breakpoint" , "" , NULL , T_VOID , 0, true);
// JVM bytecodes
// bytecode bytecode name format wide f. result tp stk traps std code
def(_fast_agetfield , "fast_agetfield" , "bJJ" , NULL , T_OBJECT , 0, true , _getfield );
def(_fast_bgetfield , "fast_bgetfield" , "bJJ" , NULL , T_INT , 0, true , _getfield );
def(_fast_cgetfield , "fast_cgetfield" , "bJJ" , NULL , T_CHAR , 0, true , _getfield );
def(_fast_dgetfield , "fast_dgetfield" , "bJJ" , NULL , T_DOUBLE , 0, true , _getfield );
def(_fast_fgetfield , "fast_fgetfield" , "bJJ" , NULL , T_FLOAT , 0, true , _getfield );
def(_fast_igetfield , "fast_igetfield" , "bJJ" , NULL , T_INT , 0, true , _getfield );
def(_fast_lgetfield , "fast_lgetfield" , "bJJ" , NULL , T_LONG , 0, true , _getfield );
def(_fast_sgetfield , "fast_sgetfield" , "bJJ" , NULL , T_SHORT , 0, true , _getfield );
def(_fast_aputfield , "fast_aputfield" , "bJJ" , NULL , T_OBJECT , 0, true , _putfield );
def(_fast_bputfield , "fast_bputfield" , "bJJ" , NULL , T_INT , 0, true , _putfield );
def(_fast_cputfield , "fast_cputfield" , "bJJ" , NULL , T_CHAR , 0, true , _putfield );
def(_fast_dputfield , "fast_dputfield" , "bJJ" , NULL , T_DOUBLE , 0, true , _putfield );
def(_fast_fputfield , "fast_fputfield" , "bJJ" , NULL , T_FLOAT , 0, true , _putfield );
def(_fast_iputfield , "fast_iputfield" , "bJJ" , NULL , T_INT , 0, true , _putfield );
def(_fast_lputfield , "fast_lputfield" , "bJJ" , NULL , T_LONG , 0, true , _putfield );
def(_fast_sputfield , "fast_sputfield" , "bJJ" , NULL , T_SHORT , 0, true , _putfield );
def(_fast_aload_0 , "fast_aload_0" , "b" , NULL , T_OBJECT , 1, true , _aload_0 );
def(_fast_iaccess_0 , "fast_iaccess_0" , "b_JJ" , NULL , T_INT , 1, true , _aload_0 );
def(_fast_aaccess_0 , "fast_aaccess_0" , "b_JJ" , NULL , T_OBJECT , 1, true , _aload_0 );
def(_fast_faccess_0 , "fast_faccess_0" , "b_JJ" , NULL , T_OBJECT , 1, true , _aload_0 );
def(_fast_iload , "fast_iload" , "bi" , NULL , T_INT , 1, false, _iload);
def(_fast_iload2 , "fast_iload2" , "bi_i" , NULL , T_INT , 2, false, _iload);
def(_fast_icaload , "fast_icaload" , "bi_" , NULL , T_INT , 0, false, _iload);
// Faster method invocation.
def(_fast_invokevfinal , "fast_invokevfinal" , "bJJ" , NULL , T_ILLEGAL, -1, true, _invokevirtual );
def(_fast_linearswitch , "fast_linearswitch" , "" , NULL , T_VOID , -1, false, _lookupswitch );
def(_fast_binaryswitch , "fast_binaryswitch" , "" , NULL , T_VOID , -1, false, _lookupswitch );
def(_return_register_finalizer , "return_register_finalizer" , "b" , NULL , T_VOID , 0, true, _return);
def(_invokehandle , "invokehandle" , "bJJ" , NULL , T_ILLEGAL, -1, true, _invokevirtual );
def(_fast_aldc , "fast_aldc" , "bj" , NULL , T_OBJECT, 1, true, _ldc );
def(_fast_aldc_w , "fast_aldc_w" , "bJJ" , NULL , T_OBJECT, 1, true, _ldc_w );
def(_nofast_getfield , "nofast_getfield" , "bJJ" , NULL , T_ILLEGAL, 0, true, _getfield );
def(_nofast_putfield , "nofast_putfield" , "bJJ" , NULL , T_ILLEGAL, -2, true , _putfield );
def(_nofast_aload_0 , "nofast_aload_0" , "b" , NULL , T_ILLEGAL, 1, true , _aload_0 );
def(_nofast_iload , "nofast_iload" , "bi" , NULL , T_ILLEGAL, 1, false, _iload );
def(_shouldnotreachhere , "_shouldnotreachhere" , "b" , NULL , T_VOID , 0, false);
// compare can_trap information for each bytecode with the
// can_trap information for the corresponding base bytecode
// (if a rewritten bytecode can trap, so must the base bytecode)
#ifdef ASSERT
{ for (int i = 0; i < number_of_codes; i++) {
if (is_defined(i)) {
Code code = cast(i);
Code java = java_code(code);
if (can_trap(code) && !can_trap(java))
fatal("%s can trap => %s can trap, too", name(code), name(java));
}
}
}
#endif
// initialization successful
_is_initialized = true;
}
static char *morphprep(char *s)
{
char *rest, *exc_word, *lastwd = NULL, *last;
int i, offset, cnt;
char word[WORDBUF], end[WORDBUF];
static char retval[WORDBUF];
/* Assume that the verb is the first word in the phrase. Strip it
off, check for validity, then try various morphs with the
rest of the phrase tacked on, trying to find a match. */
rest = strchr(s, '_');
last = strrchr(s, '_');
if (rest != last) { /* more than 2 words */
if (lastwd = morphword(last + 1, NOUN)) {
strncpy(end, rest, last - rest + 1);
end[last-rest+1] = '\0';
strcat(end, lastwd);
}
}
strncpy(word, s, rest - s);
word[rest - s] = '\0';
for (i = 0, cnt = strlen(word); i < cnt; i++)
if (!isalnum(word[i])) return(NULL);
offset = offsets[VERB];
cnt = cnts[VERB];
/* First try to find the verb in the exception list */
if ((exc_word = exc_lookup(word, VERB)) &&
strcmp(exc_word, word)) {
sprintf(retval, "%s%s", exc_word, rest);
if(is_defined(retval, VERB))
return(retval);
else if (lastwd) {
sprintf(retval, "%s%s", exc_word, end);
if(is_defined(retval, VERB))
return(retval);
}
}
for (i = 0; i < cnt; i++) {
if ((exc_word = wordbase(word, (i + offset))) &&
strcmp(word, exc_word)) { /* ending is different */
sprintf(retval, "%s%s", exc_word, rest);
if(is_defined(retval, VERB))
return(retval);
else if (lastwd) {
sprintf(retval, "%s%s", exc_word, end);
if(is_defined(retval, VERB))
return(retval);
}
}
}
sprintf(retval, "%s%s", word, rest);
if (strcmp(s, retval))
return(retval);
if (lastwd) {
sprintf(retval, "%s%s", word, end);
if (strcmp(s, retval))
return(retval);
}
return(NULL);
}
static void recv_only_or_dump(struct ctx *ctx)
{
short ifflags = 0;
int sock, ifindex, fd = 0, ret;
size_t size;
unsigned int it = 0;
struct ring rx_ring;
struct pollfd rx_poll;
struct sock_fprog bpf_ops;
struct timeval start, end, diff;
bool is_v3 = is_defined(HAVE_TPACKET3);
sock = pf_socket_type(ctx->link_type);
ifindex = device_ifindex(ctx->device_in);
size = ring_size(ctx->device_in, ctx->reserve_size);
enable_kernel_bpf_jit_compiler();
bpf_parse_rules(ctx->filter, &bpf_ops, ctx->link_type);
if (ctx->dump_bpf)
bpf_dump_all(&bpf_ops);
bpf_attach_to_sock(sock, &bpf_ops);
if (ctx->hwtimestamp) {
ret = set_sockopt_hwtimestamp(sock, ctx->device_in);
if (ret == 0 && ctx->verbose)
printf("HW timestamping enabled\n");
}
ring_rx_setup(&rx_ring, sock, size, ifindex, &rx_poll, is_v3, true,
ctx->verbose, ctx->fanout_group, ctx->fanout_type);
dissector_init_all(ctx->print_mode);
if (ctx->cpu >= 0 && ifindex > 0) {
int irq = device_irq_number(ctx->device_in);
device_set_irq_affinity(irq, ctx->cpu);
if (ctx->verbose)
printf("IRQ: %s:%d > CPU%d\n",
ctx->device_in, irq, ctx->cpu);
}
if (ctx->promiscuous)
ifflags = device_enter_promiscuous_mode(ctx->device_in);
if (dump_to_pcap(ctx) && __pcap_io->init_once_pcap)
__pcap_io->init_once_pcap(true);
drop_privileges(ctx->enforce, ctx->uid, ctx->gid);
if (dump_to_pcap(ctx)) {
struct stat stats;
ret = stat(ctx->device_out, &stats);
if (ret < 0)
ctx->dump_dir = 0;
else
ctx->dump_dir = S_ISDIR(stats.st_mode);
if (ctx->dump_dir)
fd = begin_multi_pcap_file(ctx);
else
fd = begin_single_pcap_file(ctx);
}
printf("Running! Hang up with ^C!\n\n");
fflush(stdout);
bug_on(gettimeofday(&start, NULL));
while (likely(sigint == 0)) {
#ifdef HAVE_TPACKET3
struct block_desc *pbd;
while (user_may_pull_from_rx_block((pbd = rx_ring.frames[it].iov_base))) {
walk_t3_block(pbd, ctx, sock, &fd);
kernel_may_pull_from_rx_block(pbd);
it = (it + 1) % rx_ring.layout3.tp_block_nr;
if (unlikely(sigint == 1))
break;
}
#else
while (user_may_pull_from_rx(rx_ring.frames[it].iov_base)) {
struct frame_map *hdr = rx_ring.frames[it].iov_base;
uint8_t *packet = ((uint8_t *) hdr) + hdr->tp_h.tp_mac;
pcap_pkthdr_t phdr;
if (ctx->packet_type != -1)
if (ctx->packet_type != hdr->s_ll.sll_pkttype)
goto next;
ctx->pkts_seen++;
if (unlikely(ring_frame_size(&rx_ring) < hdr->tp_h.tp_snaplen)) {
/* XXX: silently ignore for now. We used to
* report them with dump_rx_stats() */
goto next;
}
if (dump_to_pcap(ctx)) {
tpacket_hdr_to_pcap_pkthdr(&hdr->tp_h, &hdr->s_ll, &phdr, ctx->magic);
ret = __pcap_io->write_pcap(fd, &phdr, ctx->magic, packet,
pcap_get_length(&phdr, ctx->magic));
if (unlikely(ret != (int) pcap_get_total_length(&phdr, ctx->magic)))
panic("Write error to pcap!\n");
}
show_frame_hdr(packet, hdr->tp_h.tp_snaplen,
ctx->link_type, hdr, ctx->print_mode,
ctx->pkts_seen);
dissector_entry_point(packet, hdr->tp_h.tp_snaplen,
ctx->link_type, ctx->print_mode,
&hdr->s_ll);
if (frame_count_max != 0) {
if (unlikely(ctx->pkts_seen >= frame_count_max)) {
sigint = 1;
break;
}
}
next:
kernel_may_pull_from_rx(&hdr->tp_h);
it = (it + 1) % rx_ring.layout.tp_frame_nr;
if (unlikely(sigint == 1))
break;
update_pcap_next_dump(ctx, hdr->tp_h.tp_snaplen, &fd,
sock, is_v3);
}
#endif /* HAVE_TPACKET3 */
ret = poll(&rx_poll, 1, -1);
if (unlikely(ret < 0)) {
if (errno != EINTR)
panic("Poll failed!\n");
}
}
bug_on(gettimeofday(&end, NULL));
timersub(&end, &start, &diff);
dump_rx_stats(ctx, sock, is_v3);
printf("\r%12lu sec, %lu usec in total\n",
diff.tv_sec, diff.tv_usec);
bpf_release(&bpf_ops);
dissector_cleanup_all();
destroy_rx_ring(sock, &rx_ring);
if (ctx->promiscuous)
device_leave_promiscuous_mode(ctx->device_in, ifflags);
if (ctx->rfraw)
leave_rfmon_mac80211(ctx->device_in);
if (dump_to_pcap(ctx)) {
if (ctx->dump_dir)
finish_multi_pcap_file(ctx, fd);
else
finish_single_pcap_file(ctx, fd);
}
close(sock);
}