void
print_insn (char *buf, const_rtx x, int verbose)
{
char t[BUF_LEN];
const_rtx insn = x;
switch (GET_CODE (x))
{
case INSN:
print_pattern (t, PATTERN (x), verbose);
#ifdef INSN_SCHEDULING
if (verbose && current_sched_info)
sprintf (buf, "%s: %s", (*current_sched_info->print_insn) (x, 1),
t);
else
#endif
sprintf (buf, " %4d %s", INSN_UID (x), t);
break;
case JUMP_INSN:
print_pattern (t, PATTERN (x), verbose);
#ifdef INSN_SCHEDULING
if (verbose && current_sched_info)
sprintf (buf, "%s: jump %s", (*current_sched_info->print_insn) (x, 1),
t);
else
#endif
sprintf (buf, " %4d %s", INSN_UID (x), t);
break;
case CALL_INSN:
x = PATTERN (insn);
if (GET_CODE (x) == PARALLEL)
{
x = XVECEXP (x, 0, 0);
print_pattern (t, x, verbose);
}
else
strcpy (t, "call <...>");
#ifdef INSN_SCHEDULING
if (verbose && current_sched_info)
sprintf (buf, "%s: %s", (*current_sched_info->print_insn) (insn, 1), t);
else
#endif
sprintf (buf, " %4d %s", INSN_UID (insn), t);
break;
case CODE_LABEL:
sprintf (buf, "L%d:", INSN_UID (x));
break;
case BARRIER:
sprintf (buf, "i%4d: barrier", INSN_UID (x));
break;
case NOTE:
sprintf (buf, " %4d %s", INSN_UID (x),
GET_NOTE_INSN_NAME (NOTE_KIND (x)));
break;
default:
sprintf (buf, "i%4d <What %s?>", INSN_UID (x),
GET_RTX_NAME (GET_CODE (x)));
}
} /* print_insn */
int main() {
int n = 4;
for(int i = 0; i < n; i++) {
print_pattern(8, " *");
print_pattern(8, "* ");
}
}
int main(int argc, char *argv[]) {
char pattern[9][9];
char possibilities[9][9][9];
if (argc < 2) {
fprintf(stderr, "Usage: %s pattern-file\n", argv[0]);
exit(EXIT_FAILURE);
}
read_file(argv[1], pattern);
printf("Beginning Pattern:\n");
print_pattern(pattern);
switch(check_solved_legal(pattern)) {
case 1 :
printf("\nAlready solved!\n");
return 0;
case -1 :
printf("\nUnsolvable, illegal moves\n");
return 0;
}
build_possibilities(possibilities);
int count = 0;
int iterations = 1;
do {
first_pass(pattern, possibilities);
count++;
} while (change_check_pull(pattern, possibilities));
printf("\nBase Passes: %d\n\n", count);
switch(check_solved_legal(pattern)) {
case 1 :
print_pattern(pattern);
printf("\nSolved!\n");
return 0;
case -1 :
printf("\nIllegal moves\n");
return 0;
}
print_pattern(pattern);
printf("\nBegin iterations:\n\n");
begin = clock();
iterations += try_possibility(pattern, possibilities);
return 0;
}
const char *
str_pattern_slim (const_rtx x)
{
pretty_printer rtl_slim_pp;
print_pattern (&rtl_slim_pp, x, 0);
return ggc_strdup (pp_formatted_text (&rtl_slim_pp));
}
static void
verify_print_pattern (const char *expected, rtx pat)
{
pretty_printer pp;
print_pattern (&pp, pat, 1);
ASSERT_STREQ (expected, pp_formatted_text (&pp));
}
void print_pattern(int N, int diff, int present)
{
printf("%d ", present);
if (diff > 0)
{
if (present <= N && present > 0)
print_pattern(N, diff, present - diff);
if (present + diff <= N)
printf("%d ", present + diff);
}
}
void main()
{
int N, diff;
printf("Enter the starting No. : ");
scanf_s("%d", &N);
printf("Enter the difference value :");
scanf_s("%d", &diff);
print_pattern(N, diff, N);
_getch();
}
/**
* Shows the contents of the patternlist.
*
* (Prints to STDOUT.)
*
* @param eidx Index into the global Environment array, identifying the element
* whose patternlist is to be printed.
*/
void
show_patternlist(int eidx)
{
int i;
Rprintf("\n==================== Pattern List:\n\n");
Rprintf("Size: %d\n", Environment[eidx].MaxPatIndex + 1);
for(i = 0; i <= Environment[eidx].MaxPatIndex; i++) {
Rprintf("Pattern #%d:\n", i);
print_pattern(eidx, i, 0);
}
Rprintf("\n==================== End of Pattern List\n\n");
}
static void
print_insn_with_notes (pretty_printer *pp, const_rtx x)
{
pp_string (pp, print_rtx_head);
print_insn (pp, x, 1);
pp_newline (pp);
if (INSN_P (x) && REG_NOTES (x))
for (rtx note = REG_NOTES (x); note; note = XEXP (note, 1))
{
pp_printf (pp, "%s %s ", print_rtx_head,
GET_REG_NOTE_NAME (REG_NOTE_KIND (note)));
if (GET_CODE (note) == INT_LIST)
pp_printf (pp, "%d", XINT (note, 0));
else
print_pattern (pp, XEXP (note, 0), 1);
pp_newline (pp);
}
}
/********************************************************************
* Project database
********************************************************************/
void Prefixspan::project(Pairdata &projected) {
if (projected.database.size() < min_sup)
return;
if ((max_sup == 0 || projected.database.size() <= max_sup) && pattern.size() >= min_pat)
print_pattern(projected);
if (max_pat != 0 && pattern.size() == max_pat)
return;
map<unsigned int, unsigned int> map_item;
const vector<Transaction> &database = projected.database;
for (unsigned int i = 0; i < database.size(); i++) {
const vector<unsigned int> &itemset = database[i].second;
for (unsigned int iter = projected.indeces[i]; iter < itemset.size(); iter++)
++map_item[itemset[iter]];
}
Pairdata pairdata;
vector<Transaction> &new_database = pairdata.database;
vector<unsigned int> &new_indeces = pairdata.indeces;
for (map<unsigned int, unsigned int>::iterator it_1 = map_item.begin(); it_1 != map_item.end(); it_1++) {
for (unsigned int i = 0; i < database.size(); i++) {
const Transaction &transaction = database[i];
const vector<unsigned int> &itemset = transaction.second;
for (unsigned int iter = projected.indeces[i]; iter < itemset.size(); iter++) {
if (itemset[iter] == it_1->first) {
new_database.push_back(transaction);
new_indeces.push_back(iter + 1);
break;
}
}
}
pattern.push_back(it_1->first);
project(pairdata);
pattern.pop_back();
pairdata.clear();
}
}
static int nvmStringMatchCoproMatchFoundCallback (void *add_data, int pattern_offset, void *search_data) {
nvmStringMatchCoproInternalData *smcdata;
nvmStringMatchCoproPattern *p;
nvmStringMatchCoproMatchResult *r;
smcdata = (nvmStringMatchCoproInternalData *) search_data;
p = (nvmStringMatchCoproPattern *) add_data;
smdebug ("String match %d at offset %d, len = %d, data = %u: \"", smcdata -> matches_no, pattern_offset, p -> len, p -> data);
//printf ("String match %d at offset %d, len = %d, data = %u: \"", smcdata -> matches_no, pattern_offset, p -> len, p -> data);
print_pattern (p -> pattern, p -> len);
smdebug ("\"\n");
if (smcdata -> matches_no < MAX_MATCHES) {
r = &(smcdata -> matches[smcdata -> matches_no]);
r -> p = p;
r -> offset = pattern_offset;
smcdata -> matches_no++;
} else {
fprintf (stderr, "Too many matches, cannot add last match!\n");
}
return (0); // 0 = Go on, 1 = Stop search (?)
}
void
print_insn (pretty_printer *pp, const_rtx x, int verbose)
{
if (verbose)
{
/* Blech, pretty-print can't print integers with a specified width. */
char uid_prefix[32];
snprintf (uid_prefix, sizeof uid_prefix, " %4d: ", INSN_UID (x));
pp_string (pp, uid_prefix);
}
switch (GET_CODE (x))
{
case INSN:
print_pattern (pp, PATTERN (x), verbose);
break;
case DEBUG_INSN:
{
const char *name = "?";
if (DECL_P (INSN_VAR_LOCATION_DECL (x)))
{
tree id = DECL_NAME (INSN_VAR_LOCATION_DECL (x));
char idbuf[32];
if (id)
name = IDENTIFIER_POINTER (id);
else if (TREE_CODE (INSN_VAR_LOCATION_DECL (x))
== DEBUG_EXPR_DECL)
{
sprintf (idbuf, "D#%i",
DEBUG_TEMP_UID (INSN_VAR_LOCATION_DECL (x)));
name = idbuf;
}
else
{
sprintf (idbuf, "D.%i",
DECL_UID (INSN_VAR_LOCATION_DECL (x)));
name = idbuf;
}
}
pp_printf (pp, "debug %s => ", name);
if (VAR_LOC_UNKNOWN_P (INSN_VAR_LOCATION_LOC (x)))
pp_string (pp, "optimized away");
else
print_pattern (pp, INSN_VAR_LOCATION_LOC (x), verbose);
}
break;
case JUMP_INSN:
print_pattern (pp, PATTERN (x), verbose);
break;
case CALL_INSN:
if (GET_CODE (PATTERN (x)) == PARALLEL)
print_pattern (pp, XVECEXP (PATTERN (x), 0, 0), verbose);
else
print_pattern (pp, PATTERN (x), verbose);
break;
case CODE_LABEL:
pp_printf (pp, "L%d:", INSN_UID (x));
break;
case JUMP_TABLE_DATA:
pp_string (pp, "jump_table_data{\n");
print_pattern (pp, PATTERN (x), verbose);
pp_right_brace (pp);
break;
case BARRIER:
pp_string (pp, "barrier");
break;
case NOTE:
{
pp_string (pp, GET_NOTE_INSN_NAME (NOTE_KIND (x)));
switch (NOTE_KIND (x))
{
case NOTE_INSN_EH_REGION_BEG:
case NOTE_INSN_EH_REGION_END:
pp_printf (pp, " %d", NOTE_EH_HANDLER (x));
break;
case NOTE_INSN_BLOCK_BEG:
case NOTE_INSN_BLOCK_END:
pp_printf (pp, " %d", BLOCK_NUMBER (NOTE_BLOCK (x)));
break;
case NOTE_INSN_BASIC_BLOCK:
pp_printf (pp, " %d", NOTE_BASIC_BLOCK (x)->index);
break;
case NOTE_INSN_DELETED_LABEL:
case NOTE_INSN_DELETED_DEBUG_LABEL:
{
const char *label = NOTE_DELETED_LABEL_NAME (x);
if (label == NULL)
label = "";
pp_printf (pp, " (\"%s\")", label);
}
break;
case NOTE_INSN_VAR_LOCATION:
case NOTE_INSN_CALL_ARG_LOCATION:
pp_left_brace (pp);
print_pattern (pp, NOTE_VAR_LOCATION (x), verbose);
pp_right_brace (pp);
break;
default:
break;
}
break;
}
default:
gcc_unreachable ();
}
} /* print_insn */
static void
print_exp (pretty_printer *pp, const_rtx x, int verbose)
{
const char *st[4];
const char *fun;
rtx op[4];
int i;
fun = (char *) 0;
for (i = 0; i < 4; i++)
{
st[i] = (char *) 0;
op[i] = NULL_RTX;
}
switch (GET_CODE (x))
{
case PLUS:
op[0] = XEXP (x, 0);
if (CONST_INT_P (XEXP (x, 1))
&& INTVAL (XEXP (x, 1)) < 0)
{
st[1] = "-";
op[1] = GEN_INT (-INTVAL (XEXP (x, 1)));
}
else
{
st[1] = "+";
op[1] = XEXP (x, 1);
}
break;
case LO_SUM:
op[0] = XEXP (x, 0);
st[1] = "+low(";
op[1] = XEXP (x, 1);
st[2] = ")";
break;
case MINUS:
op[0] = XEXP (x, 0);
st[1] = "-";
op[1] = XEXP (x, 1);
break;
case COMPARE:
fun = "cmp";
op[0] = XEXP (x, 0);
op[1] = XEXP (x, 1);
break;
case NEG:
st[0] = "-";
op[0] = XEXP (x, 0);
break;
case FMA:
st[0] = "{";
op[0] = XEXP (x, 0);
st[1] = "*";
op[1] = XEXP (x, 1);
st[2] = "+";
op[2] = XEXP (x, 2);
st[3] = "}";
break;
case MULT:
op[0] = XEXP (x, 0);
st[1] = "*";
op[1] = XEXP (x, 1);
break;
case DIV:
op[0] = XEXP (x, 0);
st[1] = "/";
op[1] = XEXP (x, 1);
break;
case UDIV:
fun = "udiv";
op[0] = XEXP (x, 0);
op[1] = XEXP (x, 1);
break;
case MOD:
op[0] = XEXP (x, 0);
st[1] = "%";
op[1] = XEXP (x, 1);
break;
case UMOD:
fun = "umod";
op[0] = XEXP (x, 0);
op[1] = XEXP (x, 1);
break;
case SMIN:
fun = "smin";
op[0] = XEXP (x, 0);
op[1] = XEXP (x, 1);
break;
case SMAX:
fun = "smax";
op[0] = XEXP (x, 0);
op[1] = XEXP (x, 1);
break;
case UMIN:
fun = "umin";
op[0] = XEXP (x, 0);
op[1] = XEXP (x, 1);
break;
case UMAX:
fun = "umax";
op[0] = XEXP (x, 0);
op[1] = XEXP (x, 1);
break;
case NOT:
st[0] = "!";
op[0] = XEXP (x, 0);
break;
case AND:
op[0] = XEXP (x, 0);
st[1] = "&";
op[1] = XEXP (x, 1);
break;
case IOR:
op[0] = XEXP (x, 0);
st[1] = "|";
op[1] = XEXP (x, 1);
break;
case XOR:
op[0] = XEXP (x, 0);
st[1] = "^";
op[1] = XEXP (x, 1);
break;
case ASHIFT:
op[0] = XEXP (x, 0);
st[1] = "<<";
op[1] = XEXP (x, 1);
break;
case LSHIFTRT:
op[0] = XEXP (x, 0);
st[1] = " 0>>";
op[1] = XEXP (x, 1);
break;
case ASHIFTRT:
op[0] = XEXP (x, 0);
st[1] = ">>";
op[1] = XEXP (x, 1);
break;
case ROTATE:
op[0] = XEXP (x, 0);
st[1] = "<-<";
op[1] = XEXP (x, 1);
break;
case ROTATERT:
op[0] = XEXP (x, 0);
st[1] = ">->";
op[1] = XEXP (x, 1);
break;
case NE:
op[0] = XEXP (x, 0);
st[1] = "!=";
op[1] = XEXP (x, 1);
break;
case EQ:
op[0] = XEXP (x, 0);
st[1] = "==";
op[1] = XEXP (x, 1);
break;
case GE:
op[0] = XEXP (x, 0);
st[1] = ">=";
op[1] = XEXP (x, 1);
break;
case GT:
op[0] = XEXP (x, 0);
st[1] = ">";
op[1] = XEXP (x, 1);
break;
case LE:
op[0] = XEXP (x, 0);
st[1] = "<=";
op[1] = XEXP (x, 1);
break;
case LT:
op[0] = XEXP (x, 0);
st[1] = "<";
op[1] = XEXP (x, 1);
break;
case SIGN_EXTRACT:
fun = (verbose) ? "sign_extract" : "sxt";
op[0] = XEXP (x, 0);
op[1] = XEXP (x, 1);
op[2] = XEXP (x, 2);
break;
case ZERO_EXTRACT:
fun = (verbose) ? "zero_extract" : "zxt";
op[0] = XEXP (x, 0);
op[1] = XEXP (x, 1);
op[2] = XEXP (x, 2);
break;
case SIGN_EXTEND:
fun = (verbose) ? "sign_extend" : "sxn";
op[0] = XEXP (x, 0);
break;
case ZERO_EXTEND:
fun = (verbose) ? "zero_extend" : "zxn";
op[0] = XEXP (x, 0);
break;
case FLOAT_EXTEND:
fun = (verbose) ? "float_extend" : "fxn";
op[0] = XEXP (x, 0);
break;
case TRUNCATE:
fun = (verbose) ? "trunc" : "trn";
op[0] = XEXP (x, 0);
break;
case FLOAT_TRUNCATE:
fun = (verbose) ? "float_trunc" : "ftr";
op[0] = XEXP (x, 0);
break;
case FLOAT:
fun = (verbose) ? "float" : "flt";
op[0] = XEXP (x, 0);
break;
case UNSIGNED_FLOAT:
fun = (verbose) ? "uns_float" : "ufl";
op[0] = XEXP (x, 0);
break;
case FIX:
fun = "fix";
op[0] = XEXP (x, 0);
break;
case UNSIGNED_FIX:
fun = (verbose) ? "uns_fix" : "ufx";
op[0] = XEXP (x, 0);
break;
case PRE_DEC:
st[0] = "--";
op[0] = XEXP (x, 0);
break;
case PRE_INC:
st[0] = "++";
op[0] = XEXP (x, 0);
break;
case POST_DEC:
op[0] = XEXP (x, 0);
st[1] = "--";
break;
case POST_INC:
op[0] = XEXP (x, 0);
st[1] = "++";
break;
case PRE_MODIFY:
st[0] = "pre ";
op[0] = XEXP (XEXP (x, 1), 0);
st[1] = "+=";
op[1] = XEXP (XEXP (x, 1), 1);
break;
case POST_MODIFY:
st[0] = "post ";
op[0] = XEXP (XEXP (x, 1), 0);
st[1] = "+=";
op[1] = XEXP (XEXP (x, 1), 1);
break;
case CALL:
st[0] = "call ";
op[0] = XEXP (x, 0);
if (verbose)
{
st[1] = " argc:";
op[1] = XEXP (x, 1);
}
break;
case IF_THEN_ELSE:
st[0] = "{(";
op[0] = XEXP (x, 0);
st[1] = ")?";
op[1] = XEXP (x, 1);
st[2] = ":";
op[2] = XEXP (x, 2);
st[3] = "}";
break;
case TRAP_IF:
fun = "trap_if";
op[0] = TRAP_CONDITION (x);
break;
case PREFETCH:
fun = "prefetch";
op[0] = XEXP (x, 0);
op[1] = XEXP (x, 1);
op[2] = XEXP (x, 2);
break;
case UNSPEC:
case UNSPEC_VOLATILE:
{
pp_string (pp, "unspec");
if (GET_CODE (x) == UNSPEC_VOLATILE)
pp_string (pp, "/v");
pp_left_bracket (pp);
for (i = 0; i < XVECLEN (x, 0); i++)
{
if (i != 0)
pp_comma (pp);
print_pattern (pp, XVECEXP (x, 0, i), verbose);
}
pp_string (pp, "] ");
pp_decimal_int (pp, XINT (x, 1));
}
break;
default:
{
/* Most unhandled codes can be printed as pseudo-functions. */
if (GET_RTX_CLASS (GET_CODE (x)) == RTX_UNARY)
{
fun = GET_RTX_NAME (GET_CODE (x));
op[0] = XEXP (x, 0);
}
else if (GET_RTX_CLASS (GET_CODE (x)) == RTX_COMPARE
|| GET_RTX_CLASS (GET_CODE (x)) == RTX_COMM_COMPARE
|| GET_RTX_CLASS (GET_CODE (x)) == RTX_BIN_ARITH
|| GET_RTX_CLASS (GET_CODE (x)) == RTX_COMM_ARITH)
{
fun = GET_RTX_NAME (GET_CODE (x));
op[0] = XEXP (x, 0);
op[1] = XEXP (x, 1);
}
else if (GET_RTX_CLASS (GET_CODE (x)) == RTX_TERNARY)
{
fun = GET_RTX_NAME (GET_CODE (x));
op[0] = XEXP (x, 0);
op[1] = XEXP (x, 1);
op[2] = XEXP (x, 2);
}
else
/* Give up, just print the RTX name. */
st[0] = GET_RTX_NAME (GET_CODE (x));
}
break;
}
/* Print this as a function? */
if (fun)
{
pp_string (pp, fun);
pp_left_paren (pp);
}
for (i = 0; i < 4; i++)
{
if (st[i])
pp_string (pp, st[i]);
if (op[i])
{
if (fun && i != 0)
pp_comma (pp);
print_value (pp, op[i], verbose);
}
}
if (fun)
pp_right_paren (pp);
} /* print_exp */
void
print_pattern (pretty_printer *pp, const_rtx x, int verbose)
{
if (! x)
{
pp_string (pp, "(nil)");
return;
}
switch (GET_CODE (x))
{
case SET:
print_value (pp, SET_DEST (x), verbose);
pp_equal (pp);
print_value (pp, SET_SRC (x), verbose);
break;
case RETURN:
case SIMPLE_RETURN:
case EH_RETURN:
pp_string (pp, GET_RTX_NAME (GET_CODE (x)));
break;
case CALL:
print_exp (pp, x, verbose);
break;
case CLOBBER:
case USE:
pp_printf (pp, "%s ", GET_RTX_NAME (GET_CODE (x)));
print_value (pp, XEXP (x, 0), verbose);
break;
case VAR_LOCATION:
pp_string (pp, "loc ");
print_value (pp, PAT_VAR_LOCATION_LOC (x), verbose);
break;
case COND_EXEC:
pp_left_paren (pp);
if (GET_CODE (COND_EXEC_TEST (x)) == NE
&& XEXP (COND_EXEC_TEST (x), 1) == const0_rtx)
print_value (pp, XEXP (COND_EXEC_TEST (x), 0), verbose);
else if (GET_CODE (COND_EXEC_TEST (x)) == EQ
&& XEXP (COND_EXEC_TEST (x), 1) == const0_rtx)
{
pp_exclamation (pp);
print_value (pp, XEXP (COND_EXEC_TEST (x), 0), verbose);
}
else
print_value (pp, COND_EXEC_TEST (x), verbose);
pp_string (pp, ") ");
print_pattern (pp, COND_EXEC_CODE (x), verbose);
break;
case PARALLEL:
{
int i;
pp_left_brace (pp);
for (i = 0; i < XVECLEN (x, 0); i++)
{
print_pattern (pp, XVECEXP (x, 0, i), verbose);
pp_semicolon (pp);
}
pp_right_brace (pp);
}
break;
case SEQUENCE:
{
pp_string (pp, "sequence{");
if (INSN_P (XVECEXP (x, 0, 0)))
{
/* Print the sequence insns indented. */
const char * save_print_rtx_head = print_rtx_head;
char indented_print_rtx_head[32];
pp_newline (pp);
gcc_assert (strlen (print_rtx_head) < sizeof (indented_print_rtx_head) - 4);
snprintf (indented_print_rtx_head,
sizeof (indented_print_rtx_head),
"%s ", print_rtx_head);
print_rtx_head = indented_print_rtx_head;
for (int i = 0; i < XVECLEN (x, 0); i++)
print_insn_with_notes (pp, XVECEXP (x, 0, i));
pp_printf (pp, "%s ", save_print_rtx_head);
print_rtx_head = save_print_rtx_head;
}
else
{
for (int i = 0; i < XVECLEN (x, 0); i++)
{
print_pattern (pp, XVECEXP (x, 0, i), verbose);
pp_semicolon (pp);
}
}
pp_right_brace (pp);
}
break;
case ASM_INPUT:
pp_printf (pp, "asm {%s}", XSTR (x, 0));
break;
case ADDR_VEC:
/* Fall through. */
case ADDR_DIFF_VEC:
print_value (pp, XEXP (x, 0), verbose);
break;
case TRAP_IF:
pp_string (pp, "trap_if ");
print_value (pp, TRAP_CONDITION (x), verbose);
break;
case UNSPEC:
case UNSPEC_VOLATILE:
/* Fallthru -- leave UNSPECs to print_exp. */
default:
print_value (pp, x, verbose);
}
} /* print_pattern */
void
print_insn (char *buf, const_rtx x, int verbose)
{
char t[BUF_LEN];
const_rtx insn = x;
switch (GET_CODE (x))
{
case INSN:
print_pattern (t, PATTERN (x), verbose);
#ifdef INSN_SCHEDULING
if (verbose && current_sched_info)
sprintf (buf, "%s: %s", (*current_sched_info->print_insn) (x, 1),
t);
else
#endif
sprintf (buf, " %4d %s", INSN_UID (x), t);
break;
case DEBUG_INSN:
{
const char *name = "?";
if (DECL_P (INSN_VAR_LOCATION_DECL (insn)))
{
tree id = DECL_NAME (INSN_VAR_LOCATION_DECL (insn));
char idbuf[32];
if (id)
name = IDENTIFIER_POINTER (id);
else if (TREE_CODE (INSN_VAR_LOCATION_DECL (insn))
== DEBUG_EXPR_DECL)
{
sprintf (idbuf, "D#%i",
DEBUG_TEMP_UID (INSN_VAR_LOCATION_DECL (insn)));
name = idbuf;
}
else
{
sprintf (idbuf, "D.%i",
DECL_UID (INSN_VAR_LOCATION_DECL (insn)));
name = idbuf;
}
}
if (VAR_LOC_UNKNOWN_P (INSN_VAR_LOCATION_LOC (insn)))
sprintf (buf, " %4d: debug %s optimized away", INSN_UID (insn), name);
else
{
print_pattern (t, INSN_VAR_LOCATION_LOC (insn), verbose);
sprintf (buf, " %4d: debug %s => %s", INSN_UID (insn), name, t);
}
}
break;
case JUMP_INSN:
print_pattern (t, PATTERN (x), verbose);
#ifdef INSN_SCHEDULING
if (verbose && current_sched_info)
sprintf (buf, "%s: jump %s", (*current_sched_info->print_insn) (x, 1),
t);
else
#endif
sprintf (buf, " %4d %s", INSN_UID (x), t);
break;
case CALL_INSN:
x = PATTERN (insn);
if (GET_CODE (x) == PARALLEL)
{
x = XVECEXP (x, 0, 0);
print_pattern (t, x, verbose);
}
else
strcpy (t, "call <...>");
#ifdef INSN_SCHEDULING
if (verbose && current_sched_info)
sprintf (buf, "%s: %s", (*current_sched_info->print_insn) (insn, 1), t);
else
#endif
sprintf (buf, " %4d %s", INSN_UID (insn), t);
break;
case CODE_LABEL:
sprintf (buf, "L%d:", INSN_UID (x));
break;
case BARRIER:
sprintf (buf, "i%4d: barrier", INSN_UID (x));
break;
case NOTE:
sprintf (buf, " %4d %s", INSN_UID (x),
GET_NOTE_INSN_NAME (NOTE_KIND (x)));
break;
default:
sprintf (buf, "i%4d <What %s?>", INSN_UID (x),
GET_RTX_NAME (GET_CODE (x)));
}
} /* print_insn */
static void
print_exp (char *buf, const_rtx x, int verbose)
{
char tmp[BUF_LEN];
const char *st[4];
char *cur = buf;
const char *fun = (char *) 0;
const char *sep;
rtx op[4];
int i;
for (i = 0; i < 4; i++)
{
st[i] = (char *) 0;
op[i] = NULL_RTX;
}
switch (GET_CODE (x))
{
case PLUS:
op[0] = XEXP (x, 0);
if (CONST_INT_P (XEXP (x, 1))
&& INTVAL (XEXP (x, 1)) < 0)
{
st[1] = "-";
op[1] = GEN_INT (-INTVAL (XEXP (x, 1)));
}
else
{
st[1] = "+";
op[1] = XEXP (x, 1);
}
break;
case LO_SUM:
op[0] = XEXP (x, 0);
st[1] = "+low(";
op[1] = XEXP (x, 1);
st[2] = ")";
break;
case MINUS:
op[0] = XEXP (x, 0);
st[1] = "-";
op[1] = XEXP (x, 1);
break;
case COMPARE:
fun = "cmp";
op[0] = XEXP (x, 0);
op[1] = XEXP (x, 1);
break;
case NEG:
st[0] = "-";
op[0] = XEXP (x, 0);
break;
case MULT:
op[0] = XEXP (x, 0);
st[1] = "*";
op[1] = XEXP (x, 1);
break;
case DIV:
op[0] = XEXP (x, 0);
st[1] = "/";
op[1] = XEXP (x, 1);
break;
case UDIV:
fun = "udiv";
op[0] = XEXP (x, 0);
op[1] = XEXP (x, 1);
break;
case MOD:
op[0] = XEXP (x, 0);
st[1] = "%";
op[1] = XEXP (x, 1);
break;
case UMOD:
fun = "umod";
op[0] = XEXP (x, 0);
op[1] = XEXP (x, 1);
break;
case SMIN:
fun = "smin";
op[0] = XEXP (x, 0);
op[1] = XEXP (x, 1);
break;
case SMAX:
fun = "smax";
op[0] = XEXP (x, 0);
op[1] = XEXP (x, 1);
break;
case UMIN:
fun = "umin";
op[0] = XEXP (x, 0);
op[1] = XEXP (x, 1);
break;
case UMAX:
fun = "umax";
op[0] = XEXP (x, 0);
op[1] = XEXP (x, 1);
break;
case NOT:
st[0] = "!";
op[0] = XEXP (x, 0);
break;
case AND:
op[0] = XEXP (x, 0);
st[1] = "&";
op[1] = XEXP (x, 1);
break;
case IOR:
op[0] = XEXP (x, 0);
st[1] = "|";
op[1] = XEXP (x, 1);
break;
case XOR:
op[0] = XEXP (x, 0);
st[1] = "^";
op[1] = XEXP (x, 1);
break;
case ASHIFT:
op[0] = XEXP (x, 0);
st[1] = "<<";
op[1] = XEXP (x, 1);
break;
case LSHIFTRT:
op[0] = XEXP (x, 0);
st[1] = " 0>>";
op[1] = XEXP (x, 1);
break;
case ASHIFTRT:
op[0] = XEXP (x, 0);
st[1] = ">>";
op[1] = XEXP (x, 1);
break;
case ROTATE:
op[0] = XEXP (x, 0);
st[1] = "<-<";
op[1] = XEXP (x, 1);
break;
case ROTATERT:
op[0] = XEXP (x, 0);
st[1] = ">->";
op[1] = XEXP (x, 1);
break;
case ABS:
fun = "abs";
op[0] = XEXP (x, 0);
break;
case SQRT:
fun = "sqrt";
op[0] = XEXP (x, 0);
break;
case FFS:
fun = "ffs";
op[0] = XEXP (x, 0);
break;
case EQ:
op[0] = XEXP (x, 0);
st[1] = "==";
op[1] = XEXP (x, 1);
break;
case NE:
op[0] = XEXP (x, 0);
st[1] = "!=";
op[1] = XEXP (x, 1);
break;
case GT:
op[0] = XEXP (x, 0);
st[1] = ">";
op[1] = XEXP (x, 1);
break;
case GTU:
fun = "gtu";
op[0] = XEXP (x, 0);
op[1] = XEXP (x, 1);
break;
case LT:
op[0] = XEXP (x, 0);
st[1] = "<";
op[1] = XEXP (x, 1);
break;
case LTU:
fun = "ltu";
op[0] = XEXP (x, 0);
op[1] = XEXP (x, 1);
break;
case GE:
op[0] = XEXP (x, 0);
st[1] = ">=";
op[1] = XEXP (x, 1);
break;
case GEU:
fun = "geu";
op[0] = XEXP (x, 0);
op[1] = XEXP (x, 1);
break;
case LE:
op[0] = XEXP (x, 0);
st[1] = "<=";
op[1] = XEXP (x, 1);
break;
case LEU:
fun = "leu";
op[0] = XEXP (x, 0);
op[1] = XEXP (x, 1);
break;
case SIGN_EXTRACT:
fun = (verbose) ? "sign_extract" : "sxt";
op[0] = XEXP (x, 0);
op[1] = XEXP (x, 1);
op[2] = XEXP (x, 2);
break;
case ZERO_EXTRACT:
fun = (verbose) ? "zero_extract" : "zxt";
op[0] = XEXP (x, 0);
op[1] = XEXP (x, 1);
op[2] = XEXP (x, 2);
break;
case SIGN_EXTEND:
fun = (verbose) ? "sign_extend" : "sxn";
op[0] = XEXP (x, 0);
break;
case ZERO_EXTEND:
fun = (verbose) ? "zero_extend" : "zxn";
op[0] = XEXP (x, 0);
break;
case FLOAT_EXTEND:
fun = (verbose) ? "float_extend" : "fxn";
op[0] = XEXP (x, 0);
break;
case TRUNCATE:
fun = (verbose) ? "trunc" : "trn";
op[0] = XEXP (x, 0);
break;
case FLOAT_TRUNCATE:
fun = (verbose) ? "float_trunc" : "ftr";
op[0] = XEXP (x, 0);
break;
case FLOAT:
fun = (verbose) ? "float" : "flt";
op[0] = XEXP (x, 0);
break;
case UNSIGNED_FLOAT:
fun = (verbose) ? "uns_float" : "ufl";
op[0] = XEXP (x, 0);
break;
case FIX:
fun = "fix";
op[0] = XEXP (x, 0);
break;
case UNSIGNED_FIX:
fun = (verbose) ? "uns_fix" : "ufx";
op[0] = XEXP (x, 0);
break;
case PRE_DEC:
st[0] = "--";
op[0] = XEXP (x, 0);
break;
case PRE_INC:
st[0] = "++";
op[0] = XEXP (x, 0);
break;
case POST_DEC:
op[0] = XEXP (x, 0);
st[1] = "--";
break;
case POST_INC:
op[0] = XEXP (x, 0);
st[1] = "++";
break;
case PRE_MODIFY:
st[0] = "pre ";
op[0] = XEXP (XEXP (x, 1), 0);
st[1] = "+=";
op[1] = XEXP (XEXP (x, 1), 1);
break;
case POST_MODIFY:
st[0] = "post ";
op[0] = XEXP (XEXP (x, 1), 0);
st[1] = "+=";
op[1] = XEXP (XEXP (x, 1), 1);
break;
case CALL:
st[0] = "call ";
op[0] = XEXP (x, 0);
if (verbose)
{
st[1] = " argc:";
op[1] = XEXP (x, 1);
}
break;
case IF_THEN_ELSE:
st[0] = "{(";
op[0] = XEXP (x, 0);
st[1] = ")?";
op[1] = XEXP (x, 1);
st[2] = ":";
op[2] = XEXP (x, 2);
st[3] = "}";
break;
case TRAP_IF:
fun = "trap_if";
op[0] = TRAP_CONDITION (x);
break;
case PREFETCH:
fun = "prefetch";
op[0] = XEXP (x, 0);
op[1] = XEXP (x, 1);
op[2] = XEXP (x, 2);
break;
case UNSPEC:
case UNSPEC_VOLATILE:
{
cur = safe_concat (buf, cur, "unspec");
if (GET_CODE (x) == UNSPEC_VOLATILE)
cur = safe_concat (buf, cur, "/v");
cur = safe_concat (buf, cur, "[");
sep = "";
for (i = 0; i < XVECLEN (x, 0); i++)
{
print_pattern (tmp, XVECEXP (x, 0, i), verbose);
cur = safe_concat (buf, cur, sep);
cur = safe_concat (buf, cur, tmp);
sep = ",";
}
cur = safe_concat (buf, cur, "] ");
sprintf (tmp, "%d", XINT (x, 1));
cur = safe_concat (buf, cur, tmp);
}
break;
default:
/* If (verbose) debug_rtx (x); */
st[0] = GET_RTX_NAME (GET_CODE (x));
break;
}
/* Print this as a function? */
if (fun)
{
cur = safe_concat (buf, cur, fun);
cur = safe_concat (buf, cur, "(");
}
for (i = 0; i < 4; i++)
{
if (st[i])
cur = safe_concat (buf, cur, st[i]);
if (op[i])
{
if (fun && i != 0)
cur = safe_concat (buf, cur, ",");
print_value (tmp, op[i], verbose);
cur = safe_concat (buf, cur, tmp);
}
}
if (fun)
cur = safe_concat (buf, cur, ")");
} /* print_exp */
void
print_pattern (char *buf, const_rtx x, int verbose)
{
char t1[BUF_LEN], t2[BUF_LEN], t3[BUF_LEN];
switch (GET_CODE (x))
{
case SET:
print_value (t1, SET_DEST (x), verbose);
print_value (t2, SET_SRC (x), verbose);
sprintf (buf, "%s=%s", t1, t2);
break;
case RETURN:
sprintf (buf, "return");
break;
case SIMPLE_RETURN:
sprintf (buf, "simple_return");
break;
case CALL:
print_exp (buf, x, verbose);
break;
case CLOBBER:
print_value (t1, XEXP (x, 0), verbose);
sprintf (buf, "clobber %s", t1);
break;
case USE:
print_value (t1, XEXP (x, 0), verbose);
sprintf (buf, "use %s", t1);
break;
case VAR_LOCATION:
print_value (t1, PAT_VAR_LOCATION_LOC (x), verbose);
sprintf (buf, "loc %s", t1);
break;
case COND_EXEC:
if (GET_CODE (COND_EXEC_TEST (x)) == NE
&& XEXP (COND_EXEC_TEST (x), 1) == const0_rtx)
print_value (t1, XEXP (COND_EXEC_TEST (x), 0), verbose);
else if (GET_CODE (COND_EXEC_TEST (x)) == EQ
&& XEXP (COND_EXEC_TEST (x), 1) == const0_rtx)
{
t1[0] = '!';
print_value (t1 + 1, XEXP (COND_EXEC_TEST (x), 0), verbose);
}
else
print_value (t1, COND_EXEC_TEST (x), verbose);
print_pattern (t2, COND_EXEC_CODE (x), verbose);
sprintf (buf, "(%s) %s", t1, t2);
break;
case PARALLEL:
{
int i;
sprintf (t1, "{");
for (i = 0; i < XVECLEN (x, 0); i++)
{
print_pattern (t2, XVECEXP (x, 0, i), verbose);
sprintf (t3, "%s%s;", t1, t2);
strcpy (t1, t3);
}
sprintf (buf, "%s}", t1);
}
break;
case SEQUENCE:
/* Should never see SEQUENCE codes until after reorg. */
gcc_unreachable ();
case ASM_INPUT:
sprintf (buf, "asm {%s}", XSTR (x, 0));
break;
case ADDR_VEC:
/* Fall through. */
case ADDR_DIFF_VEC:
print_value (buf, XEXP (x, 0), verbose);
break;
case TRAP_IF:
print_value (t1, TRAP_CONDITION (x), verbose);
sprintf (buf, "trap_if %s", t1);
break;
case UNSPEC:
{
int i;
sprintf (t1, "unspec{");
for (i = 0; i < XVECLEN (x, 0); i++)
{
print_pattern (t2, XVECEXP (x, 0, i), verbose);
sprintf (t3, "%s%s;", t1, t2);
strcpy (t1, t3);
}
sprintf (buf, "%s}", t1);
}
break;
case UNSPEC_VOLATILE:
{
int i;
sprintf (t1, "unspec/v{");
for (i = 0; i < XVECLEN (x, 0); i++)
{
print_pattern (t2, XVECEXP (x, 0, i), verbose);
sprintf (t3, "%s%s;", t1, t2);
strcpy (t1, t3);
}
sprintf (buf, "%s}", t1);
}
break;
default:
print_value (buf, x, verbose);
}
} /* print_pattern */
int32_t nvmStringMatchCoproInjectData (nvmCoprocessorState *c, uint8_t *data) {
uint32_t /*byte_order,*/ pattern_data;
uint16_t g, i, patterns_no, pattern_length, pattern_nocase;
nvmStringMatchCoproInternalData *smcdata = c -> data;
nvmStringMatchCoproPattern *p, *q;
int32_t out;
smdebug ("String-matching coprocessor initialising\n");
/* Get first byte, which contains info on the data */
// byte_order = *(uint32_t *) data;
// data += SIZE_DD; // So that it points to pattern data
smcdata -> patterns = NULL;
smcdata -> graphs_no = *(uint16_t *) data;
data += SIZE_DW;
smdebug ("* %hd pattern groups\n", smcdata -> graphs_no);
smcdata -> acsm = (ACSM_STRUCT2 **) malloc (sizeof (ACSM_STRUCT2 *) * smcdata -> graphs_no);
/* Read data for all graphs */
for (g = 0; g < smcdata -> graphs_no; g++) {
/* Init Aho-Corasick state machine */
smcdata -> acsm[g] = acsmNew2 ();
smcdata -> acsm[g] -> acsmFormat = ACF_FULL; // For the moment...
patterns_no = *(uint16_t *) data;
data += SIZE_DW;
smdebug ("* %hd patterns\n", patterns_no);
for (i = 0; i < patterns_no; i++) {
pattern_length = *(uint16_t *) data;
data += SIZE_DW;
smdebug ("* Pattern:\n - Length: %hd\n", pattern_length);
pattern_nocase = *(uint16_t *) data;
data += SIZE_DW;
smdebug (" - Nocase: %hd\n", pattern_nocase);
pattern_data = *(uint32_t *) data;
data += SIZE_DD;
smdebug (" - Data: %u\n", pattern_data);
smdebug (" - Text: \"");
print_pattern ((char *)data, pattern_length);
smdebug ("\"\n");
/* Add pattern to list */
if (!(p = (nvmStringMatchCoproPattern *) malloc (sizeof (nvmStringMatchCoproPattern)))) {
fprintf (stderr, "Cannot allocate memory for pattern\n");
exit (9);
}
p -> pattern = (char *) malloc (pattern_length * SIZE_DB);
memcpy (p -> pattern, data, pattern_length);
p -> len = pattern_length;
p -> data = pattern_data;
p -> next = NULL;
/* Append new pattern to list */
if (smcdata -> patterns != NULL) {
for (q = smcdata -> patterns; q -> next; q = q -> next)
;
q -> next = p;
} else {
smcdata -> patterns = p;
}
/* Add pattern to Aho-Corasick SM */
acsmAddPattern2 (smcdata -> acsm[g], data, pattern_length, pattern_nocase, 0, 0, p, i);
smcdata -> patterns_no++;
/* On with next pattern */
data += pattern_length * SIZE_DB;
}
/* All patterns added: compile graph */
// Print_DFA (smcdata -> acsm);
acsmCompile2 (smcdata -> acsm[g]);
#ifdef COPRO_STRINGMATCH_DEBUG
acsmPrintInfo2 (smcdata -> acsm[g]);
#endif
}
/* Prepare stuff for results */
smcdata -> matches_no = 0;
smcdata -> next_match_id = 0;
out = nvmSUCCESS;
return (out);
}
static int try_possibility(char pattern[9][9], char possibilities[9][9][9]) {
int iterations = 0;
bool solved = false;
int lowestx = 0;
int lowesty = 0;
int lowest = 9;
for (int x = 0; x < 9; x++) {
for (int y = 0; y < 9; y++) {
if (pattern[x][y] == ' ') {
if (lowest > count_possibilities(possibilities, x, y)) {
lowest = count_possibilities(possibilities, x, y);
lowestx = x;
lowesty = y;
}
}
}
}
if (lowest != 9) {
while ((lowest > 0) && (!solved)) {
iterations++;
char testpattern[9][9];
char testpossibilities[9][9][9];
bool loadprob = false;
for (int x = 0; x < 9; x++) {
for (int y = 0; y < 9; y++) {
testpattern[x][y] = pattern[x][y];
for (int z = 0; z < 9; z++) {
testpossibilities[x][y][z] = possibilities[x][y][z];
if ((x == lowestx) && (lowesty == y) && (possibilities[x][y][z] != ' ') && (!loadprob)) {
testpattern[x][y] = possibilities[x][y][z];
possibilities[x][y][z] = ' ';
testpossibilities[x][y][z] = ' ';
loadprob = true;
}
}
}
}
printf("\n===\n");
print_pattern(testpattern);
printf("\n===\n");
switch(check_solved_legal(testpattern)) {
case 1 :
solved = true;
print_pattern(testpattern);
printf("\nSolved!\n");
printf("\nIterations: %d\n", iterations);
end = clock();
time_spent = (double)(end - begin) / CLOCKS_PER_SEC;
printf("\nTime to run: %f\n", time_spent);
exit(EXIT_SUCCESS);
return iterations;
case -1 :
printf("\nillegal moves\n");
break;
case 0 :
iterations += try_possibility(testpattern, testpossibilities);
}
lowest--;
}
}
return iterations;
}
int maildir_filter_saverules(struct maildirfilter *r, const char *filename,
const char *maildir,
const char *maildirpath, const char *fromaddr)
{
FILE *f=fopen(filename, "w");
struct maildirfilterrule *p;
if (!f) return (-1);
fprintf(f, "#MFMAILDROP=2\n"
"#\n"
"# DO NOT EDIT THIS FILE. This is an automatically"
" generated filter.\n"
"\n");
for (fprintf(f, "FROM='"); *fromaddr; fromaddr++)
{
if (*fromaddr != '"' && *fromaddr != '\'' && *fromaddr != '\\')
putc(*fromaddr, f);
}
fprintf(f, "\'\nimport SENDER\nif ($SENDER eq \"\")\n{\n SENDER=$FROM\n}\n\n");
for (p=r->first; p; p=p->next)
{
const char *fieldname=p->fieldname ? p->fieldname:"";
const char *fieldvalue=p->fieldvalue ? p->fieldvalue:"";
const char *tofolder=p->tofolder ? p->tofolder:"";
fprintf(f, "##Op:%s\n",
typelist[p->type].name);
fprintf(f, "##Header:%s\n", fieldname);
fprintf(f, "##Value:%s\n", fieldvalue);
fprintf(f, "##Folder:%s\n", tofolder);
fprintf(f, "##From:%s\n", p->fromhdr ? p->fromhdr:"");
if (p->flags & MFR_PLAINSTRING)
fprintf(f, "##PlainString\n");
if (p->flags & MFR_DOESNOT)
fprintf(f, "##DoesNot\n");
if (p->flags & MFR_BODY)
fprintf(f, "##Body\n");
if (p->flags & MFR_CONTINUE)
fprintf(f, "##Continue\n");
fprintf(f, "##Name:%s\n\n", p->rulename ? p->rulename:"");
fprintf(f, "\nif (");
if (p->flags & MFR_DOESNOT)
fprintf(f, "!");
fprintf(f, "(");
switch (p->type) {
case startswith:
if (p->flags & MFR_BODY)
{
fprintf(f, "/^");
print_pattern(f, p->flags, fieldvalue);
fprintf(f, "/:b");
}
else
{
fprintf(f, "/^%s: *", fieldname);
print_pattern(f, p->flags, fieldvalue);
fprintf(f, "/");
}
break;
case endswith:
if (p->flags & MFR_BODY)
{
fprintf(f, "/");
print_pattern(f, p->flags, fieldvalue);
fprintf(f, "$/:b");
}
else
{
fprintf(f, "/^%s:.*", fieldname);
print_pattern(f, p->flags, fieldvalue);
fprintf(f, "$/");
}
break;
case contains:
if (p->flags & MFR_BODY)
{
fprintf(f, "/");
print_pattern(f, p->flags, fieldvalue);
fprintf(f, "/:b");
}
else
{
fprintf(f, "/^%s:.*", fieldname);
print_pattern(f, p->flags, fieldvalue);
fprintf(f, "/");
}
break;
case hasrecipient:
fprintf(f, "hasaddr(\"%s\")", fieldvalue);
break;
case mimemultipart:
fprintf(f, "/^Content-Type: *multipart\\/mixed/");
break;
case textplain:
fprintf(f, " (! /^Content-Type:/) || "
"/^Content-Type: text\\/plain$/ || "
"/^Content-Type: text\\/plain;/");
break;
case islargerthan:
fprintf(f, "$SIZE > %s", fieldvalue);
break;
}
fprintf(f, "))\n"
"{\n");
if (*tofolder == '!')
{
fprintf(f, " %s \"| $SENDMAIL -f \" '\"$SENDER\"' \" %s\"\n",
p->flags & MFR_CONTINUE ? "cc":"to",
tofolder+1);
}
else if (*tofolder == '*')
{
fprintf(f, " echo \"%s\"\n"
" EXITCODE=77\n"
" exit\n", tofolder+1);
}
else if (*tofolder == '+')
{
struct maildir_filter_autoresp_info ai;
if (maildir_filter_autoresp_info_init_str(&ai, tofolder+1) == 0)
{
if (p->fromhdr && p->fromhdr[0])
fprintf(f, " AUTOREPLYFROM='%s'\n",
p->fromhdr);
else
fprintf(f, " AUTOREPLYFROM=$FROM\n"
);
fprintf(f, " `%s -A \"X-Sender: $FROM\""
" -A \"From: $AUTOREPLYFROM\"",
MAILBOT);
if (ai.dsnflag)
fprintf(f, " -M \"$FROM\"");
fprintf(f, " -m \"%s/autoresponses/%s\"",
maildirpath, ai.name);
if (ai.days > 0)
fprintf(f,
" -d \"%s/autoresponses/"
"%s.dat\" -D %u",
maildirpath, ai.name, ai.days);
fprintf(f, " $SENDMAIL -t -f \"\"`\n");
maildir_filter_autoresp_info_free(&ai);
}
}
else
{
if (*tofolder == '.') ++tofolder;
/* Strip leading dot */
fprintf(f,
" %s \"%s%s%s/.\"\n",
p->flags & MFR_CONTINUE ? "cc":"to",
maildirpath,
*tofolder ? "/.":"",
tofolder);
}
fprintf(f, "}\n\n");
}
fflush(f);
if (ferror(f))
{
fclose(f);
return (-1);
}
fprintf(f, "to \"%s/.\"\n", maildirpath);
if (fclose(f))
return (-1);
if (chmod(filename, 0600))
return (-1);
return (0);
}
int maildir_filter_saverules(struct maildirfilter *r, const char *filename,
const char *maildir,
const char *maildirpath, const char *fromaddr)
{
FILE *f=fopen(filename, "w");
struct maildirfilterrule *p;
if (!f) return (-1);
fprintf(f, "#MFMAILDROP=2\n"
"#\n"
"# DO NOT EDIT THIS FILE. This is an automatically"
" generated filter.\n"
"\n");
for (fprintf(f, "FROM='"); *fromaddr; fromaddr++)
{
if (*fromaddr == '\'' || *fromaddr == '\\')
putc('\\', f);
putc(*fromaddr, f);
}
fprintf(f, "\'\n");
for (p=r->first; p; p=p->next)
{
const char *fieldname=p->fieldname_utf8 ? p->fieldname_utf8:"";
const char *fieldvalue=p->fieldvalue_utf8 ? p->fieldvalue_utf8:"";
const char *tofolder=p->tofolder ? p->tofolder:"";
fprintf(f, "##Op:%s\n",
typelist[p->type].name);
fprintf(f, "##Header:%s\n", fieldname);
fprintf(f, "##Value:%s\n", fieldvalue);
fprintf(f, "##Folder:%s\n",
strcmp(tofolder, INBOX) == 0 ? ".":
strncmp(tofolder, INBOX ".", sizeof(INBOX)) == 0
? strchr(tofolder, '.'):tofolder);
fprintf(f, "##From:%s\n", p->fromhdr ? p->fromhdr:"");
if (p->flags & MFR_PLAINSTRING)
fprintf(f, "##PlainString\n");
if (p->flags & MFR_DOESNOT)
fprintf(f, "##DoesNot\n");
if (p->flags & MFR_BODY)
fprintf(f, "##Body\n");
if (p->flags & MFR_CONTINUE)
fprintf(f, "##Continue\n");
fprintf(f, "##Name:%s\n\n", p->rulename_utf8 ? p->rulename_utf8:"");
fprintf(f, "\nif (");
if (p->flags & MFR_DOESNOT)
fprintf(f, "!");
fprintf(f, "(");
switch (p->type) {
case startswith:
if (p->flags & MFR_BODY)
{
fprintf(f, "/^");
print_pattern(f, p->flags, fieldvalue);
fprintf(f, "/:b");
}
else
{
fprintf(f, "/^%s: *", fieldname);
print_pattern(f, p->flags, fieldvalue);
fprintf(f, "/");
}
break;
case endswith:
if (p->flags & MFR_BODY)
{
fprintf(f, "/");
print_pattern(f, p->flags, fieldvalue);
fprintf(f, "$/:b");
}
else
{
fprintf(f, "/^%s:.*", fieldname);
print_pattern(f, p->flags, fieldvalue);
fprintf(f, "$/");
}
break;
case contains:
if (p->flags & MFR_BODY)
{
fprintf(f, "/");
print_pattern(f, p->flags, fieldvalue);
fprintf(f, "/:b");
}
else
{
fprintf(f, "/^%s:.*", fieldname);
print_pattern(f, p->flags, fieldvalue);
fprintf(f, "/");
}
break;
case hasrecipient:
fprintf(f, "hasaddr(\"%s\")", fieldvalue);
break;
case mimemultipart:
fprintf(f, "/^Content-Type: *multipart\\/mixed/");
break;
case textplain:
fprintf(f, " (! /^Content-Type:/) || "
"/^Content-Type: text\\/plain$/ || "
"/^Content-Type: text\\/plain;/");
break;
case islargerthan:
fprintf(f, "$SIZE > %s", fieldvalue);
break;
case anymessage:
fprintf(f, "1");
break;
}
fprintf(f, "))\n"
"{\n");
if (*tofolder == '!')
{
fprintf(f, " %s \"| $SENDMAIL -f \" '\"\"' \" %s\"\n",
p->flags & MFR_CONTINUE ? "cc":"to",
tofolder+1);
}
else if (*tofolder == '*')
{
fprintf(f, " echo \"%s\"\n"
" EXITCODE=%d\n"
" exit\n", tofolder+1, EX_SOFTWARE);
}
else if (*tofolder == '+')
{
struct maildir_filter_autoresp_info ai;
if (maildir_filter_autoresp_info_init_str(&ai, tofolder+1) == 0)
{
if (p->fromhdr && p->fromhdr[0])
{
const char *cp;
fprintf(f, " AUTOREPLYFROM='");
for (cp=p->fromhdr; *cp; ++cp)
{
if (*cp == '\'' || *cp == '\\')
putc('\\', f);
putc(*cp, f);
}
fprintf(f, "'\n");
}
else
fprintf(f, " AUTOREPLYFROM=\"$FROM\"\n"
);
fprintf(f, " `%s -A \"X-Sender: $FROM\""
" -A \"From: $AUTOREPLYFROM\"",
MAILBOT);
if (ai.dsnflag)
fprintf(f, " -M \"$FROM\"");
fprintf(f, " -m \"%s/autoresponses/%s\"",
maildirpath, ai.name);
if (ai.noquote)
fprintf(f, " -N");
if (ai.days > 0)
fprintf(f,
" -d \"%s/autoresponses/"
"%s.dat\" -D %u",
maildirpath, ai.name, ai.days);
fprintf(f, " $SENDMAIL -t -f \"\"`\n");
maildir_filter_autoresp_info_free(&ai);
}
}
else if (strcmp(tofolder, "exit") == 0)
{
fprintf(f, " exit\n");
}
else
{
char *s;
s=maildir_name2dir(maildirpath, tofolder);
if (!s)
fprintf(f, " # INTERNAL ERROR in maildir_name2dir\n");
else
{
fprintf(f,
" %s \"%s/.\"\n",
p->flags & MFR_CONTINUE ? "cc":"to",
s);
free(s);
}
}
fprintf(f, "}\n\n");
}
fflush(f);
if (ferror(f))
{
fclose(f);
return (-1);
}
fprintf(f, "to \"%s/.\"\n", maildirpath);
if (fclose(f))
return (-1);
if (chmod(filename, 0600))
return (-1);
return (0);
}
/**
* Pretty-prints an evaluation tree.
*
* This function traverses the evaluation tree in infix order and
* prints it appropriately indented.
*
* @param envidx Index into the Environment global array.
* @param etptr The evaluation tree to print.
* @param indent The indent level to start printing at.
*/
void
print_evaltree(int envidx, Evaltree etptr, int indent)
{
int i;
if(etptr != NULL) {
switch (etptr->type) {
case node:
switch(etptr->node.op_id) {
case re_od_concat:
assert(etptr->node.min == repeat_none);
assert(etptr->node.min == repeat_none);
print_evaltree(envidx, etptr->node.left, indent + 1);
Rprintf("\n");
for (i = 1; i <= indent; i++)
Rprintf(" ");
Rprintf(".\n");
print_evaltree(envidx, etptr->node.right, indent + 1);
break;
case re_oi_concat:
assert(etptr->node.min == repeat_none);
assert(etptr->node.min == repeat_none);
print_evaltree(envidx, etptr->node.left, indent + 1);
Rprintf("\n");
for (i = 1; i <= indent; i++)
Rprintf(" ");
Rprintf(",\n");
print_evaltree(envidx, etptr->node.right, indent + 1);
break;
case re_disj:
assert(etptr->node.min == repeat_none);
assert(etptr->node.min == repeat_none);
print_evaltree(envidx, etptr->node.left, indent + 1);
Rprintf("\n");
for (i = 1; i <= indent; i++)
Rprintf(" ");
Rprintf("|\n");
print_evaltree(envidx, etptr->node.right, indent + 1);
break;
case re_repeat:
assert(etptr->node.min != repeat_none);
assert(etptr->node.min != repeat_none);
print_evaltree(envidx, etptr->node.left, indent + 1);
Rprintf("\n");
for (i = 1; i <= indent; i++)
Rprintf(" ");
Rprintf("{ ");
print_rep_factor(etptr->node.min);
Rprintf(" , ");
print_rep_factor(etptr->node.max);
Rprintf(" }\n");
assert(etptr->node.right == NULL);
break;
}
break;
case leaf:
Rprintf("\n");
for (i = 1; i <= indent; i++)
Rprintf(" ");
if ((etptr->leaf.patindex >= 0) && (etptr->leaf.patindex <= Environment[envidx].MaxPatIndex))
print_pattern(envidx, etptr->leaf.patindex, indent);
break;
case meet_union:
Rprintf("\n");
for (i = 1; i <= indent; i++)
Rprintf(" ");
switch (etptr->cooc.op_id) {
case cooc_meet:
Rprintf("Meet <%d/%d, %s>", etptr->cooc.lw,
etptr->cooc.rw,
etptr->cooc.struc ?
etptr->cooc.struc->any.name :
"words");
break;
case cooc_union:
Rprintf("Union ");
break;
default:
assert(0 && "Can't be");
break;
}
print_evaltree(envidx, etptr->cooc.left, indent + 1);
print_evaltree(envidx, etptr->cooc.right, indent + 1);
break;
case tabular:
Rprintf("Tabular\n");
while (etptr) {
print_pattern(0, etptr->tab_el.patindex, 2);
if (etptr->tab_el.next) {
/* print the distance */
Rprintf(" {%d,%d}\n",
etptr->tab_el.next->tab_el.min_dist,
etptr->tab_el.next->tab_el.max_dist);
}
etptr = etptr->tab_el.next;
}
break;
default:
assert(0 && "Can't be");
}
}
}
void rm_tok_pattern (int idx)
{
int i;
int n_patterns = 1<<(n_toks-1);
#ifdef _MSC_VER
unsigned char *patterns = calloc(n_patterns, sizeof(unsigned char));
#else
unsigned char patterns[n_patterns];
#endif
for (i=0; i<n_patterns; i++) {
patterns[i] = 1 | ((unsigned)i << 1);
}
int n_pattern = idx & (n_patterns-1);
unsigned char pat = patterns[n_pattern];
#ifdef _MSC_VER
free(patterns);
#endif
if (0) {
printf ("pattern = ");
print_pattern (pat);
}
idx >>= (n_toks-1);
int which = 0;
int started = 0;
int matched = 0;
int deleted = 0;
for (i=0; i<toks; i++) {
if (tok_list[i].kind != TOK_WS) {
if (which == idx) {
matched = 1;
started = 1;
}
if (which == (idx + n_toks)) started = 0;
which++;
}
int print = 0;
int pattern_idx = which - idx;
if (tok_list[i].kind == TOK_WS) {
print = 1;
} else {
if (!started) {
print = 1;
} else {
if (pat & 1) {
deleted = 1;
// printf ("[%s]", tok_list[i].str);
} else {
print = 1;
}
pat >>= 1;
}
}
if (print) printf ("%s", tok_list[i].str);
}
if (matched && deleted) {
exit (0);
} else {
exit (1);
}
}
void
print_insn (char *buf, rtx x, int verbose)
{
char t[BUF_LEN];
rtx insn = x;
switch (GET_CODE (x))
{
case INSN:
print_pattern (t, PATTERN (x), verbose);
if (verbose)
sprintf (buf, "%s: %s", (*current_sched_info->print_insn) (x, 1),
t);
else
sprintf (buf, "%-4d %s", INSN_UID (x), t);
break;
case JUMP_INSN:
print_pattern (t, PATTERN (x), verbose);
if (verbose)
sprintf (buf, "%s: jump %s", (*current_sched_info->print_insn) (x, 1),
t);
else
sprintf (buf, "%-4d %s", INSN_UID (x), t);
break;
case CALL_INSN:
x = PATTERN (insn);
if (GET_CODE (x) == PARALLEL)
{
x = XVECEXP (x, 0, 0);
print_pattern (t, x, verbose);
}
else
strcpy (t, "call <...>");
if (verbose)
sprintf (buf, "%s: %s", (*current_sched_info->print_insn) (x, 1), t);
else
sprintf (buf, "%-4d %s", INSN_UID (insn), t);
break;
case CODE_LABEL:
sprintf (buf, "L%d:", INSN_UID (x));
break;
case BARRIER:
sprintf (buf, "i% 4d: barrier", INSN_UID (x));
break;
case NOTE:
if (NOTE_LINE_NUMBER (x) > 0)
{
expanded_location xloc;
NOTE_EXPANDED_LOCATION (xloc, x);
sprintf (buf, "%4d note \"%s\" %d", INSN_UID (x),
xloc.file, xloc.line);
}
else
sprintf (buf, "%4d %s", INSN_UID (x),
GET_NOTE_INSN_NAME (NOTE_LINE_NUMBER (x)));
break;
default:
if (verbose)
{
sprintf (buf, "Not an INSN at all\n");
debug_rtx (x);
}
else
sprintf (buf, "i%-4d <What?>", INSN_UID (x));
}
} /* print_insn */
