int main(int argc, char **argv)
{
FILE *rule_fp;
Topform c;
Term t;
int i;
Clause_eval compiled_rule;
Plist rules = NULL;
init_standard_ladr();
init_weight(NULL, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0);
i = register_attribute("label", STRING_ATTRIBUTE); /* ignore these */
i = register_attribute("answer", TERM_ATTRIBUTE); /* ignore these */
rule_fp = fopen(argv[1], "r");
if (rule_fp == NULL)
fatal_error("test_clause_eval, rule file cannot be opened for reading");
t = read_term(rule_fp, stderr); /* get first rule */
while (t != NULL) {
compiled_rule = compile_clause_eval_rule(t);
rules = plist_append(rules, compiled_rule);
fwrite_term_nl(stdout, t);
zap_term(t);
t = read_term(rule_fp, stderr);
}
fclose(rule_fp);
/* Evaluate each clause on stdin. */
c = read_clause(stdin, stderr);
while (c != NULL && !end_of_list_clause(c)) {
Plist p;
c->weight = clause_weight(c->literals);
for (p = rules; p; p = p->next) {
Clause_eval rule = p->v;
BOOL result = eval_clause_in_rule(c, rule);
printf("%d (wt=%.3f) : ", result, c->weight);
fwrite_clause(stdout, c, CL_FORM_BARE);
}
printf("\n");
zap_topform(c);
c = read_clause(stdin, stderr);
}
exit(0);
} /* main */
/* PUBLIC */
Plist read_term_list(FILE *fin, FILE *fout)
{
Plist p = NULL;
Term t;
t = read_term(fin, fout);
while (t != NULL && !end_of_list_term(t)) {
p = plist_prepend(p, t);
t = read_term(fin, fout);
}
if (t != NULL)
zap_term(t);
p = reverse_plist(p);
return p;
} /* read_term_list */
/* PUBLIC */
Term term_reader(BOOL fast)
{
if (fast)
return fast_read_term(stdin, stderr);
else
return read_term(stdin, stderr);
} /* term_reader */
/* PUBLIC */
Topform read_clause_or_formula(FILE *fin, FILE *fout)
{
Term t = read_term(fin, fout);
if (t == NULL)
return NULL;
else {
Topform tf = term_to_topform2(t);
zap_term(t);
return tf;
}
} /* read_clause_or_formula */
/* PUBLIC */
Formula read_formula(FILE *fin, FILE *fout)
{
Term t = read_term(fin, fout);
if (t == NULL)
return NULL;
else {
Formula f = term_to_formula(t);
zap_term(t);
return f;
}
} /* read_formula */
/* PUBLIC */
Topform read_clause(FILE *fin, FILE *fout)
{
Term t = read_term(fin, fout);
if (t == NULL)
return NULL;
else {
Topform c = term_to_clause(t);
zap_term(t);
clause_set_variables(c, MAX_VARS); /* fatal if too many vars */
return c;
}
} /* read_clause */
static
Plist read_tptp_file(FILE *fp)
{
Plist formulas = NULL;
Term t = read_term(fp, stderr);
while (t != NULL) {
if (is_term(t, "include", 1) || is_term(t, "include", 2))
formulas = plist_cat(formulas, tptp_include(t));
else if (is_term(t, "cnf", 3) || is_term(t, "cnf", 4))
formulas = plist_prepend(formulas, tptp_formula(t));
else if (is_term(t, "fof", 3) || is_term(t, "fof", 4))
formulas = plist_prepend(formulas, tptp_formula(t));
else {
p_term(t);
fatal_error("read_tptp_file: unknown term");
}
zap_term(t);
t = read_term(stdin, stderr);
}
return reverse_plist(formulas);
} /* read_tptp_file */
static
Term next_interp(FILE *fp, BOOL mace4_file)
{
if (mace4_file) {
if (read_to_line(fp, "= MODEL ="))
return read_term(fp, stderr);
else
return NULL;
}
else {
Term t = read_term(fp, stderr);
if (t == NULL)
return NULL;
else if (is_term(t, "terms", 1) ||
is_term(t, "list", 1) ||
end_of_list_term(t)) {
zap_term(t);
return next_interp(fp, FALSE);
}
else
return t;
}
} /* next_interp */
/* PUBLIC */
Term read_commands(FILE *fin, FILE *fout, BOOL echo, int unknown_action)
{
Term t = read_term(fin, fout);
BOOL go = (t != NULL);
while (go) {
BOOL already_echoed = FALSE;
/************************************************************ set, clear */
if (is_term(t, "set", 1) || is_term(t, "clear", 1)) {
if (echo) {
fwrite_term_nl(fout, t);
already_echoed = TRUE;
}
flag_handler(fout, t, unknown_action);
}
else if (is_term(t, "assign", 2)) {
/************************************************************** assign */
if (echo) {
fwrite_term_nl(fout, t);
already_echoed = TRUE;
}
parm_handler(fout, t, unknown_action);
}
else if (is_term(t, "assoc_comm", 1) ||
is_term(t, "commutative", 1)) {
/************************************************************ AC, etc. */
Term f = ARG(t,0);
if (!CONSTANT(f)) {
bell(stderr);
fwrite_term_nl(fout, t);
fwrite_term_nl(stderr, t);
fatal_error("argument must be symbol only");
}
else {
if (is_term(t, "assoc_comm", 1))
set_assoc_comm(sn_to_str(SYMNUM(f)), TRUE);
else
set_commutative(sn_to_str(SYMNUM(f)), TRUE);
}
}
else if (is_term(t, "op", 3)) {
/****************************************************************** op */
/* e.g., op(300, infix, +); */
Term prec_term = ARG(t,0);
Term type_term = ARG(t,1);
Term symb_term = ARG(t,2);
int prec;
BOOL ok = term_to_int(prec_term, &prec);
if (!ok || prec < MIN_PRECEDENCE || prec > MAX_PRECEDENCE) {
bell(stderr);
fwrite_term_nl(fout, t);
fwrite_term_nl(stderr, t);
fatal_error("bad precedence in op command");
}
else if (proper_listterm(symb_term)) {
while (cons_term(symb_term)) {
process_op(fout, t, prec, type_term, ARG(symb_term, 0));
symb_term = ARG(symb_term, 1);
}
}
else
process_op(fout, t, prec, type_term, symb_term);
}
else if (is_term(t, "lex", 1)) {
/***************************************************************** lex */
Plist p = listterm_to_tlist(ARG(t,0));
if (p == NULL) {
bell(stderr);
fwrite_term_nl(fout, t);
fwrite_term_nl(stderr, t);
fatal_error("lex command must contain a proper list, e.g., [a,b,c]");
}
else {
preliminary_precedence(p);
zap_plist(p);
}
}
else {
/******************************************************** unrecognized */
/* return this unknown term */
go = FALSE;
}
if (go) {
if (echo && !already_echoed)
fwrite_term_nl(fout, t);
zap_term(t);
t = read_term(fin, fout);
go = (t != NULL);
}
}
return t;
} /* read_commands */
int main() {
int choice, len;
int *p;
char buf[2];
char first_array[] = "first";
char second_array[] = "second";
/*
print_term("Rogue test\n\n");
print_term("0 - End test\n");
print_term("1 - NULL pointer dereference\n");
print_term("2 - Access memory in Kseg0\n");
print_term("3 - Operate a semaphore not in Useg3\n");
print_term("4 - Request to delay for < 0 seconds\n");
print_term("5 - Write to .text section\n");
print_term("6 - Buffer overflow!\n");
*/
do {
print_term("\nEnter your choice: ");
len = read_term(buf);
if (len > 2) len = 2;
buf[1] = '\0';
choice = to_num(buf);
} while((choice < 0) || (choice > 6));
switch (choice) {
case 0:
print_term("Terminating gracefully...\n");
return 0;
break;
case 1:
p = NULL;
*p = 10; /* Should kill the process */
print_term("Should not get here!\n");
break;
case 2:
p = (int *)(SEG1 + 4);
*p = 10;
print_term("Should not get here!\n");
break;
case 3:
p = (int *)(SEG2 + (20 * PAGE_SIZE));
*p = 0; /* Should succeed */
print_term("Set the semaphore to 0...\n");
V(p, 1); /* Should fail */
print_term("Should not get here!\n");
break;
case 4:
delay(-6);
print_term("Should not get here!\n");
break;
case 5:
p = (int *)(SEG2 + 10); /* This is in the .text section */
*p = 42;
print_term("Should not get here!\n");
break;
case 6:
print_term("\nfirst_array[] is ");
print_term(first_array);
print_term("\nsecond_array[] is ");
print_term(second_array);
print_term("\nnow enter a string longer than 6 characters...");
read_term(first_array);
print_term("\nnow first_array[] is ");
print_term(first_array);
print_term("\nand second_array[] is ");
print_term(second_array);
return 0;
default:
print_term("Should not get here...\n");
break;
}
print_term("Houston, we have a problem...\n");
return 0;
}
bool pass_line(void)
{
lineelement_t *lelem;
lineelement_t *vle;
lineelement_t nlelem;
length_t len;
int16_t rel;
int32_t relLong;
VARIABLE var;
elength_t ve;
linesize_t linepos_start;
seglistsize_t segelemidx;
const lineelement_t pcd = { LE_OPERAND, { OP_StarEq }};
while( 1 )
{
vle=(lineelement_t*)pp_peek();
if( vle==NULL ) {
return false;
}
if( vle->typ==LE_EOL ) {
break;
}
linepos_start = pp_getPos();
len.len = 0;
len.defined = true;
switch( vle->typ )
{
case LE_NUMBER:
case LE_TEXTNUM1:
case LE_TEXTNUM2:
case LE_TEXTNUM3:
case LE_TEXTNUM4:
error(EM_NumberWithoutOperand);
return false;
case LE_OPERAND:
/* soft lineend? */
if( vle->data.op==OP_Colon ) {
/* replace ':' with LE_EOL */
vle->typ = LE_EOL;
break;
}
else if( vle->data.op==OP_Carro ) {
/*
* if a single '#' ends up here which was not interpreted as a
* preproc command or a 'mne #number', it's an unknown preproc error!
*/
error(EM_UnknownPreproc);
return false;
}
else if( vle->data.op==OP_Dot ) {
/*
* if a single '.' ends up here which was not interpreted as a
* psyopcode or a macro, it's an unknown psyopcode error!
*/
error(EM_UnknownPsyOpcodeOrMacro);
return false;
}
else if( !pp_skip() ) {
return false;
}
lelem = (lineelement_t*)pp_peek();
if( lelem==NULL ) {
return false;
}
if( vle->data.op==OP_StarEq ||
( vle->data.op==OP_Star && lelem->typ==LE_OPERAND && lelem->data.op==OP_Eq ) )
{
if( vle->data.op==OP_Star && !pp_skip() ) {
return false;
}
lelem = (lineelement_t*)pp_peek();
if( lelem==NULL ) {
return false;
}
if( lelem->typ==LE_EOL )
{
segelemidx = segment_newSegElem(false, 0);
pp_delItems(linepos_start, pp_getPos());
vle->typ = LE_SEGELEMENTER;
vle->data.segelemidx = segelemidx;
}
else if( !term_readVardef(&pcd, linepos_start) )
{
error(EM_AssignmentHasNoRightSide);
return false;
}
}
else if( !term_readVardef(vle, linepos_start) )
{
error(EM_AssignmentHasNoRightSide);
return false;
}
break;
case LE_PSYOPC:
if( (ve=pass_psyopc()).err )
return false;
len = ve.len;
break;
case LE_MNE:
if( (ve=parse_mne()).err )
return false;
len = ve.len;
break;
case LE_STRING:
error(EM_StringWithoutOperand);
return false;
case LE_TEXT:
if( !pp_skip() )
return false;
lelem = (lineelement_t*)pp_peek();
if( lelem==NULL ) {
return false;
}
switch( lelem->typ )
{
case LE_OPERAND:
if( lelem->data.op!=OP_Colon )
{
/* and parse all together as a term */
if( !term_readVardef(vle, linepos_start) )
{
error(EM_AssignmentHasNoRightSide);
return false;
}
break;
}
else
{
/* clear ':' */
lelem->typ = LE_EMPTY;
/* and fallthrough */
}
case LE_EOF:
case LE_EOL:
case LE_PSYOPC:
case LE_MNE:
if( !term_makePCVar(vle->data.txt, linepos_start) )
return false;
break;
case LE_NUMBER:
case LE_STRING:
case LE_TEXT:
case LE_TEXTNUM1:
case LE_TEXTNUM2:
case LE_TEXTNUM3:
case LE_TEXTNUM4:
error(EM_ExpectingVarAssignment);
return false;
case BE_1BYTE:
case BE_2BYTE:
case BE_3BYTE:
case BE_4BYTE:
case BE_nBYTE:
case TE_1BYTE:
case TE_2BYTE:
case TE_3BYTE:
case TE_4BYTE:
case TE_RBYTE:
case TE_RLBYTE:
case TE_FLEX:
case TE_nBYTE:
case TE_JIADR:
case BE_DSB:
case LE_EMPTY:
case LE_SRC:
case LE_VARDEF:
case LE_VARTERM:
case LE_SEGMENTENTER:
case LE_SEGELEMENTER:
case LE_LOCALBLOCK:
case LE_PHASE:
case LE_DEPHASE:
case LE_SETCODE:
case LE_ASIZE:
case LE_XYSIZE:
case LE_CPUTYPE:
case LE_MACRODEF:
case LE_PREPROC:
/* This should never happen! */
assert( false );
break;
};
break;
case BE_1BYTE:
case BE_2BYTE:
case BE_3BYTE:
case BE_4BYTE:
if( !pp_skip() )
return false;
len.len = (vle->typ&LINEELEMENT_TYPMASK)+1;
break;
case BE_DSB:
if( !pp_skip() )
return false;
len.len = vle->data.dsb.length;
break;
case BE_nBYTE:
if( !pp_skip() )
return false;
len.len = *(vle->data.b_nbyte);
break;
case TE_1BYTE:
case TE_2BYTE:
case TE_3BYTE:
case TE_4BYTE:
if( !read_term((TERMSIZE)(vle->typ&LINEELEMENT_TYPMASK),&var, true) )
return false;
allBytesResolved &= var.defined;
if( var.defined )
allTermsFinal &= var.final;
len.len = (vle->typ&LINEELEMENT_TYPMASK)+1;
break;
case TE_RBYTE:
if( !read_term(TS_RBYTE,&var, false) )
return false;
allBytesResolved &= var.defined;
if( var.defined && segment_isPCDefined() )
{
pp_delItems(linepos_start, pp_getPos());
nlelem.typ = BE_1BYTE;
if( (rel=adr2rel(var.valt.value.num,segment_getPC()))==-1 )
return false;
nlelem.data.b_1byte = (uint8_t)rel;
pp_replaceItem(linepos_start, &nlelem);
}
len.len = 1;
break;
case TE_RLBYTE:
if( !read_term(TS_RLBYTE,&var, false) )
return false;
allBytesResolved &= var.defined;
if( var.defined && segment_isPCDefined() )
{
pp_delItems(linepos_start, pp_getPos());
nlelem.typ = BE_2BYTE;
if( (relLong=adr2relLong(var.valt.value.num,segment_getPC()))==-1 )
return false;
nlelem.data.b_2byte = (uint8_t)relLong;
pp_replaceItem(linepos_start, &nlelem);
}
len.len = 1;
break;
case TE_FLEX:
if( !read_term(TS_FLEX,&var, true) )
return false;
if( (allBytesResolved&=(len.defined=var.defined)) )
len.len = (vle->typ&LINEELEMENT_TYPMASK)+1;
if( var.defined )
allTermsFinal &= var.final;
break;
case TE_nBYTE:
if( !read_term(TS_nBYTE, &var, true) )
return false;
if( (allBytesResolved&=(len.defined=var.defined)) )
len.len = var.valt.byteSize;
if( var.defined )
allTermsFinal &= var.final;
deleteVariable( &var );
break;
case TE_JIADR:
if( !read_term(TS_2BYTE,&var, true) )
return false;
allBytesResolved &= var.defined;
checkJmpInd(&var);
len.len = 2;
break;
case LE_PREPROC:
case LE_EOF:
case LE_EOL:
case LE_EMPTY:
case LE_SRC:
case LE_VARDEF:
case LE_VARTERM:
case LE_SEGMENTENTER:
case LE_SEGELEMENTER:
case LE_LOCALBLOCK:
case LE_PHASE:
case LE_DEPHASE:
case LE_SETCODE:
case LE_ASIZE:
case LE_XYSIZE:
case LE_CPUTYPE:
case LE_MACRODEF:
/* should never happen */
assert( false );
};
segment_addLength(len);
};
return true;
}
int main(int argc, char **argv)
{
FILE *head_fp;
Ilist just;
Plist demodulators, p;
Mindex idx;
Term t;
int rewritten = 0;
BOOL verbose = string_member("verbose", argv, argc);;
if (string_member("help", argv, argc) ||
string_member("-help", argv, argc) ||
argc < 2) {
printf("\n%s, version %s, %s\n",PROGRAM_NAME,PROGRAM_VERSION,PROGRAM_DATE);
printf("%s", Help_string);
exit(1);
}
init_standard_ladr();
head_fp = fopen(argv[1], "r");
if (head_fp == NULL)
fatal_error("demodulator file can't be opened for reading");
t = read_commands(head_fp, stderr, verbose, KILL_UNKNOWN);
if (!is_term(t, "clauses", 1) && !is_term(t, "formulas", 1))
fatal_error("formulas(demodulators) not found");
/* Read list of demodulators. */
demodulators = read_clause_list(head_fp, stderr, TRUE);
fclose(head_fp);
/* AC-canonicalize and index the demodulators. */
if (assoc_comm_symbols() || comm_symbols())
idx = mindex_init(DISCRIM_WILD, BACKTRACK_UNIF, 0);
else
idx = mindex_init(DISCRIM_BIND, ORDINARY_UNIF, 0);
for (p = demodulators; p != NULL; p = p->next) {
/* assume positive equality unit */
Topform d = p->v;
Literals lit = d->literals;
Term alpha = lit->atom->args[0];
mark_oriented_eq(lit->atom); /* don not check for termination */
if (assoc_comm_symbols())
ac_canonical(lit->atom, -1);
mindex_update(idx, alpha, INSERT);
}
if (verbose)
fwrite_clause_list(stdout, demodulators, "demodulators", CL_FORM_BARE);
/* Read and demodulate terms. */
t = read_term(stdin, stderr);
while (t != NULL) {
rewritten++;
if (verbose) {
fprintf(stdout, "\nBefore: "); fwrite_term_nl(stdout, t);
}
if (assoc_comm_symbols())
ac_canonical(t, -1);
just = NULL;
t = demodulate(t, idx, &just, FALSE);
if (verbose)
fprintf(stdout, "After: ");
fwrite_term_nl(stdout, t);
fflush(stdout);
zap_ilist(just);
zap_term(t);
t = read_term(stdin, stderr);
}
printf("%% %s %s: rewrote %d terms with %d rewrite steps in %.2f seconds.\n",
PROGRAM_NAME, argv[1], rewritten, demod_rewrites(), user_seconds());
exit(0);
} /* main */
