box naive_icp::solve(box b, contractor & ctc, SMTConfig & config) {
thread_local static std::unordered_set<std::shared_ptr<constraint>> used_constraints;
used_constraints.clear();
thread_local static vector<box> solns;
thread_local static vector<box> box_stack;
solns.clear();
box_stack.clear();
box_stack.push_back(b);
do {
DREAL_LOG_INFO << "naive_icp::solve - loop"
<< "\t" << "box stack Size = " << box_stack.size();
b = box_stack.back();
box_stack.pop_back();
try {
ctc.prune(b, config);
auto this_used_constraints = ctc.used_constraints();
used_constraints.insert(this_used_constraints.begin(), this_used_constraints.end());
if (config.nra_use_stat) { config.nra_stat.increase_prune(); }
} catch (contractor_exception & e) {
// Do nothing
}
if (!b.is_empty()) {
tuple<int, box, box> splits = b.bisect(config.nra_precision);
if (config.nra_use_stat) { config.nra_stat.increase_branch(); }
int const i = get<0>(splits);
if (i >= 0) {
box const & first = get<1>(splits);
box const & second = get<2>(splits);
assert(first.get_idx_last_branched() == i);
assert(second.get_idx_last_branched() == i);
if (second.is_bisectable()) {
box_stack.push_back(second);
box_stack.push_back(first);
} else {
box_stack.push_back(first);
box_stack.push_back(second);
}
if (config.nra_proof) {
config.nra_proof_out << "[branched on "
<< b.get_name(i)
<< "]" << endl;
}
} else {
config.nra_found_soln++;
if (config.nra_multiple_soln > 1) {
// If --multiple_soln is used
output_solution(b, config, config.nra_found_soln);
}
if (config.nra_found_soln >= config.nra_multiple_soln) {
break;
}
solns.push_back(b);
}
}
} while (box_stack.size() > 0);
ctc.set_used_constraints(used_constraints);
if (config.nra_multiple_soln > 1 && solns.size() > 0) {
return solns.back();
} else {
assert(!b.is_empty() || box_stack.size() == 0);
return b;
}
}
void insert(const Reg& reg){
registers.insert(reg);
}
void erase(const Reg& reg){
registers.erase(reg);
}
void ndt::typevar_type::get_vars(std::unordered_set<std::string> &vars) const
{
vars.insert(m_name.str());
}
bool is_signed() const
{
return required_signatures.size() == trx.signatures.size();
}
void concept_indexer::index_object(object& o, model& m,
std::unordered_set<qname>& processed_qnames) {
BOOST_LOG_SEV(lg, debug) << "Indexing object: "
<< string_converter::convert(o.name());
if (processed_qnames.find(o.name()) != processed_qnames.end()) {
BOOST_LOG_SEV(lg, debug) << "Object already processed.";
return;
}
const auto i(o.relationships().find(relationship_types::modeled_concepts));
if (i == o.relationships().end() || i->second.empty()) {
processed_qnames.insert(o.name());
BOOST_LOG_SEV(lg, debug) << "Object models no concepts.";
return;
}
std::list<qname> expanded_refines;
for (auto& qn : i->second) {
auto& c(find_concept(qn, m));
expanded_refines.push_back(qn);
expanded_refines.insert(expanded_refines.end(),
c.refines().begin(), c.refines().end());
}
remove_duplicates(expanded_refines);
if (!o.is_child()) {
i->second = expanded_refines;
BOOST_LOG_SEV(lg, debug) << "Object has no parents, using reduced set.";
return;
}
std::set<qname> our_concepts;
our_concepts.insert(expanded_refines.begin(), expanded_refines.end());
std::set<qname> their_concepts;
for (const auto& qn : find_relationships(relationship_types::parents, o)) {
auto& parent(find_object(qn, m));
index_object(parent, m, processed_qnames);
auto& pr(parent.relationships());
const auto j(pr.find(relationship_types::modeled_concepts));
if (j == pr.end() || j->second.empty())
continue;
their_concepts.insert(j->second.begin(), j->second.end());
}
/* we want to only model concepts which have not yet been modeled
* by any of our parents.
*/
std::set<qname> result;
std::set_difference(our_concepts.begin(), our_concepts.end(),
their_concepts.begin(), their_concepts.end(),
std::inserter(result, result.end()));
/* reinsert all of the modeled concepts which are part of the set
* difference. we do this instead of just using the set difference
* directly to preserve order.
*/
BOOST_LOG_SEV(lg, debug) << "Object has parents, computing set difference.";
i->second.clear();
for (const auto& qn : expanded_refines) {
if (result.find(qn) != result.end())
i->second.push_back(qn);
}
BOOST_LOG_SEV(lg, debug) << "Finished indexing object.";
}
static std::unique_ptr<QueryExpr>
parse(w_query*, const json_ref& term, CaseSensitivity caseSensitive) {
const char *pattern = nullptr, *scope = "basename";
const char *which =
caseSensitive == CaseSensitivity::CaseInSensitive ? "iname" : "name";
std::unordered_set<w_string> set;
if (!term.isArray()) {
throw QueryParseError("Expected array for '", which, "' term");
}
if (json_array_size(term) > 3) {
throw QueryParseError(
"Invalid number of arguments for '", which, "' term");
}
if (json_array_size(term) == 3) {
const auto& jscope = term.at(2);
if (!jscope.isString()) {
throw QueryParseError("Argument 3 to '", which, "' must be a string");
}
scope = json_string_value(jscope);
if (strcmp(scope, "basename") && strcmp(scope, "wholename")) {
throw QueryParseError(
"Invalid scope '", scope, "' for ", which, " expression");
}
}
const auto& name = term.at(1);
if (name.isArray()) {
uint32_t i;
for (i = 0; i < json_array_size(name); i++) {
if (!json_array_get(name, i).isString()) {
throw QueryParseError(
"Argument 2 to '",
which,
"' must be either a string or an array of string");
}
}
set.reserve(json_array_size(name));
for (i = 0; i < json_array_size(name); i++) {
w_string element;
const auto& jele = name.at(i);
auto ele = json_to_w_string(jele);
if (caseSensitive == CaseSensitivity::CaseInSensitive) {
element = ele.piece().asLowerCase(ele.type()).normalizeSeparators();
} else {
element = ele.normalizeSeparators();
}
set.insert(element);
}
} else if (name.isString()) {
pattern = json_string_value(name);
} else {
throw QueryParseError(
"Argument 2 to '",
which,
"' must be either a string or an array of string");
}
auto data = new NameExpr(std::move(set), caseSensitive,
!strcmp(scope, "wholename"));
if (pattern) {
data->name = json_to_w_string(name).normalizeSeparators();
}
return std::unique_ptr<QueryExpr>(data);
}
int main(int argc, char* argv[])
{
if (MPI_Init(&argc, &argv) != MPI_SUCCESS) {
cerr << "Coudln't initialize MPI." << endl;
abort();
}
MPI_Comm comm = MPI_COMM_WORLD;
int rank = 0, comm_size = 0;
MPI_Comm_rank(comm, &rank);
MPI_Comm_size(comm, &comm_size);
float zoltan_version;
if (Zoltan_Initialize(argc, argv, &zoltan_version) != ZOLTAN_OK) {
cout << "Zoltan_Initialize failed" << endl;
abort();
}
Dccrg<std::array<int, 2>> grid;
const std::array<uint64_t, 3> grid_length = {{18, 18, 1}};
grid
.set_initial_length(grid_length)
.set_neighborhood_length(2)
.set_maximum_refinement_level(0)
.set_periodic(true, true, true)
.set_load_balancing_method("RANDOM")
.initialize(comm);
/*
Use a neighborhood like this in the z plane:
O.O.O
.....
O.X.O
.....
O.O.O
and play 4 interlaced games simultaneously.
*/
typedef dccrg::Types<3>::neighborhood_item_t neigh_t;
const std::vector<neigh_t> neighborhood{
{-2, -2, 0},
{-2, 0, 0},
{-2, 2, 0},
{ 0, -2, 0},
{ 0, 2, 0},
{ 2, -2, 0},
{ 2, 0, 0},
{ 2, 2, 0}
};
const int neighborhood_id = 1;
if (!grid.add_neighborhood(neighborhood_id, neighborhood)) {
std::cerr << __FILE__ << ":" << __LINE__
<< " Couldn't set neighborhood"
<< std::endl;
abort();
}
// initial condition
const std::unordered_set<uint64_t> live_cells = get_live_cells(grid_length[0], 0);
for (const uint64_t cell: live_cells) {
auto* const cell_data = grid[cell];
if (cell_data != nullptr) {
(*cell_data)[0] = 1;
}
}
// every process outputs the game state into its own file
ostringstream basename, suffix(".vtk");
basename << "tests/user_neighborhood/general_neighborhood_" << rank << "_";
ofstream outfile, visit_file;
// visualize the game with visit -o game_of_life_test.visit
if (rank == 0) {
visit_file.open("tests/user_neighborhood/general_neighborhood.visit");
visit_file << "!NBLOCKS " << comm_size << endl;
}
#define TIME_STEPS 36
for (int step = 0; step < TIME_STEPS; step++) {
grid.balance_load();
grid.update_copies_of_remote_neighbors(neighborhood_id);
// check that the result is correct
if (step % 4 == 0) {
const std::unordered_set<uint64_t> live_cells = get_live_cells(grid_length[0], step);
for (const auto& cell: grid.local_cells(neighborhood_id)) {
if ((*cell.data)[0] == 0) {
if (live_cells.count(cell.id) > 0) {
std::cerr << __FILE__ << ":" << __LINE__
<< " Cell " << cell.id
<< " shouldn't be alive on step " << step
<< endl;
abort();
}
} else {
if (live_cells.count(cell.id) == 0) {
std::cerr << __FILE__ << ":" << __LINE__
<< " Cell " << cell.id
<< " should be alive on step " << step
<< endl;
abort();
}
}
}
}
// write the game state into a file named according to the current time step
string current_output_name("");
ostringstream step_string;
step_string.fill('0');
step_string.width(5);
step_string << step;
current_output_name += basename.str();
current_output_name += step_string.str();
current_output_name += suffix.str();
// visualize the game with visit -o game_of_life_test.visit
if (rank == 0) {
for (int process = 0; process < comm_size; process++) {
visit_file << "general_neighborhood_" << process << "_" << step_string.str() << suffix.str() << endl;
}
}
// write the grid into a file
vector<uint64_t> cells = grid.get_cells();
sort(cells.begin(), cells.end());
grid.write_vtk_file(current_output_name.c_str());
// prepare to write the game data into the same file
outfile.open(current_output_name.c_str(), ofstream::app);
outfile << "CELL_DATA " << cells.size() << endl;
// go through the grids cells and write their state into the file
outfile << "SCALARS is_alive float 1" << endl;
outfile << "LOOKUP_TABLE default" << endl;
for (const uint64_t cell: cells) {
const auto* const cell_data = grid[cell];
if ((*cell_data)[0] == 1) {
// color live cells of interlaced games differently
const Types<3>::indices_t indices = grid.mapping.get_indices(cell);
outfile << 1 + indices[0] % 2 + (indices[1] % 2) * 2;
} else {
outfile << 0;
}
outfile << endl;
}
// write each cells live neighbor count
outfile << "SCALARS live_neighbor_count float 1" << endl;
outfile << "LOOKUP_TABLE default" << endl;
for (const uint64_t cell: cells) {
const auto* const cell_data = grid[cell];
outfile << (*cell_data)[1] << endl;
}
// write each cells neighbor count
outfile << "SCALARS neighbors int 1" << endl;
outfile << "LOOKUP_TABLE default" << endl;
for (const uint64_t cell: cells) {
const auto* const neighbors = grid.get_neighbors_of(cell);
outfile << neighbors->size() << endl;
}
// write each cells process
outfile << "SCALARS process int 1" << endl;
outfile << "LOOKUP_TABLE default" << endl;
for (size_t i = 0; i < cells.size(); i++) {
outfile << rank << endl;
}
// write each cells id
outfile << "SCALARS id int 1" << endl;
outfile << "LOOKUP_TABLE default" << endl;
for (const uint64_t cell: cells) {
outfile << cell << endl;
}
outfile.close();
// get live neighbor counts
for (const auto& cell: grid.local_cells(neighborhood_id)) {
(*cell.data)[1] = 0;
for (const auto& neighbor: cell.neighbors_of) {
if ((*neighbor.data)[0] == 1) {
(*cell.data)[1]++;
}
}
}
// calculate the next turn
for (const auto& cell: grid.local_cells(neighborhood_id)) {
if ((*cell.data)[1] == 3) {
(*cell.data)[0] = 1;
} else if ((*cell.data)[1] != 2) {
(*cell.data)[0] = 0;
}
}
}
MPI_Finalize();
return EXIT_SUCCESS;
}
ReaScriptWindow::~ReaScriptWindow()
{
g_reascriptwindows.erase(this);
}
void mesh::connect_face_to_chunks(
int f,
std::unordered_set<int> & to_add,
float step_distance,
std::unordered_set<int> & chunk
) {
using namespace std;
// If this polygon is surrounded by only polygons in the same chunk skip it
bool surrounded = true;
for (int n : neighbouring_triangles[f])
surrounded &= !(chunk.count(n) == 0);
if (surrounded)
return;
// Dijkstras
unordered_map<int, float> dist;
unordered_map<int, int> prev;
priority_queue<S> pq;
pq.push(S(f, 0.0f));
while(!pq.empty()) {
S min = pq.top();
pq.pop();
for (int n : neighbouring_triangles[min.face]) {
S alt(n, distance(f, n));
// Cuttoffs
// Max step distance is exceeded
if (alt.dist > step_distance)
continue;
if (dist.count(alt.face) == 0) {
dist.emplace(alt.face, alt.dist);
prev.emplace(alt.face, min.face);
pq.push(alt);
}
else if (alt.dist < dist[alt.face]) {
dist.emplace(alt.face, alt.dist);
prev.emplace(alt.face, min.face);
pq.push(alt);
}
}
}
for(auto kv : prev) {
// If the polygon is walkable AND not in the same chunk as the starting point
// if ((walkable_faces.count(kv.first) > 0) and chunk.count(kv.first) == 0) {
if (walkable_faces.count(kv.first) > 0) {
int curr = kv.first;
while (curr != f){
to_add.insert(prev[curr]);
if (prev.count(curr) > 0)
curr = prev[curr];
}
}
}
}
bool HasFrame(const std::string& frameName)
{
std::shared_lock<std::shared_mutex> lock(frameListMutex);
return frameList.find(frameName) != frameList.end();
}
bool checkEntry(const InputMethodEntry &entry, const std::unordered_set<std::string> &inputMethods) {
return (entry.name().empty() || entry.uniqueName().empty() || entry.addon().empty() ||
inputMethods.count(entry.addon()) == 0)
? false
: true;
}
static void insert_data(const T& data, std::unordered_set<T> &value)
{
value.insert(value.rbegin() , data);
}
void KeyMultiValueTagFilter::setValues(const std::unordered_set<std::string> & values)
{
setValues(values.cbegin(), values.cend());
}
namespace HPHP {
///////////////////////////////////////////////////////////////////////////////
struct xmlErrorVec : folly::fbvector<xmlError> {
~xmlErrorVec() {
clearErrors();
}
void reset() {
clearErrors();
clear();
}
private:
void clearErrors() {
for (auto& error : *this) {
xmlResetError(&error);
}
}
};
struct LibXmlRequestData final : RequestEventHandler {
void requestInit() override {
m_use_error = false;
m_suppress_error = false;
m_errors = xmlErrorVec();
m_entity_loader_disabled = false;
m_streams_context = nullptr;
}
void requestShutdown() override {
m_use_error = false;
m_errors = xmlErrorVec();
m_streams_context = nullptr;
}
bool m_entity_loader_disabled;
bool m_suppress_error;
bool m_use_error;
xmlErrorVec m_errors;
req::ptr<StreamContext> m_streams_context;
};
IMPLEMENT_STATIC_REQUEST_LOCAL(LibXmlRequestData, tl_libxml_request_data);
namespace {
// This function takes ownership of a req::ptr<File> and returns
// a void* token that can be used to lookup the File later. This
// is so a reference to the file can be stored in an XML context
// object as a void*. The set of remembered files is cleared out
// during MemoryManager reset. The ext_libxml extension is the only
// XML extension that should be storing streams in the MemoryManager
// since it has no other place to safely store a req::ptr.
// The other XML extensions either own the req::ptr<File> locally
// or are able to store it in a object.
inline void* rememberStream(req::ptr<File>&& stream) {
return reinterpret_cast<void*>(MM().addRoot(std::move(stream)));
}
// This function returns the File associated with the given token.
// If the token is not in the MemoryManager map, it means a pointer to
// the File has been stored directly in the XML context.
inline req::ptr<File> getStream(void* userData) {
auto token = reinterpret_cast<MemoryManager::RootId>(userData);
auto res = MM().lookupRoot<File>(token);
return res ? res : *reinterpret_cast<req::ptr<File>*>(token);
}
// This closes and deletes the File associated with the given token.
// It is used by the XML callback that destroys a context.
inline bool forgetStream(void* userData) {
auto token = reinterpret_cast<MemoryManager::RootId>(userData);
auto ptr = MM().removeRoot<File>(token);
return ptr->close();
}
}
static Class* s_LibXMLError_class;
const StaticString
s_LibXMLError("LibXMLError"),
s_level("level"),
s_code("code"),
s_column("column"),
s_message("message"),
s_file("file"),
s_line("line");
///////////////////////////////////////////////////////////////////////////////
void XMLNodeData::sweep() {
if (m_node) {
assert(this == m_node->_private);
php_libxml_node_free_resource(m_node);
}
if (m_doc) m_doc->detachNode();
}
void XMLDocumentData::cleanup() {
assert(!m_liveNodes);
auto docp = (xmlDocPtr)m_node;
if (docp->URL) {
xmlFree((void*)docp->URL);
docp->URL = nullptr;
}
xmlFreeDoc(docp);
m_node = nullptr; // don't let XMLNode try to cleanup
}
void XMLDocumentData::sweep() {
if (!m_liveNodes) {
cleanup();
}
m_destruct = true;
if (m_doc) m_doc->detachNode();
}
///////////////////////////////////////////////////////////////////////////////
// Callbacks and helpers
//
// Note that these stream callbacks may re-enter the VM via a user-defined
// stream wrapper. The VM state should be synced using VMRegGuard by the
// caller, before entering libxml2.
static req::ptr<File> libxml_streams_IO_open_wrapper(
const char *filename, const char* mode, bool read_only)
{
ITRACE(1, "libxml_open_wrapper({}, {}, {})\n", filename, mode, read_only);
Trace::Indent _i;
auto strFilename = String::attach(StringData::Make(filename, CopyString));
/* FIXME: PHP calls stat() here if the wrapper has a non-null stat handler,
* in order to skip the open of a missing file, thus suppressing warnings.
* Our stat handlers are virtual, so there's no easy way to tell if stat
* is supported, so instead we will just call stat() for plain files, since
* of the default transports, only plain files have support for stat().
*/
if (read_only) {
int pathIndex = 0;
Stream::Wrapper* wrapper = Stream::getWrapperFromURI(strFilename,
&pathIndex);
if (dynamic_cast<FileStreamWrapper*>(wrapper)) {
if (!HHVM_FN(file_exists)(strFilename)) {
return nullptr;
}
}
}
// PHP unescapes the URI here, but that should properly be done by the
// wrapper. The wrapper should expect a valid URI, e.g. file:///foo%20bar
return File::Open(strFilename, mode, 0,
tl_libxml_request_data->m_streams_context);
}
int libxml_streams_IO_read(void* context, char* buffer, int len) {
ITRACE(1, "libxml_IO_read({}, {}, {})\n", context, (void*)buffer, len);
Trace::Indent _i;
auto stream = getStream(context);
assert(len >= 0);
if (len > 0) {
String str = stream->read(len);
if (str.size() <= len) {
std::memcpy(buffer, str.data(), str.size());
return str.size();
}
}
return -1;
}
int libxml_streams_IO_write(void* context, const char* buffer, int len) {
ITRACE(1, "libxml_IO_write({}, {}, {})\n", context, (void*)buffer, len);
Trace::Indent _i;
auto stream = getStream(context);
int64_t ret = stream->write(String(buffer, len, CopyString));
return (ret < INT_MAX) ? ret : -1;
}
int libxml_streams_IO_close(void* context) {
ITRACE(1, "libxml_IO_close({}), sweeping={}\n",
context, MemoryManager::sweeping());
Trace::Indent _i;
if (MemoryManager::sweeping()) {
// Stream wrappers close themselves on sweep, so there's nothing to do here
return 0;
}
return forgetStream(context) ? 0 : -1;
}
int libxml_streams_IO_nop_close(void* context) {
return 0;
}
static xmlExternalEntityLoader s_default_entity_loader = nullptr;
/*
* A whitelist of protocols allowed to be use in xml external entities. Note
* that accesses to this set are not synchronized, so it must not be modified
* after module initialization.
*/
static std::unordered_set<
const StringData*,
string_data_hash,
string_data_isame
> s_ext_entity_whitelist;
static bool allow_ext_entity_protocol(const String& protocol) {
return s_ext_entity_whitelist.count(protocol.get());
}
static xmlParserInputPtr libxml_ext_entity_loader(const char *url,
const char *id,
xmlParserCtxtPtr context) {
ITRACE(1, "libxml_ext_entity_loader({}, {}, {})\n",
url, id, (void*)context);
Trace::Indent _i;
auto protocol = Stream::getWrapperProtocol(url);
if (!allow_ext_entity_protocol(protocol)) {
raise_warning("Protocol '%s' for external XML entity '%s' is disabled for"
" security reasons. This may be changed using the"
" hhvm.libxml.ext_entity_whitelist ini setting.",
protocol.c_str(), url);
return nullptr;
}
return s_default_entity_loader(url, id, context);
}
static xmlParserInputBufferPtr
libxml_create_input_buffer(const char* URI, xmlCharEncoding enc) {
ITRACE(1, "libxml_create_input_buffer({}, {})\n", URI, static_cast<int>(enc));
Trace::Indent _i;
if (tl_libxml_request_data->m_entity_loader_disabled || !URI) return nullptr;
auto stream = libxml_streams_IO_open_wrapper(URI, "rb", true);
if (!stream || stream->isInvalid()) return nullptr;
// Allocate the Input buffer front-end.
xmlParserInputBufferPtr ret = xmlAllocParserInputBuffer(enc);
if (ret != nullptr) {
ret->context = rememberStream(std::move(stream));
ret->readcallback = libxml_streams_IO_read;
ret->closecallback = libxml_streams_IO_close;
}
return ret;
}
static xmlOutputBufferPtr
libxml_create_output_buffer(const char *URI,
xmlCharEncodingHandlerPtr encoder,
int compression ATTRIBUTE_UNUSED)
{
ITRACE(1, "libxml_create_output_buffer({}, {}, {})\n",
URI, (void*)encoder, compression);
Trace::Indent _i;
if (URI == nullptr) {
return nullptr;
}
// PHP unescapes the URI here, but that should properly be done by the
// wrapper. The wrapper should expect a valid URI, e.g. file:///foo%20bar
auto stream = libxml_streams_IO_open_wrapper(URI, "wb", false);
if (!stream || stream->isInvalid()) {
return nullptr;
}
// Allocate the Output buffer front-end.
xmlOutputBufferPtr ret = xmlAllocOutputBuffer(encoder);
if (ret != nullptr) {
ret->context = rememberStream(std::move(stream));
ret->writecallback = libxml_streams_IO_write;
ret->closecallback = libxml_streams_IO_close;
}
return ret;
}
///////////////////////////////////////////////////////////////////////////////
bool libxml_use_internal_error() {
return tl_libxml_request_data->m_use_error;
}
void libxml_add_error(const std::string &msg) {
if (tl_libxml_request_data->m_suppress_error) {
return;
}
xmlErrorVec* error_list = &tl_libxml_request_data->m_errors;
error_list->resize(error_list->size() + 1);
xmlError &error_copy = error_list->back();
memset(&error_copy, 0, sizeof(xmlError));
error_copy.domain = 0;
error_copy.code = XML_ERR_INTERNAL_ERROR;
error_copy.level = XML_ERR_ERROR;
error_copy.line = 0;
error_copy.node = nullptr;
error_copy.int1 = 0;
error_copy.int2 = 0;
error_copy.ctxt = nullptr;
error_copy.message = (char*)xmlStrdup((const xmlChar*)msg.c_str());
error_copy.file = nullptr;
error_copy.str1 = nullptr;
error_copy.str2 = nullptr;
error_copy.str3 = nullptr;
}
void php_libxml_node_free(xmlNodePtr node) {
if (node) {
if (node->_private) {
// XXX: we may be sweeping- so don't create a smart pointer
reinterpret_cast<XMLNodeData*>(node->_private)->reset();
}
switch (node->type) {
case XML_ATTRIBUTE_NODE:
xmlFreeProp((xmlAttrPtr) node);
break;
case XML_ENTITY_DECL:
case XML_ELEMENT_DECL:
case XML_ATTRIBUTE_DECL:
break;
case XML_NOTATION_NODE:
/* These require special handling */
if (node->name != NULL) {
xmlFree((char *) node->name);
}
if (((xmlEntityPtr) node)->ExternalID != NULL) {
xmlFree((char *) ((xmlEntityPtr) node)->ExternalID);
}
if (((xmlEntityPtr) node)->SystemID != NULL) {
xmlFree((char *) ((xmlEntityPtr) node)->SystemID);
}
xmlFree(node);
break;
case XML_NAMESPACE_DECL:
if (node->ns) {
xmlFreeNs(node->ns);
node->ns = NULL;
}
node->type = XML_ELEMENT_NODE;
default:
xmlFreeNode(node);
}
}
}
static void php_libxml_node_free_list(xmlNodePtr node) {
xmlNodePtr curnode;
if (node != NULL) {
curnode = node;
while (curnode != NULL) {
node = curnode;
switch (node->type) {
/* Skip property freeing for the following types */
case XML_NOTATION_NODE:
case XML_ENTITY_DECL:
break;
case XML_ENTITY_REF_NODE:
php_libxml_node_free_list((xmlNodePtr) node->properties);
break;
case XML_ATTRIBUTE_NODE:
if ((node->doc != NULL) &&
(((xmlAttrPtr) node)->atype == XML_ATTRIBUTE_ID)) {
xmlRemoveID(node->doc, (xmlAttrPtr) node);
}
case XML_ATTRIBUTE_DECL:
case XML_DTD_NODE:
case XML_DOCUMENT_TYPE_NODE:
case XML_NAMESPACE_DECL:
case XML_TEXT_NODE:
php_libxml_node_free_list(node->children);
break;
default:
php_libxml_node_free_list(node->children);
php_libxml_node_free_list((xmlNodePtr) node->properties);
}
curnode = node->next;
xmlUnlinkNode(node);
php_libxml_node_free(node);
}
}
}
void php_libxml_node_free_resource(xmlNodePtr node) {
if (node) {
switch (node->type) {
case XML_DOCUMENT_NODE:
case XML_HTML_DOCUMENT_NODE:
break;
default:
if (node->parent == NULL || node->type == XML_NAMESPACE_DECL) {
php_libxml_node_free_list((xmlNodePtr) node->children);
switch (node->type) {
/* Skip property freeing for the following types */
case XML_ATTRIBUTE_DECL:
case XML_DTD_NODE:
case XML_DOCUMENT_TYPE_NODE:
case XML_ENTITY_DECL:
case XML_ATTRIBUTE_NODE:
case XML_NAMESPACE_DECL:
case XML_TEXT_NODE:
break;
default:
php_libxml_node_free_list((xmlNodePtr) node->properties);
}
php_libxml_node_free(node);
}
}
}
}
String libxml_get_valid_file_path(const char* source) {
return libxml_get_valid_file_path(String(source, CopyString));
}
String libxml_get_valid_file_path(const String& source) {
bool isFileUri = false;
bool isUri = false;
String file_dest(source);
Url url;
if (url_parse(url, file_dest.data(), file_dest.size())) {
isUri = true;
if (url.scheme.same(s_file)) {
file_dest = StringUtil::UrlDecode(url.path, false);
isFileUri = true;
}
}
if (url.scheme.empty() && (!isUri || isFileUri)) {
file_dest = File::TranslatePath(file_dest);
}
return file_dest;
}
static void libxml_error_handler(void* userData, xmlErrorPtr error) {
if (tl_libxml_request_data->m_suppress_error) {
return;
}
xmlErrorVec* error_list = &tl_libxml_request_data->m_errors;
error_list->resize(error_list->size() + 1);
xmlError &error_copy = error_list->back();
memset(&error_copy, 0, sizeof(xmlError));
if (error) {
xmlCopyError(error, &error_copy);
} else {
error_copy.code = XML_ERR_INTERNAL_ERROR;
error_copy.level = XML_ERR_ERROR;
}
}
static Object create_libxmlerror(xmlError &error) {
Object ret{s_LibXMLError_class};
ret->o_set(s_level, error.level);
ret->o_set(s_code, error.code);
ret->o_set(s_column, error.int2);
ret->o_set(s_message, String(error.message, CopyString));
ret->o_set(s_file, String(error.file, CopyString));
ret->o_set(s_line, error.line);
return ret;
}
Array HHVM_FUNCTION(libxml_get_errors) {
xmlErrorVec* error_list = &tl_libxml_request_data->m_errors;
const auto length = error_list->size();
if (!length) {
return empty_array();
}
PackedArrayInit ret(length);
for (int64_t i = 0; i < length; i++) {
ret.append(create_libxmlerror(error_list->at(i)));
}
return ret.toArray();
}
Variant HHVM_FUNCTION(libxml_get_last_error) {
xmlErrorPtr error = xmlGetLastError();
if (error) {
return create_libxmlerror(*error);
}
return false;
}
void HHVM_FUNCTION(libxml_clear_errors) {
xmlResetLastError();
tl_libxml_request_data->m_errors.reset();
}
bool HHVM_FUNCTION(libxml_use_internal_errors, bool use_errors) {
bool ret = (xmlStructuredError == libxml_error_handler);
if (!use_errors) {
xmlSetStructuredErrorFunc(nullptr, nullptr);
tl_libxml_request_data->m_use_error = false;
tl_libxml_request_data->m_suppress_error = false;
tl_libxml_request_data->m_errors.reset();
} else {
xmlSetStructuredErrorFunc(nullptr, libxml_error_handler);
tl_libxml_request_data->m_use_error = true;
tl_libxml_request_data->m_suppress_error = false;
}
return ret;
}
void HHVM_FUNCTION(libxml_suppress_errors, bool suppress_errors) {
tl_libxml_request_data->m_suppress_error = suppress_errors;
}
bool HHVM_FUNCTION(libxml_disable_entity_loader, bool disable /* = true */) {
bool old = tl_libxml_request_data->m_entity_loader_disabled;
tl_libxml_request_data->m_entity_loader_disabled = disable;
return old;
}
void HHVM_FUNCTION(libxml_set_streams_context, const Resource & context) {
tl_libxml_request_data->m_streams_context =
dyn_cast_or_null<StreamContext>(context);
}
///////////////////////////////////////////////////////////////////////////////
// Extension
struct LibXMLExtension final : Extension {
LibXMLExtension() : Extension("libxml") {}
void moduleLoad(const IniSetting::Map& ini, Hdf config) override {
// Grab the external entity whitelist and set up the map, then register
// the callback for external entity loading. data: is always supported
// since it doesn't reference data outside of the current document.
std::vector<std::string> whitelist;
auto whitelistStr = Config::GetString(ini, config,
"Eval.Libxml.ExtEntityWhitelist");
folly::split(',', whitelistStr, whitelist, true);
s_ext_entity_whitelist.reserve(1 + whitelist.size());
s_ext_entity_whitelist.insert(makeStaticString("data"));
for (auto const& str : whitelist) {
s_ext_entity_whitelist.insert(makeStaticString(str));
}
}
void moduleInit() override {
HHVM_RC_INT_SAME(LIBXML_VERSION);
HHVM_RC_STR_SAME(LIBXML_DOTTED_VERSION);
HHVM_RC_STR(LIBXML_LOADED_VERSION, xmlParserVersion);
// For use with loading xml
HHVM_RC_INT(LIBXML_NOENT, XML_PARSE_NOENT);
HHVM_RC_INT(LIBXML_DTDLOAD, XML_PARSE_DTDLOAD);
HHVM_RC_INT(LIBXML_DTDATTR, XML_PARSE_DTDATTR);
HHVM_RC_INT(LIBXML_DTDVALID, XML_PARSE_DTDVALID);
HHVM_RC_INT(LIBXML_NOERROR, XML_PARSE_NOERROR);
HHVM_RC_INT(LIBXML_NOWARNING, XML_PARSE_NOWARNING);
HHVM_RC_INT(LIBXML_NOBLANKS, XML_PARSE_NOBLANKS);
HHVM_RC_INT(LIBXML_XINCLUDE, XML_PARSE_XINCLUDE);
HHVM_RC_INT(LIBXML_NSCLEAN, XML_PARSE_NSCLEAN);
HHVM_RC_INT(LIBXML_NOCDATA, XML_PARSE_NOCDATA);
HHVM_RC_INT(LIBXML_NONET, XML_PARSE_NONET);
HHVM_RC_INT(LIBXML_PEDANTIC, XML_PARSE_PEDANTIC);
HHVM_RC_INT(LIBXML_COMPACT, XML_PARSE_COMPACT);
HHVM_RC_INT(LIBXML_NOXMLDECL, XML_SAVE_NO_DECL);
HHVM_RC_INT(LIBXML_PARSEHUGE, XML_PARSE_HUGE);
HHVM_RC_INT(LIBXML_NOEMPTYTAG, LIBXML_SAVE_NOEMPTYTAG);
// Schema validation options
#if defined(LIBXML_SCHEMAS_ENABLED)
HHVM_RC_INT(LIBXML_SCHEMA_CREATE, XML_SCHEMA_VAL_VC_I_CREATE);
#endif
// Additional constants for use with loading html
#if LIBXML_VERSION >= 20707
HHVM_RC_INT(LIBXML_HTML_NOIMPLIED, HTML_PARSE_NOIMPLIED);
#endif
#if LIBXML_VERSION >= 20708
HHVM_RC_INT(LIBXML_HTML_NODEFDTD, HTML_PARSE_NODEFDTD);
#endif
// Error levels
HHVM_RC_INT(LIBXML_ERR_NONE, XML_ERR_NONE);
HHVM_RC_INT(LIBXML_ERR_WARNING, XML_ERR_WARNING);
HHVM_RC_INT(LIBXML_ERR_ERROR, XML_ERR_ERROR);
HHVM_RC_INT(LIBXML_ERR_FATAL, XML_ERR_FATAL);
HHVM_FE(libxml_get_errors);
HHVM_FE(libxml_get_last_error);
HHVM_FE(libxml_clear_errors);
HHVM_FE(libxml_use_internal_errors);
HHVM_FE(libxml_suppress_errors);
HHVM_FE(libxml_disable_entity_loader);
HHVM_FE(libxml_set_streams_context);
loadSystemlib();
s_LibXMLError_class = Unit::lookupClass(s_LibXMLError.get());
// Set up callbacks to support stream wrappers for reading and writing
// xml files and loading external entities.
xmlParserInputBufferCreateFilenameDefault(libxml_create_input_buffer);
xmlOutputBufferCreateFilenameDefault(libxml_create_output_buffer);
s_default_entity_loader = xmlGetExternalEntityLoader();
xmlSetExternalEntityLoader(libxml_ext_entity_loader);
}
void requestInit() override {
xmlResetLastError();
}
} s_libxml_extension;
///////////////////////////////////////////////////////////////////////////////
}
bool is_valid_reascriptwindow(ReaScriptWindow* w)
{
return g_reascriptwindows.count(w) == 1;
}
void TransactionContext::stealChunks(std::unordered_set<RevisionCacheChunk*>& target) {
target.clear();
_chunks.swap(target);
}
ReaScriptWindow::ReaScriptWindow(std::string title) : MRPWindow(g_parent,title)
{
g_reascriptwindows.insert(this);
// deliberately allocate tons of memory to see object destruction works
m_leak_test.resize(100000000);
}
void GraphCompressor::Compress(const std::unordered_set<NodeID> &barrier_nodes,
const std::unordered_set<NodeID> &traffic_lights,
RestrictionMap &restriction_map,
util::NodeBasedDynamicGraph &graph,
CompressedEdgeContainer &geometry_compressor)
{
const unsigned original_number_of_nodes = graph.GetNumberOfNodes();
const unsigned original_number_of_edges = graph.GetNumberOfEdges();
util::Percent progress(original_number_of_nodes);
for (const NodeID node_v : util::irange(0u, original_number_of_nodes))
{
progress.PrintStatus(node_v);
// only contract degree 2 vertices
if (2 != graph.GetOutDegree(node_v))
{
continue;
}
// don't contract barrier node
if (barrier_nodes.end() != barrier_nodes.find(node_v))
{
continue;
}
// check if v is a via node for a turn restriction, i.e. a 'directed' barrier node
if (restriction_map.IsViaNode(node_v))
{
continue;
}
// reverse_e2 forward_e2
// u <---------- v -----------> w
// ----------> <-----------
// forward_e1 reverse_e1
//
// Will be compressed to:
//
// reverse_e1
// u <---------- w
// ---------->
// forward_e1
//
// If the edges are compatible.
const bool reverse_edge_order = graph.GetEdgeData(graph.BeginEdges(node_v)).reversed;
const EdgeID forward_e2 = graph.BeginEdges(node_v) + reverse_edge_order;
BOOST_ASSERT(SPECIAL_EDGEID != forward_e2);
BOOST_ASSERT(forward_e2 >= graph.BeginEdges(node_v) && forward_e2 < graph.EndEdges(node_v));
const EdgeID reverse_e2 = graph.BeginEdges(node_v) + 1 - reverse_edge_order;
BOOST_ASSERT(SPECIAL_EDGEID != reverse_e2);
BOOST_ASSERT(reverse_e2 >= graph.BeginEdges(node_v) && reverse_e2 < graph.EndEdges(node_v));
const EdgeData &fwd_edge_data2 = graph.GetEdgeData(forward_e2);
const EdgeData &rev_edge_data2 = graph.GetEdgeData(reverse_e2);
const NodeID node_w = graph.GetTarget(forward_e2);
BOOST_ASSERT(SPECIAL_NODEID != node_w);
BOOST_ASSERT(node_v != node_w);
const NodeID node_u = graph.GetTarget(reverse_e2);
BOOST_ASSERT(SPECIAL_NODEID != node_u);
BOOST_ASSERT(node_u != node_v);
const EdgeID forward_e1 = graph.FindEdge(node_u, node_v);
BOOST_ASSERT(SPECIAL_EDGEID != forward_e1);
BOOST_ASSERT(node_v == graph.GetTarget(forward_e1));
const EdgeID reverse_e1 = graph.FindEdge(node_w, node_v);
BOOST_ASSERT(SPECIAL_EDGEID != reverse_e1);
BOOST_ASSERT(node_v == graph.GetTarget(reverse_e1));
const EdgeData &fwd_edge_data1 = graph.GetEdgeData(forward_e1);
const EdgeData &rev_edge_data1 = graph.GetEdgeData(reverse_e1);
if (graph.FindEdgeInEitherDirection(node_u, node_w) != SPECIAL_EDGEID)
{
continue;
}
// this case can happen if two ways with different names overlap
if (fwd_edge_data1.name_id != rev_edge_data1.name_id ||
fwd_edge_data2.name_id != rev_edge_data2.name_id)
{
continue;
}
if (fwd_edge_data1.IsCompatibleTo(fwd_edge_data2) &&
rev_edge_data1.IsCompatibleTo(rev_edge_data2))
{
BOOST_ASSERT(graph.GetEdgeData(forward_e1).name_id ==
graph.GetEdgeData(reverse_e1).name_id);
BOOST_ASSERT(graph.GetEdgeData(forward_e2).name_id ==
graph.GetEdgeData(reverse_e2).name_id);
// Do not compress edge if it crosses a traffic signal.
// This can't be done in IsCompatibleTo, becase we only store the
// traffic signals in the `traffic_lights` list, which EdgeData
// doesn't have access to.
const bool has_node_penalty = traffic_lights.find(node_v) != traffic_lights.end();
if (has_node_penalty)
{
continue;
}
// Get distances before graph is modified
const int forward_weight1 = graph.GetEdgeData(forward_e1).distance;
const int forward_weight2 = graph.GetEdgeData(forward_e2).distance;
BOOST_ASSERT(0 != forward_weight1);
BOOST_ASSERT(0 != forward_weight2);
const int reverse_weight1 = graph.GetEdgeData(reverse_e1).distance;
const int reverse_weight2 = graph.GetEdgeData(reverse_e2).distance;
BOOST_ASSERT(0 != reverse_weight1);
BOOST_ASSERT(0 != reverse_weight2);
// add weight of e2's to e1
graph.GetEdgeData(forward_e1).distance += fwd_edge_data2.distance;
graph.GetEdgeData(reverse_e1).distance += rev_edge_data2.distance;
// extend e1's to targets of e2's
graph.SetTarget(forward_e1, node_w);
graph.SetTarget(reverse_e1, node_u);
// remove e2's (if bidir, otherwise only one)
graph.DeleteEdge(node_v, forward_e2);
graph.DeleteEdge(node_v, reverse_e2);
// update any involved turn restrictions
restriction_map.FixupStartingTurnRestriction(node_u, node_v, node_w);
restriction_map.FixupArrivingTurnRestriction(node_u, node_v, node_w, graph);
restriction_map.FixupStartingTurnRestriction(node_w, node_v, node_u);
restriction_map.FixupArrivingTurnRestriction(node_w, node_v, node_u, graph);
// store compressed geometry in container
geometry_compressor.CompressEdge(
forward_e1, forward_e2, node_v, node_w, forward_weight1, forward_weight2);
geometry_compressor.CompressEdge(
reverse_e1, reverse_e2, node_v, node_u, reverse_weight1, reverse_weight2);
}
}
PrintStatistics(original_number_of_nodes, original_number_of_edges, graph);
// Repeate the loop, but now add all edges as uncompressed values.
// The function AddUncompressedEdge does nothing if the edge is already
// in the CompressedEdgeContainer.
for (const NodeID node_u : util::irange(0u, original_number_of_nodes))
{
for (const auto edge_id : util::irange(graph.BeginEdges(node_u), graph.EndEdges(node_u)))
{
const EdgeData &data = graph.GetEdgeData(edge_id);
const NodeID target = graph.GetTarget(edge_id);
geometry_compressor.AddUncompressedEdge(edge_id, target, data.distance);
}
}
}
bool didReuseNode(SyntaxNodeId NodeId) {
return ReusedNodeIds.count(NodeId) > 0;
}
/* Calculate whether an assertion is a standard non-NULL check.
* e.g. (x != NULL), (x), (x != NULL && …) or (x && …).
*
* Insert the ValueDecls of the variables being checked into the provided
* unordered_set, and return the number of such insertions (this will be 0 if no
* variables are non-NULL checked). The returned number may be an over-estimate
* of the number of elements in the set, as it doesn’t account for
* duplicates. */
static unsigned int
_assertion_is_explicit_nonnull_check (Expr& assertion_expr,
const ASTContext& context,
std::unordered_set<const ValueDecl*>& ret)
{
DEBUG_EXPR (__func__ << ": ", assertion_expr);
switch ((int) assertion_expr.getStmtClass ()) {
case Expr::BinaryOperatorClass: {
BinaryOperator& bin_expr =
cast<BinaryOperator> (assertion_expr);
BinaryOperatorKind opcode = bin_expr.getOpcode ();
if (opcode == BinaryOperatorKind::BO_LAnd) {
/* LHS && RHS */
unsigned int lhs_count =
AssertionExtracter::assertion_is_nonnull_check (*(bin_expr.getLHS ()), context, ret);
unsigned int rhs_count =
AssertionExtracter::assertion_is_nonnull_check (*(bin_expr.getRHS ()), context, ret);
return lhs_count + rhs_count;
} else if (opcode == BinaryOperatorKind::BO_LOr) {
/* LHS || RHS */
std::unordered_set<const ValueDecl*> lhs_vars, rhs_vars;
unsigned int lhs_count =
AssertionExtracter::assertion_is_nonnull_check (*(bin_expr.getLHS ()), context, lhs_vars);
unsigned int rhs_count =
AssertionExtracter::assertion_is_nonnull_check (*(bin_expr.getRHS ()), context, rhs_vars);
std::set_intersection (lhs_vars.begin (),
lhs_vars.end (),
rhs_vars.begin (),
rhs_vars.end (),
std::inserter (ret, ret.end ()));
return lhs_count + rhs_count;
} else if (opcode == BinaryOperatorKind::BO_NE) {
/* LHS != RHS */
Expr* rhs = bin_expr.getRHS ();
Expr::NullPointerConstantKind k =
rhs->isNullPointerConstant (const_cast<ASTContext&> (context),
Expr::NullPointerConstantValueDependence::NPC_ValueDependentIsNotNull);
if (k != Expr::NullPointerConstantKind::NPCK_NotNull &&
bin_expr.getLHS ()->IgnoreParenCasts ()->getStmtClass () == Expr::DeclRefExprClass) {
DEBUG ("Found non-NULL check.");
ret.insert (cast<DeclRefExpr> (bin_expr.getLHS ()->IgnoreParenCasts ())->getDecl ());
return 1;
}
/* Either not a comparison to NULL, or the expr being
* compared is not a DeclRefExpr. */
return 0;
}
return 0;
}
case Expr::UnaryOperatorClass: {
/* A unary operator. For the moment, assume this isn't a
* non-null check.
*
* FIXME: In the future, define a proper program transformation
* to check for non-null checks, since we could have expressions
* like:
* !(my_var == NULL)
* or (more weirdly):
* ~(my_var == NULL)
*/
return 0;
}
case Expr::ConditionalOperatorClass: {
/* A conditional operator. For the moment, assume this isn’t a
* non-null check.
*
* FIXME: In the future, define a proper program transformation
* to check for non-null checks, since we could have expressions
* like:
* (x == NULL) ? TRUE : FALSE
*/
return 0;
}
case Expr::CStyleCastExprClass:
case Expr::ImplicitCastExprClass: {
/* A (explicit or implicit) cast. This can either be:
* (void*)0
* or
* (bool)my_var */
CastExpr& cast_expr = cast<CastExpr> (assertion_expr);
Expr* sub_expr = cast_expr.getSubExpr ()->IgnoreParenCasts ();
if (sub_expr->getStmtClass () == Expr::DeclRefExprClass) {
DEBUG ("Found non-NULL check.");
ret.insert (cast<DeclRefExpr> (sub_expr)->getDecl ());
return 1;
}
/* Not a cast to NULL, or the expr being casted is not a
* DeclRefExpr. */
return 0;
}
case Expr::DeclRefExprClass: {
/* A variable reference, which will implicitly become a non-NULL
* check. */
DEBUG ("Found non-NULL check.");
DeclRefExpr& decl_ref_expr = cast<DeclRefExpr> (assertion_expr);
ret.insert (decl_ref_expr.getDecl ());
return 1;
}
case Expr::StmtExprClass:
/* FIXME: Statement expressions can be nonnull checks, but
* detecting them requires a formal program transformation which
* has not been implemented yet. */
case Expr::CallExprClass:
/* Function calls can’t be nonnull checks. */
case Expr::IntegerLiteralClass: {
/* Integer literals can’t be nonnull checks. */
return 0;
}
case Stmt::StmtClass::NoStmtClass:
default:
WARN_EXPR (__func__ << "() can’t handle expressions of type " <<
assertion_expr.getStmtClassName (), assertion_expr);
return 0;
}
}
std::vector<std::string> nextPossibles(const std::string& s,
std::unordered_set<std::string>& visited,
std::unordered_set<std::string>& deadendSet)
{
std::vector<std::string> res;
int a = s[0] - '0';
int b = s[1] - '0';
int c = s[2] - '0';
int d = s[3] - '0';
std::vector<int> aV = { a == 0 ? 9 : a - 1, a == 9 ? 0 : a + 1};
std::vector<int> bV = { b == 0 ? 9 : b - 1, b == 9 ? 0 : b + 1};
std::vector<int> cV = { c == 0 ? 9 : c - 1, c == 9 ? 0 : c + 1};
std::vector<int> dV = { d == 0 ? 9 : d - 1, d == 9 ? 0 : d + 1};
for(int i = 0; i < 2; ++i)
{
std::stringstream ss;
ss<< aV[i] << b << c << d;
const auto& s = ss.str();
if(visited.find(s) == visited.end() && deadendSet.find(s) == deadendSet.end())
{
visited.insert(s);
res.push_back(s);
}
}
for(int i = 0; i < 2; ++i)
{
std::stringstream ss;
ss<< a << bV[i] << c << d;
const auto& s = ss.str();
if(visited.find(s) == visited.end() && deadendSet.find(s) == deadendSet.end())
{
visited.insert(s);
res.push_back(s);
}
}
for(int i = 0; i < 2; ++i)
{
std::stringstream ss;
ss<< a << b << cV[i] << d;
const auto& s = ss.str();
if(visited.find(s) == visited.end() && deadendSet.find(s) == deadendSet.end())
{
visited.insert(s);
res.push_back(s);
}
}
for(int i = 0; i < 2; ++i)
{
std::stringstream ss;
ss<< a << b << c << dV[i];
const auto& s = ss.str();
if(visited.find(s) == visited.end() && deadendSet.find(s) == deadendSet.end())
{
visited.insert(s);
res.push_back(s);
}
}
return res;
}
// populate the graph with info from the wasm, integrating with potentially-existing
// nodes for imports and exports that the graph may already contain.
void scanWebAssembly() {
// Add an entry for everything we might need ahead of time, so parallel work
// does not alter parent state, just adds to things pointed by it, independently
// (each thread will add for one function, etc.)
ModuleUtils::iterDefinedFunctions(wasm, [&](Function* func) {
auto dceName = getName("func", func->name.str);
DCENodeToFunction[dceName] = func->name;
functionToDCENode[func->name] = dceName;
nodes[dceName] = DCENode(dceName);
});
ModuleUtils::iterDefinedGlobals(wasm, [&](Global* global) {
auto dceName = getName("global", global->name.str);
DCENodeToGlobal[dceName] = global->name;
globalToDCENode[global->name] = dceName;
nodes[dceName] = DCENode(dceName);
});
// only process function and global imports - the table and memory are always there
ModuleUtils::iterImportedFunctions(wasm, [&](Function* import) {
auto id = getImportId(import->module, import->base);
if (importIdToDCENode.find(id) == importIdToDCENode.end()) {
auto dceName = getName("importId", import->name.str);
importIdToDCENode[id] = dceName;
}
});
ModuleUtils::iterImportedGlobals(wasm, [&](Global* import) {
auto id = getImportId(import->module, import->base);
if (importIdToDCENode.find(id) == importIdToDCENode.end()) {
auto dceName = getName("importId", import->name.str);
importIdToDCENode[id] = dceName;
}
});
for (auto& exp : wasm.exports) {
if (exportToDCENode.find(exp->name) == exportToDCENode.end()) {
auto dceName = getName("export", exp->name.str);
DCENodeToExport[dceName] = exp->name;
exportToDCENode[exp->name] = dceName;
nodes[dceName] = DCENode(dceName);
}
// we can also link the export to the thing being exported
auto& node = nodes[exportToDCENode[exp->name]];
if (exp->kind == ExternalKind::Function) {
if (!wasm.getFunction(exp->value)->imported()) {
node.reaches.push_back(functionToDCENode[exp->value]);
} else {
node.reaches.push_back(importIdToDCENode[getFunctionImportId(exp->value)]);
}
} else if (exp->kind == ExternalKind::Global) {
if (!wasm.getGlobal(exp->value)->imported()) {
node.reaches.push_back(globalToDCENode[exp->value]);
} else {
node.reaches.push_back(importIdToDCENode[getGlobalImportId(exp->value)]);
}
}
}
// Add initializer dependencies
// if we provide a parent DCE name, that is who can reach what we see
// if none is provided, then it is something we must root
struct InitScanner : public PostWalker<InitScanner> {
InitScanner(MetaDCEGraph* parent, Name parentDceName) : parent(parent), parentDceName(parentDceName) {}
void visitGetGlobal(GetGlobal* curr) {
handleGlobal(curr->name);
}
void visitSetGlobal(SetGlobal* curr) {
handleGlobal(curr->name);
}
private:
MetaDCEGraph* parent;
Name parentDceName;
void handleGlobal(Name name) {
Name dceName;
if (!getModule()->getGlobal(name)->imported()) {
// its a defined global
dceName = parent->globalToDCENode[name];
} else {
// it's an import.
dceName = parent->importIdToDCENode[parent->getGlobalImportId(name)];
}
if (parentDceName.isNull()) {
parent->roots.insert(parentDceName);
} else {
parent->nodes[parentDceName].reaches.push_back(dceName);
}
}
};
ModuleUtils::iterDefinedGlobals(wasm, [&](Global* global) {
InitScanner scanner(this, globalToDCENode[global->name]);
scanner.setModule(&wasm);
scanner.walk(global->init);
});
// we can't remove segments, so root what they need
InitScanner rooter(this, Name());
rooter.setModule(&wasm);
for (auto& segment : wasm.table.segments) {
// TODO: currently, all functions in the table are roots, but we
// should add an option to refine that
for (auto& name : segment.data) {
if (!wasm.getFunction(name)->imported()) {
roots.insert(functionToDCENode[name]);
} else {
roots.insert(importIdToDCENode[getFunctionImportId(name)]);
}
}
rooter.walk(segment.offset);
}
for (auto& segment : wasm.memory.segments) {
if (!segment.isPassive) {
rooter.walk(segment.offset);
}
}
// A parallel scanner for function bodies
struct Scanner : public WalkerPass<PostWalker<Scanner>> {
bool isFunctionParallel() override { return true; }
Scanner(MetaDCEGraph* parent) : parent(parent) {}
Scanner* create() override {
return new Scanner(parent);
}
void visitCall(Call* curr) {
if (!getModule()->getFunction(curr->target)->imported()) {
parent->nodes[parent->functionToDCENode[getFunction()->name]].reaches.push_back(
parent->functionToDCENode[curr->target]
);
} else {
assert(parent->functionToDCENode.count(getFunction()->name) > 0);
parent->nodes[parent->functionToDCENode[getFunction()->name]].reaches.push_back(
parent->importIdToDCENode[parent->getFunctionImportId(curr->target)]
);
}
}
void visitGetGlobal(GetGlobal* curr) {
handleGlobal(curr->name);
}
void visitSetGlobal(SetGlobal* curr) {
handleGlobal(curr->name);
}
private:
MetaDCEGraph* parent;
void handleGlobal(Name name) {
if (!getFunction()) return; // non-function stuff (initializers) are handled separately
Name dceName;
if (!getModule()->getGlobal(name)->imported()) {
// its a global
dceName = parent->globalToDCENode[name];
} else {
// it's an import.
dceName = parent->importIdToDCENode[parent->getGlobalImportId(name)];
}
parent->nodes[parent->functionToDCENode[getFunction()->name]].reaches.push_back(dceName);
}
};
PassRunner runner(&wasm);
runner.setIsNested(true);
runner.add<Scanner>(this);
runner.run();
}
/*!
* \brief First pass of patching operation
*
* This performs the following operations:
*
* - Files needed by an AutoPatcher are extracted to the temporary directory.
* - Otherwise, the file is copied directly to the output zip.
*/
bool ZipPatcher::pass1(const std::string &temporary_dir,
const std::unordered_set<std::string> &exclude)
{
using namespace std::placeholders;
void *h_in = MinizipUtils::ctx_get_zip_handle(m_z_input);
void *h_out = MinizipUtils::ctx_get_zip_handle(m_z_output);
int ret = mz_zip_goto_first_entry(h_in);
if (ret != MZ_OK && ret != MZ_END_OF_LIST) {
m_error = ErrorCode::ArchiveReadHeaderError;
return false;
}
if (ret != MZ_END_OF_LIST) {
do {
if (m_cancelled) return false;
mz_zip_file *file_info;
ret = mz_zip_entry_get_info(h_in, &file_info);
if (ret != MZ_OK) {
m_error = ErrorCode::ArchiveReadHeaderError;
return false;
}
std::string cur_file{file_info->filename, file_info->filename_size};
update_files(++m_files, m_max_files);
update_details(cur_file);
// Skip files that should be patched and added in pass 2
if (exclude.find(cur_file) != exclude.end()) {
if (!MinizipUtils::extract_file(h_in, temporary_dir)) {
m_error = ErrorCode::ArchiveReadDataError;
return false;
}
continue;
}
// Rename the installer for mbtool
if (cur_file == "META-INF/com/google/android/update-binary") {
cur_file = "META-INF/com/google/android/update-binary.orig";
}
if (!MinizipUtils::copy_file_raw(h_in, h_out, cur_file,
std::bind(&ZipPatcher::la_progress_cb, this, _1))) {
LOGW("minizip: Failed to copy raw data: %s", cur_file.c_str());
m_error = ErrorCode::ArchiveWriteDataError;
return false;
}
m_bytes += file_info->uncompressed_size;
} while ((ret = mz_zip_goto_next_entry(h_in)) == MZ_OK);
if (ret != MZ_END_OF_LIST) {
m_error = ErrorCode::ArchiveReadHeaderError;
return false;
}
}
if (m_cancelled) return false;
return true;
}
std::pair<uint, std::pair<goals, goals>> parse_goals(
parser& p,
std::vector<warning>& warnings_list,
const std::unordered_set<char>& declared_pieces,
const board& declared_board)throw(goals_parse_error,parse_error){
uint turns_limit;
goals uppercase_player_goals;
goals lowercase_player_goals;
if(!p.expect_string("<GOALS>"))
throw parse_error(p.get_line_number(), p.get_char_in_line_number(), "Goals segment must begin with \'<GOALS>\' string");
p.expect_whitespace();
parser_result<int> turns_limit_result = p.expect_int();
if(!turns_limit_result)
throw goals_parse_error(turns_limit_result.info.line_number, turns_limit_result.info.char_number, turns_limit_result.info.human_readable_info.c_str());
if(turns_limit_result.result < 1)
throw goals_parse_error(p.get_line_number(), p.get_char_in_line_number(), "Turns limit must be positive");
turns_limit = turns_limit_result.result;
p.expect_whitespace();
if(p.expect_plain_char()!='&')
throw goals_parse_error(p.get_line_number(), p.get_char_in_line_number(), "Turns limit must be terminated with \'&\'");
p.expect_whitespace();
char next_char = p.expect_plain_char();
bool ignore;
while(next_char == '@' || next_char == '#'){
ignore = false;
if(next_char == '@'){
next_char = p.expect_plain_char();
bool uppercase_player;
if(isupper(next_char))
uppercase_player = true;
else if(islower(next_char)){
uppercase_player = false;
next_char = toupper(next_char);
}
else
throw goals_parse_error(p.get_line_number(), p.get_char_in_line_number(), "Expected letter after \'@\'");
if(!declared_pieces.count(next_char)){
ignore = true;
warnings_list.push_back(warning(p.get_line_number(), p.get_char_in_line_number(), "Undeclared piece (piece doesn't appear in the previous board declaration)"));
}
char piece_symbol = next_char;
do{
p.expect_whitespace();
parser_result<int> x_result = p.expect_int();
if(!x_result)
throw goals_parse_error(x_result.info.line_number, x_result.info.char_number, x_result.info.human_readable_info.c_str());
if(x_result.result < 0)
throw goals_parse_error(p.get_line_number(), p.get_char_in_line_number(), "x coordinate must be non-negative");
if(!p.expect_whitespace())
throw goals_parse_error(p.get_line_number(), p.get_char_in_line_number(), "Expected whitespace after x coordinate");
parser_result<int> y_result = p.expect_int();
if(!y_result)
throw goals_parse_error(y_result.info.line_number, y_result.info.char_number, y_result.info.human_readable_info.c_str());
if(y_result.result < 0)
throw goals_parse_error(p.get_line_number(), p.get_char_in_line_number(), "y coordinate must be non-negative");
if(!declared_board.inside(x_result.result, y_result.result)){
ignore = true;
warnings_list.push_back(warning(p.get_line_number(), p.get_char_in_line_number(), "Given point is outside the board"));
}
if(!ignore){
if(uppercase_player)
uppercase_player_goals.add_piece_placement_goal(piece_symbol, x_result.result, y_result.result);
else
lowercase_player_goals.add_piece_placement_goal(piece_symbol, x_result.result, y_result.result);
}
p.expect_whitespace();
next_char = p.expect_plain_char();
if(next_char != ',' && next_char != '&')
throw goals_parse_error(p.get_line_number(), p.get_char_in_line_number(), "Expected \',\' or \'&\'");
}while(next_char != '&');
}
else{
next_char = p.expect_plain_char();
bool uppercase_player;
if(isupper(next_char))
uppercase_player = false;
else if(islower(next_char)){
uppercase_player = true;
next_char = toupper(next_char);
}
else
throw goals_parse_error(p.get_line_number(), p.get_char_in_line_number(), "Expected letter after \'#\'");
if(!declared_pieces.count(next_char)){
ignore = true;
warnings_list.push_back(warning(p.get_line_number(), p.get_char_in_line_number(), "Undeclared piece (piece doesn't appear in the previous board declaration)"));
}
p.expect_whitespace();
parser_result<int> number_of_pieces_result = p.expect_int();
if(!number_of_pieces_result)
throw goals_parse_error(number_of_pieces_result.info.line_number, number_of_pieces_result.info.char_number, number_of_pieces_result.info.human_readable_info.c_str());
if(number_of_pieces_result.result < 0)
throw goals_parse_error(p.get_line_number(), p.get_char_in_line_number(), "Number of piece captures must be non negative");
if(!ignore){
if(uppercase_player)
uppercase_player_goals.add_piece_capture_goal(next_char, number_of_pieces_result.result);
else
lowercase_player_goals.add_piece_capture_goal(next_char, number_of_pieces_result.result);
}
p.expect_whitespace();
if(p.expect_plain_char()!='&')
throw goals_parse_error(p.get_line_number(), p.get_char_in_line_number(), "Capture goal must be terminated with \'&\'");
}
p.expect_whitespace();
next_char = p.expect_plain_char();
}
return std::make_pair(turns_limit, std::make_pair(std::move(uppercase_player_goals), std::move(lowercase_player_goals)));
}
namespace citygml {
// The nodes that are valid Polygon Objects
std::unordered_set<int> typeIDSet;
bool typeIDSetInitialized = false;
std::mutex polygonElementParser_initializedTypeIDMutex;
PolygonElementParser::PolygonElementParser(CityGMLDocumentParser& documentParser, CityGMLFactory& factory, std::shared_ptr<CityGMLLogger> logger, std::function<void(std::shared_ptr<Polygon>)> callback)
: GMLObjectElementParser(documentParser, factory, logger)
{
m_callback = callback;
}
std::string PolygonElementParser::elementParserName() const
{
return "PolygonElementParser";
}
bool PolygonElementParser::handlesElement(const NodeType::XMLNode& node) const
{
if (!typeIDSetInitialized) {
std::lock_guard<std::mutex> lock(polygonElementParser_initializedTypeIDMutex);
if(!typeIDSetInitialized) {
typeIDSet.insert(NodeType::GML_TriangleNode.typeID());
typeIDSet.insert(NodeType::GML_RectangleNode.typeID());
typeIDSet.insert(NodeType::GML_PolygonNode.typeID());
typeIDSet.insert(NodeType::GML_PolygonPatchNode.typeID());
typeIDSetInitialized = true;
}
}
return typeIDSet.count(node.typeID()) > 0;
}
bool PolygonElementParser::parseElementStartTag(const NodeType::XMLNode& node, Attributes& attributes)
{
if (!handlesElement(node)) {
CITYGML_LOG_ERROR(m_logger, "Expected start tag of PolygonObject but got <" << node.name() << "> at " << getDocumentLocation());
throw std::runtime_error("Unexpected start tag found.");
}
m_model = m_factory.createPolygon(attributes.getCityGMLIDAttribute());
return true;
}
bool PolygonElementParser::parseElementEndTag(const NodeType::XMLNode&, const std::string&)
{
m_callback(m_model);
return true;
}
bool PolygonElementParser::parseChildElementStartTag(const NodeType::XMLNode& node, Attributes& attributes)
{
if (m_model == nullptr) {
throw std::runtime_error("PolygonElementParser::parseChildElementStartTag called before PolygonElementParser::parseElementStartTag");
}
if (node == NodeType::GML_InteriorNode) {
parseRingElement(true);
return true;
} else if (node == NodeType::GML_ExteriorNode) {
parseRingElement(false);
return true;
}
return GMLObjectElementParser::parseChildElementStartTag(node, attributes);
}
bool PolygonElementParser::parseChildElementEndTag(const NodeType::XMLNode& node, const std::string& characters)
{
if (m_model == nullptr) {
throw std::runtime_error("PolygonElementParser::parseChildElementEndTag called before PolygonElementParser::parseElementStartTag");
}
if (node == NodeType::GML_InteriorNode || node == NodeType::GML_ExteriorNode) {
return true;
}
return GMLObjectElementParser::parseChildElementEndTag(node, characters);
}
Object* PolygonElementParser::getObject()
{
return m_model.get();
}
void PolygonElementParser::parseRingElement(bool interior)
{
setParserForNextElement(new LinearRingElementParser(m_documentParser, m_factory, m_logger, interior, [this](LinearRing* ring){
m_model->addRing(ring);
}));
}
}
void insert(const FloatReg& reg){
float_registers.insert(reg);
}
static bool allow_ext_entity_protocol(const String& protocol) {
return s_ext_entity_whitelist.count(protocol.get());
}
void erase(const FloatReg& reg){
float_registers.erase(reg);
}
box ncbt_icp::solve(box b, contractor & ctc, SMTConfig & config) {
thread_local static std::unordered_set<std::shared_ptr<constraint>> used_constraints;
used_constraints.clear();
static unsigned prune_count = 0;
thread_local static vector<box> box_stack;
box_stack.clear();
box_stack.push_back(b);
do {
// Loop Invariant
DREAL_LOG_INFO << "ncbt_icp::solve - loop"
<< "\t" << "box stack Size = " << box_stack.size();
b = box_stack.back();
try {
ctc.prune(b, config);
auto const this_used_constraints = ctc.used_constraints();
used_constraints.insert(this_used_constraints.begin(), this_used_constraints.end());
if (config.nra_use_stat) { config.nra_stat.increase_prune(); }
} catch (contractor_exception & e) {
// Do nothing
}
prune_count++;
box_stack.pop_back();
if (!b.is_empty()) {
// SAT
tuple<int, box, box> splits = b.bisect(config.nra_precision);
if (config.nra_use_stat) { config.nra_stat.increase_branch(); }
int const index = get<0>(splits);
if (index >= 0) {
box const & first = get<1>(splits);
box const & second = get<2>(splits);
assert(first.get_idx_last_branched() == index);
assert(second.get_idx_last_branched() == index);
if (second.is_bisectable()) {
box_stack.push_back(second);
box_stack.push_back(first);
} else {
box_stack.push_back(first);
box_stack.push_back(second);
}
} else {
break;
}
} else {
// UNSAT (b is emptified by pruning operators)
// If this bisect_var is not used in all used
// constraints, this box is safe to be popped.
thread_local static unordered_set<Enode *> used_vars;
used_vars.clear();
for (auto used_ctr : used_constraints) {
auto this_used_vars = used_ctr->get_vars();
used_vars.insert(this_used_vars.begin(), this_used_vars.end());
}
while (box_stack.size() > 0) {
int const bisect_var = box_stack.back().get_idx_last_branched();
assert(bisect_var >= 0);
// If this bisect_var is not used in all used
// constraints, this box is safe to be popped.
if (used_vars.find(b.get_vars()[bisect_var]) != used_vars.end()) {
// DREAL_LOG_FATAL << b.get_vars()[bisect_var] << " is used in "
// << *used_ctr << " and it's not safe to skip";
break;
}
// DREAL_LOG_FATAL << b.get_vars()[bisect_var] << " is not used and it's safe to skip this box"
// << " (" << box_stack.size() << ")";
box_stack.pop_back();
}
}
} while (box_stack.size() > 0);
DREAL_LOG_DEBUG << "prune count = " << prune_count;
ctc.set_used_constraints(used_constraints);
return b;
}