void ModulePromGroup::process_cross_script_links() {
GroupPromScript* script_dst = get_script();
GroupPromScript* script_src = get_script();
for(uint i=0; i<in_links.size(); i++) {
GroupPromScript* script_src = ((ModulePromGroup*)in_links[i]->src)->get_script();
if(script_src == script_dst) continue;
group->project->process_cross_script_link((LinkPromLink*)in_links[i]);
}
for(uint i=0; i<out_links.size(); i++) {
GroupPromScript* script_dst = ((ModulePromGroup*)out_links[i]->dst)->get_script();
if(script_src == script_dst) continue;
group->project->process_cross_script_link((LinkPromLink*)out_links[i]);
}
}
bool MultiScript::_get(const StringName& p_name,Variant &r_ret) const{
_THREAD_SAFE_METHOD_
String s = String(p_name);
if (s.begins_with("script_")) {
int idx = s[7];
if (idx==0)
return false;
idx-='a';
ERR_FAIL_COND_V(idx<0,false);
if (idx<scripts.size()) {
r_ret=get_script(idx);
return true;
} else if (idx==scripts.size()) {
r_ret=Ref<Script>();
return true;
}
}
return false;
}
void TestTaskManager::sleep_cancel()
{
// Set up the manager.
TaskManager *manager = new TaskManager();
QSignalSpy sig_message(manager, SIGNAL(message(QString, QString)));
// Set up a task.
TarsnapTask *task = new TarsnapTask();
QSignalSpy sig_started(task, SIGNAL(started(QVariant)));
task->setCommand("/bin/sh");
task->setArguments(QStringList(get_script("sleep-9-exit-0.sh")));
task->setData(QString("started-9"));
// Start running it, wait a second.
manager->startTask(task);
QTest::qWait(1000);
QVERIFY(sig_started.count() == 1);
QVERIFY(sig_started.takeFirst().at(0).value<QString>() == "started-9");
QVERIFY(sig_message.count() == 0);
// Cancel it
manager->stopTasks(false, true, false);
QVERIFY(sig_message.count() == 1);
QVERIFY(sig_message.takeFirst().at(0).value<QString>()
== "Stopped running tasks.");
QTest::qWait(1000);
// task is deleted by the task manager
delete manager;
}
// Sets up internal data after loading the file, based on the char
// properties. Called from load_from_file, but also needs to be run
// during set_unicharset_properties.
void UNICHARSET::post_load_setup() {
// Number of alpha chars with the case property minus those without,
// in order to determine that half the alpha chars have case.
int net_case_alphas = 0;
int x_height_alphas = 0;
int cap_height_alphas = 0;
top_bottom_set_ = false;
for (UNICHAR_ID id = 0; id < size_used; ++id) {
int min_bottom = 0;
int max_bottom = MAX_UINT8;
int min_top = 0;
int max_top = MAX_UINT8;
get_top_bottom(id, &min_bottom, &max_bottom, &min_top, &max_top);
if (min_top > 0)
top_bottom_set_ = true;
if (get_isalpha(id)) {
if (get_islower(id) || get_isupper(id))
++net_case_alphas;
else
--net_case_alphas;
if (min_top < kMeanlineThreshold && max_top < kMeanlineThreshold)
++x_height_alphas;
else if (min_top > kMeanlineThreshold && max_top > kMeanlineThreshold)
++cap_height_alphas;
}
set_normed_ids(id);
}
script_has_upper_lower_ = net_case_alphas > 0;
script_has_xheight_ = script_has_upper_lower_ ||
(x_height_alphas > cap_height_alphas * kMinXHeightFraction &&
cap_height_alphas > x_height_alphas * kMinCapHeightFraction);
null_sid_ = get_script_id_from_name(null_script);
ASSERT_HOST(null_sid_ == 0);
common_sid_ = get_script_id_from_name("Common");
latin_sid_ = get_script_id_from_name("Latin");
cyrillic_sid_ = get_script_id_from_name("Cyrillic");
greek_sid_ = get_script_id_from_name("Greek");
han_sid_ = get_script_id_from_name("Han");
hiragana_sid_ = get_script_id_from_name("Hiragana");
katakana_sid_ = get_script_id_from_name("Katakana");
// Compute default script. Use the highest-counting alpha script, that is
// not the common script, as that still contains some "alphas".
int* script_counts = new int[script_table_size_used];
memset(script_counts, 0, sizeof(*script_counts) * script_table_size_used);
for (int id = 0; id < size_used; ++id) {
if (get_isalpha(id)) {
++script_counts[get_script(id)];
}
}
default_sid_ = 0;
for (int s = 1; s < script_table_size_used; ++s) {
if (script_counts[s] > script_counts[default_sid_] && s != common_sid_)
default_sid_ = s;
}
delete [] script_counts;
}
Variant Object::get(const StringName &p_name, bool *r_valid) const {
Variant ret;
if (script_instance) {
if (script_instance->get(p_name, ret)) {
if (r_valid)
*r_valid = true;
return ret;
}
}
//try built-in setgetter
{
if (ClassDB::get_property(const_cast<Object *>(this), p_name, ret)) {
if (r_valid)
*r_valid = true;
return ret;
}
}
if (p_name == CoreStringNames::get_singleton()->_script) {
ret = get_script();
if (r_valid)
*r_valid = true;
return ret;
} else if (p_name == CoreStringNames::get_singleton()->_meta) {
ret = metadata;
if (r_valid)
*r_valid = true;
return ret;
#ifdef TOOLS_ENABLED
} else if (p_name == CoreStringNames::get_singleton()->_sections_unfolded) {
Array array;
for (Set<String>::Element *E = editor_section_folding.front(); E; E = E->next()) {
array.push_back(E->get());
}
if (r_valid)
*r_valid = true;
return array;
#endif
} else {
//something inside the object... :|
bool success = _getv(p_name, ret);
if (success) {
if (r_valid)
*r_valid = true;
return ret;
}
//if nothing else, use getvar
return getvar(p_name, r_valid);
}
}
Variant Object::get(const StringName& p_name, bool *r_valid) const{
Variant ret;
if (script_instance) {
if (script_instance->get(p_name,ret)) {
if (r_valid)
*r_valid=true;
return ret;
}
}
//try built-in setgetter
{
if (ObjectTypeDB::get_property(const_cast<Object*>(this),p_name,ret)) {
if (r_valid)
*r_valid=true;
return ret;
}
}
if (p_name==CoreStringNames::get_singleton()->_script) {
ret = get_script();
if (r_valid)
*r_valid=true;
return ret;
} else if (p_name==CoreStringNames::get_singleton()->_meta) {
ret = metadata;
if (r_valid)
*r_valid=true;
return ret;
} else {
//something inside the object... :|
bool success = _getv(p_name,ret);
if (success) {
if (r_valid)
*r_valid=true;
return ret;
}
//if nothing else, use getvar
return getvar(p_name,r_valid);
}
}
bool MaterialDescription::operator==(
const MaterialDescription &material) const
{
Uint16 i;
if (get_effect() != material.get_effect())
{
return false;
}
for (i = 0; i < material_texture_count; ++i)
{
if (get_texture(i) != material.get_texture(i))
{
return false;
}
}
for (i = 0; i < 2; ++i)
{
if (get_texture_matrix(i) !=
material.get_texture_matrix(i))
{
return false;
}
}
if (get_color() != material.get_color())
{
return false;
}
if (get_cast_shadows() != material.get_cast_shadows())
{
return false;
}
if (get_culling() != material.get_culling())
{
return false;
}
if (get_script() != material.get_script())
{
return false;
}
return get_name() == material.get_name();
}
void EditorScript::_run() {
Ref<Script> s = get_script();
ERR_FAIL_COND(!s.is_valid());
if (!get_script_instance()) {
EditorNode::add_io_error(TTR("Couldn't instance script:") + "\n " + s->get_path() + "\n" + TTR("Did you forget the 'tool' keyword?"));
return;
}
Variant::CallError ce;
ce.error = Variant::CallError::CALL_OK;
get_script_instance()->call("_run", NULL, 0, ce);
if (ce.error != Variant::CallError::CALL_OK) {
EditorNode::add_io_error(TTR("Couldn't run script:") + "\n " + s->get_path() + "\n" + TTR("Did you forget the '_run' method?"));
}
}
void MaterialDescription::save_xml(
const XmlWriterSharedPtr &writer) const
{
Uint32 i;
SamplerParameterType sampler;
writer->start_element(String(UTF8("material")));
writer->write_element(String(UTF8("name")), get_name());
writer->write_element(String(UTF8("effect")), get_effect());
writer->write_element(String(UTF8("script")), get_script());
for (i = 0; i < m_textures.size(); ++i)
{
sampler = static_cast<SamplerParameterType>(i);
writer->start_element(SamplerParameterUtil::get_str(
sampler));
writer->write_bool_property(String(UTF8("sRGB")),
get_sRGB(sampler));
writer->write_string(get_texture(sampler));
writer->end_element();
}
writer->write_mat2x3_element(String(UTF8("texture_matrix_0")),
get_texture_matrix(0));
writer->write_mat2x3_element(String(UTF8("texture_matrix_1")),
get_texture_matrix(1));
writer->write_vec4_element(String(UTF8("color")), get_color());
writer->write_vec4_element(String(UTF8("dudv_scale_offset")),
get_dudv_scale_offset());
writer->write_bool_element(String(UTF8("cast_shadows")),
get_cast_shadows());
writer->write_bool_element(String(UTF8("culling")),
get_culling());
writer->end_element();
}
static unsigned get_xml_shaders(const char *path, struct shader_program *prog, size_t size)
{
LIBXML_TEST_VERSION;
xmlParserCtxtPtr ctx = xmlNewParserCtxt();
if (!ctx)
{
RARCH_ERR("Failed to load libxml2 context.\n");
return false;
}
RARCH_LOG("Loading XML shader: %s\n", path);
xmlDocPtr doc = xmlCtxtReadFile(ctx, path, NULL, 0);
xmlNodePtr head = NULL;
xmlNodePtr cur = NULL;
unsigned num = 0;
if (!doc)
{
RARCH_ERR("Failed to parse XML file: %s\n", path);
goto error;
}
#ifdef HAVE_LIBXML2
if (ctx->valid == 0)
{
RARCH_ERR("Cannot validate XML shader: %s\n", path);
goto error;
}
#endif
head = xmlDocGetRootElement(doc);
for (cur = head; cur; cur = cur->next)
{
if (cur->type != XML_ELEMENT_NODE)
continue;
if (strcmp((const char*)cur->name, "shader") != 0)
continue;
char attr[64];
xml_get_prop(attr, sizeof(attr), cur, "language");
if (strcmp(attr, "GLSL") != 0)
continue;
xml_get_prop(attr, sizeof(attr), cur, "style");
glsl_modern = strcmp(attr, "GLES2") == 0;
if (glsl_modern)
RARCH_LOG("[GL]: Shader reports a GLES2 style shader.\n");
break;
}
if (!cur) // We couldn't find any GLSL shader :(
goto error;
memset(prog, 0, sizeof(struct shader_program) * size);
// Iterate to check if we find fragment and/or vertex shaders.
for (cur = cur->children; cur && num < size; cur = cur->next)
{
if (cur->type != XML_ELEMENT_NODE)
continue;
char *content = xml_get_content(cur);
if (!content)
continue;
if (strcmp((const char*)cur->name, "vertex") == 0)
{
if (prog[num].vertex)
{
RARCH_ERR("Cannot have more than one vertex shader in a program.\n");
free(content);
goto error;
}
content = xml_replace_if_file(content, path, cur, "src");
if (!content)
{
RARCH_ERR("Shader source file was provided, but failed to read.\n");
goto error;
}
prog[num].vertex = content;
}
else if (strcmp((const char*)cur->name, "fragment") == 0)
{
if (glsl_modern && !prog[num].vertex)
{
RARCH_ERR("Modern GLSL was chosen and vertex shader was not provided. This is an error.\n");
free(content);
goto error;
}
content = xml_replace_if_file(content, path, cur, "src");
if (!content)
{
RARCH_ERR("Shader source file was provided, but failed to read.\n");
goto error;
}
prog[num].fragment = content;
if (!get_xml_attrs(&prog[num], cur))
{
RARCH_ERR("XML shader attributes do not comply with specifications.\n");
goto error;
}
num++;
}
else if (strcmp((const char*)cur->name, "texture") == 0)
{
free(content);
if (!get_texture_image(path, cur))
{
RARCH_ERR("Texture image failed to load.\n");
goto error;
}
}
else if (strcmp((const char*)cur->name, "import") == 0)
{
free(content);
if (!get_import_value(cur))
{
RARCH_ERR("Import value is invalid.\n");
goto error;
}
}
#ifdef HAVE_PYTHON
else if (strcmp((const char*)cur->name, "script") == 0)
{
free(content);
if (!get_script(path, cur))
{
RARCH_ERR("Script is invalid.\n");
goto error;
}
}
#endif
}
if (num == 0)
{
RARCH_ERR("Couldn't find vertex shader nor fragment shader in XML file.\n");
goto error;
}
xmlFreeDoc(doc);
xmlFreeParserCtxt(ctx);
return num;
error:
RARCH_ERR("Failed to load XML shader ...\n");
if (doc)
xmlFreeDoc(doc);
xmlFreeParserCtxt(ctx);
return 0;
}
static unsigned get_xml_shaders(const char *path, struct shader_program *prog, size_t size)
{
LIBXML_TEST_VERSION;
xmlParserCtxtPtr ctx = xmlNewParserCtxt();
if (!ctx)
{
RARCH_ERR("Failed to load libxml2 context.\n");
return false;
}
RARCH_LOG("Loading XML shader: %s\n", path);
xmlDocPtr doc = xmlCtxtReadFile(ctx, path, NULL, 0);
xmlNodePtr head = NULL;
xmlNodePtr cur = NULL;
unsigned num = 0;
if (!doc)
{
RARCH_ERR("Failed to parse XML file: %s\n", path);
goto error;
}
if (ctx->valid == 0)
{
RARCH_ERR("Cannot validate XML shader: %s\n", path);
goto error;
}
head = xmlDocGetRootElement(doc);
for (cur = head; cur; cur = cur->next)
{
if (cur->type == XML_ELEMENT_NODE && strcmp((const char*)cur->name, "shader") == 0)
{
xmlChar *attr;
attr = xmlGetProp(cur, (const xmlChar*)"language");
if (attr && strcmp((const char*)attr, "GLSL") == 0)
{
xmlFree(attr);
break;
}
if (attr)
xmlFree(attr);
}
}
if (!cur) // We couldn't find any GLSL shader :(
goto error;
memset(prog, 0, sizeof(struct shader_program) * size);
// Iterate to check if we find fragment and/or vertex shaders.
for (cur = cur->children; cur && num < size; cur = cur->next)
{
if (cur->type != XML_ELEMENT_NODE)
continue;
xmlChar *content = xmlNodeGetContent(cur);
if (!content)
continue;
if (strcmp((const char*)cur->name, "vertex") == 0)
{
if (prog[num].vertex)
{
RARCH_ERR("Cannot have more than one vertex shader in a program.\n");
xmlFree(content);
goto error;
}
prog[num].vertex = (char*)content;
}
else if (strcmp((const char*)cur->name, "fragment") == 0)
{
prog[num].fragment = (char*)content;
if (!get_xml_attrs(&prog[num], cur))
{
RARCH_ERR("XML shader attributes do not comply with specifications.\n");
goto error;
}
num++;
}
else if (strcmp((const char*)cur->name, "texture") == 0)
{
if (!get_texture_image(path, cur))
{
RARCH_ERR("Texture image failed to load.\n");
goto error;
}
}
else if (strcmp((const char*)cur->name, "import") == 0)
{
if (!get_import_value(cur))
{
RARCH_ERR("Import value is invalid.\n");
goto error;
}
}
#ifdef HAVE_PYTHON
else if (strcmp((const char*)cur->name, "script") == 0)
{
if (!get_script(path, cur))
{
RARCH_ERR("Script is invalid.\n");
goto error;
}
}
#endif
}
if (num == 0)
{
RARCH_ERR("Couldn't find vertex shader nor fragment shader in XML file.\n");
goto error;
}
xmlFreeDoc(doc);
xmlFreeParserCtxt(ctx);
return num;
error:
RARCH_ERR("Failed to load XML shader ...\n");
if (doc)
xmlFreeDoc(doc);
xmlFreeParserCtxt(ctx);
return 0;
}
void
Tux::try_continue_walking(float dt_sec)
{
if (!m_moving)
return;
// Let tux walk
m_offset += TUXSPEED * dt_sec;
// Do nothing if we have not yet reached the next tile
if (m_offset <= 32)
return;
m_offset -= 32;
auto sprite_change = m_worldmap->at_sprite_change(m_tile_pos);
change_sprite(sprite_change);
// if this is a special_tile with passive_message, display it
auto special_tile = m_worldmap->at_special_tile();
if (special_tile)
{
// direction and the apply_action_ are opposites, since they "see"
// directions in a different way
if ((m_direction == Direction::NORTH && special_tile->get_apply_action_south()) ||
(m_direction == Direction::SOUTH && special_tile->get_apply_action_north()) ||
(m_direction == Direction::WEST && special_tile->get_apply_action_east()) ||
(m_direction == Direction::EAST && special_tile->get_apply_action_west()))
{
process_special_tile(special_tile);
}
}
// check if we are at a Teleporter
auto teleporter = m_worldmap->at_teleporter(m_tile_pos);
// stop if we reached a level, a WORLDMAP_STOP tile, a teleporter or a special tile without a passive_message
if ((m_worldmap->at_level()) ||
(m_worldmap->tile_data_at(m_tile_pos) & Tile::WORLDMAP_STOP) ||
(special_tile && !special_tile->is_passive_message() && special_tile->get_script().empty()) ||
(teleporter) ||
m_ghost_mode)
{
if (special_tile && !special_tile->get_map_message().empty() && !special_tile->is_passive_message()) {
m_worldmap->set_passive_message({}, 0.0f);
}
stop();
return;
}
// if user wants to change direction, try changing, else guess the direction in which to walk next
const int tile_data = m_worldmap->tile_data_at(m_tile_pos);
if ((m_direction != m_input_direction) && can_walk(tile_data, m_input_direction)) {
m_direction = m_input_direction;
m_back_direction = reverse_dir(m_direction);
} else {
Direction dir = Direction::NONE;
if (tile_data & Tile::WORLDMAP_NORTH && m_back_direction != Direction::NORTH)
dir = Direction::NORTH;
else if (tile_data & Tile::WORLDMAP_SOUTH && m_back_direction != Direction::SOUTH)
dir = Direction::SOUTH;
else if (tile_data & Tile::WORLDMAP_EAST && m_back_direction != Direction::EAST)
dir = Direction::EAST;
else if (tile_data & Tile::WORLDMAP_WEST && m_back_direction != Direction::WEST)
dir = Direction::WEST;
if (dir == Direction::NONE) {
// Should never be reached if tiledata is good
log_warning << "Could not determine where to walk next" << std::endl;
stop();
return;
}
m_direction = dir;
m_input_direction = m_direction;
m_back_direction = reverse_dir(m_direction);
}
// Walk automatically to the next tile
if (m_direction == Direction::NONE)
return;
Vector next_tile;
if (!m_ghost_mode && !m_worldmap->path_ok(m_direction, m_tile_pos, &next_tile)) {
log_debug << "Tilemap data is buggy" << std::endl;
stop();
return;
}
auto next_sprite = m_worldmap->at_sprite_change(next_tile);
if (next_sprite != nullptr && next_sprite->m_change_on_touch) {
change_sprite(next_sprite);
}
//SpriteChange* last_sprite = m_worldmap->at_sprite_change(tile_pos);
if (sprite_change != nullptr && next_sprite != nullptr) {
log_debug << "Old: " << m_tile_pos << " New: " << next_tile << std::endl;
sprite_change->set_stay_action();
}
m_tile_pos = next_tile;
}
bool MaterialDescription::operator<(const MaterialDescription &material)
const
{
glm::bvec4 cmp4;
glm::bvec3 cmp3;
Uint16 i, j;
if (get_effect() != material.get_effect())
{
return get_effect() < material.get_effect();
}
for (i = 0; i < material_texture_count; ++i)
{
if (get_texture(i) != material.get_texture(i))
{
return get_texture(i) <
material.get_texture(i);
}
}
for (i = 0; i < 2; ++i)
{
cmp3 = glm::equal(get_texture_matrix(i)[0],
material.get_texture_matrix(i)[0]);
if (glm::all(cmp3))
{
continue;
}
for (j = 0; j < 3; ++i)
{
if (cmp3[j])
{
continue;
}
return get_texture_matrix(i)[0][j] <
material.get_texture_matrix(i)[0][j];
}
cmp3 = glm::equal(get_texture_matrix(i)[1],
material.get_texture_matrix(i)[1]);
if (glm::all(cmp3))
{
continue;
}
for (j = 0; j < 3; ++i)
{
if (cmp3[j])
{
continue;
}
return get_texture_matrix(i)[1][j] <
material.get_texture_matrix(i)[1][j];
}
}
for (i = 0; i < 4; ++i)
{
if (get_color()[i] != material.get_color()[i])
{
return get_color()[i] < material.get_color()[i];
}
}
if (get_cast_shadows() != material.get_cast_shadows())
{
return get_cast_shadows() < material.get_cast_shadows();
}
if (get_culling() != material.get_culling())
{
return get_culling() < material.get_culling();
}
if (get_script() != material.get_script())
{
return get_script() < material.get_script();
}
return get_name() < material.get_name();
}
/* Insert a request in the backend */
void apm_driver_mysql_insert_request(TSRMLS_D)
{
char *script = NULL, *application_esc, *script_esc = NULL, *uri_esc = NULL, *host_esc = NULL, *cookies_esc = NULL, *post_vars_esc = NULL, *referer_esc = NULL, *sql = NULL;
unsigned int application_len = 0, script_len = 0, uri_len = 0, host_len = 0, ip_int = 0, cookies_len = 0, post_vars_len = 0, referer_len = 0;
struct in_addr ip_addr;
MYSQL *connection;
zval *tmp;
EXTRACT_DATA();
APM_DEBUG("[MySQL driver] Begin insert request\n");
if (APM_MY_G(is_request_created)) {
APM_DEBUG("[MySQL driver] SKIPPED, request already created.\n");
return;
}
MYSQL_INSTANCE_INIT
if (APM_G(application_id)) {
application_len = strlen(APM_G(application_id));
application_esc = emalloc(application_len * 2 + 1);
application_len = mysql_real_escape_string(connection, application_esc, APM_G(application_id), application_len);
}
get_script(&script);
if (script) {
script_len = strlen(script);
script_esc = emalloc(script_len * 2 + 1);
script_len = mysql_real_escape_string(connection, script_esc, script, script_len);
}
if (APM_RD(uri_found)) {
uri_len = strlen(Z_STRVAL_PP(APM_RD(uri)));
uri_esc = emalloc(uri_len * 2 + 1);
uri_len = mysql_real_escape_string(connection, uri_esc, Z_STRVAL_PP(APM_RD(uri)), uri_len);
}
if (APM_RD(host_found)) {
host_len = strlen(Z_STRVAL_PP(APM_RD(host)));
host_esc = emalloc(host_len * 2 + 1);
host_len = mysql_real_escape_string(connection, host_esc, Z_STRVAL_PP(APM_RD(host)), host_len);
}
if (APM_RD(ip_found) && (inet_pton(AF_INET, Z_STRVAL_PP(APM_RD(ip)), &ip_addr) == 1)) {
ip_int = ntohl(ip_addr.s_addr);
}
if (APM_RD(cookies_found)) {
cookies_len = strlen(APM_RD(cookies).c);
cookies_esc = emalloc(cookies_len * 2 + 1);
cookies_len = mysql_real_escape_string(connection, cookies_esc, APM_RD(cookies).c, cookies_len);
}
if (APM_RD(post_vars_found)) {
post_vars_len = strlen(APM_RD(post_vars).c);
post_vars_esc = emalloc(post_vars_len * 2 + 1);
post_vars_len = mysql_real_escape_string(connection, post_vars_esc, APM_RD(post_vars).c, post_vars_len);
}
if (APM_RD(referer_found)) {
referer_len = strlen(Z_STRVAL_PP(APM_RD(referer)));
referer_esc = emalloc(referer_len * 2 + 1);
referer_len = mysql_real_escape_string(connection, referer_esc, Z_STRVAL_PP(APM_RD(referer)), referer_len);
}
sql = emalloc(154 + application_len + script_len + uri_len + host_len + cookies_len + post_vars_len + referer_len);
sprintf(
sql,
"INSERT INTO request (application, script, uri, host, ip, cookies, post_vars, referer) VALUES ('%s', '%s', '%s', '%s', %u, '%s', '%s', '%s')",
APM_G(application_id) ? application_esc : "", script ? script_esc : "", APM_RD(uri_found) ? uri_esc : "", APM_RD(host_found) ? host_esc : "", ip_int, APM_RD(cookies_found) ? cookies_esc : "", APM_RD(post_vars_found) ? post_vars_esc : "", APM_RD(referer_found) ? referer_esc : "");
APM_DEBUG("[MySQL driver] Sending: %s\n", sql);
if (mysql_query(connection, sql) != 0)
APM_DEBUG("[MySQL driver] Error: %s\n", mysql_error(APM_MY_G(event_db)));
mysql_query(connection, "SET @request_id = LAST_INSERT_ID()");
efree(sql);
efree(script_esc);
efree(uri_esc);
efree(host_esc);
efree(cookies_esc);
efree(post_vars_esc);
efree(referer_esc);
APM_MY_G(is_request_created) = 1;
APM_DEBUG("[MySQL driver] End insert request\n");
}