void dialogue_command_rep::apply () { int i; object cmd = null_object (); object learn= null_object (); for (i=nr_args-1; i>=0; i--) { string s_arg; sv->dialogue_inquire (i, s_arg); if (s_arg == "#f") { exec_delayed (scheme_cmd ("(dialogue-end)")); return; } object arg= string_to_object (s_arg); cmd= cons (arg, cmd); if (!is_empty (p) && get_type (p, i) == "password") learn= cons (cons (object (as_string (i)), object ("")), learn); else learn= cons (cons (object (as_string (i)), arg), learn); //call ("learn-interactive-arg", fun, object (i), arg); } call ("learn-interactive", fun, learn); cmd= cons (fun, cmd); exec_delayed (scheme_cmd ("(dialogue-end)")); exec_delayed (scheme_cmd (cmd)); }
string conservative_texmacs_to_latex (tree doc, object opts) { if (get_preference ("texmacs->latex:conservative", "off") != "on") return tracked_texmacs_to_latex (latex_expand (doc), opts); tree atts= extract (doc, "attachments"); hashmap<string,tree> atts_map (UNINIT, atts); if (!atts_map->contains ("latex-source")) return tracked_texmacs_to_latex (latex_expand (doc), opts); string lsource= as_string (atts_map["latex-source"]); tree ltarget= atts_map["latex-target"]; tree target= texmacs_unmark (ltarget); if (doc == target) return lsource; tree idoc= texmacs_invarianted (doc, ltarget, lsource); call ("latex-set-virtual-packages", get_used_packages (lsource)); string conv= tracked_texmacs_to_latex (latex_expand (idoc), opts); call ("latex-set-virtual-packages", null_object ()); if (latex_unchanged_metadata (target, doc)) conv= latex_merge_metadata (lsource, conv); if (latex_unchanged_abstract (target, doc)) conv= latex_merge_abstract (lsource, conv); //cout << "Conversion" << LF << HRULE << conv << HRULE; //if (texmacs_unchanged_preamble (target, doc)) //conv= latex_recover_preamble (conv, lsource); //else conv= latex_merge_preamble (lsource, conv); return conv; }
void interactive_command_rep::apply () { if ((i>0) && (s[i-1] == "#f")) return; if (i == N(p)) { object learn= null_object (); array<object> params (N(p)); for (i=N(p)-1; i>=0; i--) { params[i]= string_to_object (s[i]); if (get_type (p, i) == "password") learn= cons (cons (object (as_string (i)), object ("")), learn); else learn= cons (cons (object (as_string (i)), params[i]), learn); } call ("learn-interactive", fun, learn); string ret= object_to_string (call (fun, params)); if (ret != "" && ret != "<unspecified>" && ret != "#<unspecified>") sv->set_message (verbatim (ret), "interactive command"); } else { s[i]= string (""); string prompt= get_prompt (p, i); string type = get_type (p, i); array<string> proposals= get_proposals (p, i); win->interactive (prompt, type, proposals, s[i], this); i++; } }
tree edit_typeset_rep::exec_latex (tree t, path p) { t= convert_OTS1_symbols_to_universal_encoding (t); bool expand_unknown_macros= "on" == as_string ( call ("get-preference", "texmacs->latex:expand-macros")); bool expand_user_macro= "on" == as_string ( call ("get-preference", "texmacs->latex:expand-user-macros")); if (!expand_unknown_macros && !expand_user_macro) return t; if (p == (rp * 0)) typeset_preamble (); typeset_exec_until (p); hashmap<string,tree> H= copy (cur[p]); object l= null_object (); iterator<string> it= iterate (H); while (it->busy ()) l= cons (object (it->next ()), l); tree patch= as_tree (call ("stree->tree", call ("tmtex-env-patch", t, l))); hashmap<string,tree> P (UNINIT, patch); H->join (P); if (!expand_user_macro && is_document (t) && is_compound (t[0], "hide-preamble")) { tree r= copy (t); r[0]= ""; r= exec (value_to_compound (r, P), H, false); r[0]= exec (t[0], H, false); return r; } else { tree r= exec (value_to_compound (t, P), H, false); return r; } }
static object get_used_packages (string src) { hashmap<string,path> h= latex_get_packages (src); object packs= null_object (); iterator<string> it= iterate (h); while (it->busy ()) packs= cons (object (it->next ()), packs); return packs; }
value_set_dereferencet::valuet value_set_dereferencet::build_reference_to( const exprt &what, const modet mode, const exprt &pointer_expr, const guardt &guard) { const typet &dereference_type= ns.follow(pointer_expr.type()).subtype(); if(what.id()==ID_unknown || what.id()==ID_invalid) { invalid_pointer(pointer_expr, guard); return valuet(); } if(what.id()!=ID_object_descriptor) throw "unknown points-to: "+what.id_string(); const object_descriptor_exprt &o=to_object_descriptor_expr(what); const exprt &root_object=o.root_object(); const exprt &object=o.object(); #if 0 std::cout << "O: " << from_expr(ns, "", root_object) << '\n'; #endif valuet result; if(root_object.id()=="NULL-object") { if(options.get_bool_option("pointer-check")) { guardt tmp_guard(guard); if(o.offset().is_zero()) { tmp_guard.add(null_pointer(pointer_expr)); dereference_callback.dereference_failure( "pointer dereference", "NULL pointer", tmp_guard); } else { tmp_guard.add(null_object(pointer_expr)); dereference_callback.dereference_failure( "pointer dereference", "NULL plus offset pointer", tmp_guard); } } } else if(root_object.id()==ID_dynamic_object) { // const dynamic_object_exprt &dynamic_object= // to_dynamic_object_expr(root_object); // the object produced by malloc exprt malloc_object= ns.lookup(CPROVER_PREFIX "malloc_object").symbol_expr(); exprt is_malloc_object=same_object(pointer_expr, malloc_object); // constraint that it actually is a dynamic object exprt dynamic_object_expr(ID_dynamic_object, bool_typet()); dynamic_object_expr.copy_to_operands(pointer_expr); // this is also our guard result.pointer_guard=dynamic_object_expr; // can't remove here, turn into *p result.value=dereference_exprt(pointer_expr, dereference_type); if(options.get_bool_option("pointer-check")) { // if(!dynamic_object.valid().is_true()) { // check if it is still alive guardt tmp_guard(guard); tmp_guard.add(deallocated(pointer_expr, ns)); dereference_callback.dereference_failure( "pointer dereference", "dynamic object deallocated", tmp_guard); } if(options.get_bool_option("bounds-check")) { if(!o.offset().is_zero()) { // check lower bound guardt tmp_guard(guard); tmp_guard.add(is_malloc_object); tmp_guard.add( dynamic_object_lower_bound( pointer_expr, ns, nil_exprt())); dereference_callback.dereference_failure( "pointer dereference", "dynamic object lower bound", tmp_guard); } { // check upper bound // we check SAME_OBJECT(__CPROVER_malloc_object, p) && // POINTER_OFFSET(p)+size>__CPROVER_malloc_size guardt tmp_guard(guard); tmp_guard.add(is_malloc_object); tmp_guard.add( dynamic_object_upper_bound( pointer_expr, dereference_type, ns, size_of_expr(dereference_type, ns))); dereference_callback.dereference_failure( "pointer dereference", "dynamic object upper bound", tmp_guard); } } } } else if(root_object.id()==ID_integer_address) { // This is stuff like *((char *)5). // This is turned into an access to __CPROVER_memory[...]. if(language_mode==ID_java) { result.value=nil_exprt(); return result; } const symbolt &memory_symbol=ns.lookup(CPROVER_PREFIX "memory"); exprt symbol_expr=symbol_exprt(memory_symbol.name, memory_symbol.type); if(base_type_eq( ns.follow(memory_symbol.type).subtype(), dereference_type, ns)) { // Types match already, what a coincidence! // We can use an index expression. exprt index_expr=index_exprt(symbol_expr, pointer_offset(pointer_expr)); index_expr.type()=ns.follow(memory_symbol.type).subtype(); result.value=index_expr; } else if(dereference_type_compare( ns.follow(memory_symbol.type).subtype(), dereference_type)) { exprt index_expr=index_exprt(symbol_expr, pointer_offset(pointer_expr)); index_expr.type()=ns.follow(memory_symbol.type).subtype(); result.value=typecast_exprt(index_expr, dereference_type); } else { // We need to use byte_extract. // Won't do this without a commitment to an endianness. if(config.ansi_c.endianness==configt::ansi_ct::endiannesst::NO_ENDIANNESS) { } else { exprt byte_extract(byte_extract_id(), dereference_type); byte_extract.copy_to_operands( symbol_expr, pointer_offset(pointer_expr)); result.value=byte_extract; } } } else { // something generic -- really has to be a symbol address_of_exprt object_pointer(object); if(o.offset().is_zero()) { equal_exprt equality(pointer_expr, object_pointer); if(ns.follow(equality.lhs().type())!=ns.follow(equality.rhs().type())) equality.lhs().make_typecast(equality.rhs().type()); result.pointer_guard=equality; } else { result.pointer_guard=same_object(pointer_expr, object_pointer); } guardt tmp_guard(guard); tmp_guard.add(result.pointer_guard); valid_check(object, tmp_guard, mode); const typet &object_type=ns.follow(object.type()); const exprt &root_object=o.root_object(); const typet &root_object_type=ns.follow(root_object.type()); exprt root_object_subexpression=root_object; if(dereference_type_compare(object_type, dereference_type) && o.offset().is_zero()) { // The simplest case: types match, and offset is zero! // This is great, we are almost done. result.value=object; if(object_type!=ns.follow(dereference_type)) result.value.make_typecast(dereference_type); } else if(root_object_type.id()==ID_array && dereference_type_compare( root_object_type.subtype(), dereference_type)) { // We have an array with a subtype that matches // the dereferencing type. // We will require well-alignedness! exprt offset; // this should work as the object is essentially the root object if(o.offset().is_constant()) offset=o.offset(); else offset=pointer_offset(pointer_expr); exprt adjusted_offset; // are we doing a byte? mp_integer element_size= dereference_type.id()==ID_empty? pointer_offset_size(char_type(), ns): pointer_offset_size(dereference_type, ns); if(element_size==1) { // no need to adjust offset adjusted_offset=offset; } else if(element_size<=0) { throw "unknown or invalid type size of:\n"+dereference_type.pretty(); } else { exprt element_size_expr= from_integer(element_size, offset.type()); adjusted_offset=binary_exprt( offset, ID_div, element_size_expr, offset.type()); // TODO: need to assert well-alignedness } index_exprt index_expr= index_exprt(root_object, adjusted_offset, root_object_type.subtype()); bounds_check(index_expr, tmp_guard); result.value=index_expr; if(ns.follow(result.value.type())!=ns.follow(dereference_type)) result.value.make_typecast(dereference_type); } else if(get_subexpression_at_offset( root_object_subexpression, o.offset(), dereference_type, ns)) { // Successfully found a member, array index, or combination thereof // that matches the desired type and offset: result.value=root_object_subexpression; } else { // we extract something from the root object result.value=o.root_object(); // this is relative to the root object const exprt offset=pointer_offset(pointer_expr); if(memory_model(result.value, dereference_type, tmp_guard, offset)) { // ok, done } else { if(options.get_bool_option("pointer-check")) { std::string msg="memory model not applicable (got `"; msg+=from_type(ns, "", result.value.type()); msg+="', expected `"; msg+=from_type(ns, "", dereference_type); msg+="')"; dereference_callback.dereference_failure( "pointer dereference", msg, tmp_guard); } return valuet(); // give up, no way that this is ok } } } return result; }
tree rewrite_impl (tree t) { switch (L(t)) { case EXTERN: { int i, n= N(t); tree r (TUPLE, n); for (i=0; i<n; i++) r[i]= evaluate (t[i]); object expr= null_object (); for (i=n-1; i>0; i--) expr= cons (object (r[i]), expr); string fun= evaluate_string (t[0]); expr= cons (string_to_object (fun), expr); bool secure= as_bool (std_env ["secure"]); if (!secure && script_status < 2) { if (!as_bool (call ("secure?", expr))) return tree (ERROR, "insecure script"); } environment old_env= reenter_rewrite_env; reenter_rewrite_env= std_env; object o= eval (expr); reenter_rewrite_env= old_env; return content_to_tree (o); } #ifdef CLASSICAL_MACRO_EXPANSION case MAP_ARGS: { if (!(is_atomic (t[0]) && is_atomic (t[1]) && is_atomic (t[2]))) return evaluate_error ("invalid map-args"); if (macro_top_level (std_env)) return evaluate_error ("undefined", t[2]); basic_environment local= macro_arguments (std_env); int key= make_tree_label (t[2]->label); if (!local->contains (key)) return evaluate_error ("undefined", t[2]); tree v= local [key]; if (is_atomic (v)) return evaluate_error ("invalid-map-args"); macro_up (std_env); int start= 0, end= N(v); if (N(t)>=4) start= as_int (evaluate (t[3])); if (N(t)>=5) end = as_int (evaluate (t[4])); int i, n= max (0, end-start); tree r (make_tree_label (t[1]->label), n); for (i=0; i<n; i++) r[i]= tree (make_tree_label (t[0]->label), tree (ARG, copy (t[2]), as_string (start+i)), as_string (start+i)); macro_redown (std_env, local); return r; } #endif // CLASSICAL_MACRO_EXPANSION case VAR_INCLUDE: { url base_file_name (as_string (std_env ["base-file-name"])); url file_name= url_system (evaluate_string (t[0])); return load_inclusion (relative (base_file_name, file_name)); } case REWRITE_INACTIVE: { #ifdef CLASSICAL_MACRO_EXPANSION if ((!is_func (t[0], ARG)) || is_compound (t[0][0])) return evaluate_error ("invalid rewrite-inactive"); if (macro_top_level (std_env)) return evaluate_error ("undefined", t[0][0]); basic_environment local= macro_arguments (std_env); int key= make_tree_label (t[0][0]->label); if (!local->contains (key)) return evaluate_error ("undefined", t[0][0]); tree val= local [key]; int i, n= N(t[0]); for (i=1; i<n; i++) { int j= as_int (t[0][i]); if ((j>=0) && (j<N(val))) val= val[j]; else return evaluate_error ("invalid rewrite-inactive"); } #else tree val= t[0]; #endif int inactive_mode= INACTIVE_INLINE_RECURSE; if (t[1] == "recurse") inactive_mode= INACTIVE_INLINE_RECURSE; else if (t[1] == "recurse*") inactive_mode= INACTIVE_BLOCK_RECURSE; else if (t[1] == "once") inactive_mode= INACTIVE_INLINE_ONCE; else if (t[1] == "once*") inactive_mode= INACTIVE_BLOCK_ONCE; else if (t[1] == "error") inactive_mode= INACTIVE_INLINE_ERROR; else if (t[1] == "error*") inactive_mode= INACTIVE_BLOCK_ERROR; return rewrite_inactive (val, inactive_mode); } default: return t; } }