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 */