Bool CCompiler::RunPreCompileStep( )
{
CL_TRACE("Enter CCompiler::RunPreCompileStep");
//if( !CopyCppFile() )
//{
// CL_ERROR("failed to copy cpp files");
// return false;
//}
if( !CopySourceCode( m_sourceCodeToCompile ) )
{
CL_ERROR("failed to copy source");
return false;
}
// delete output file to have a clean compile log
CPath::DeleteFile( m_compilerOutputFile );
CString pathToSettupBat;
if( !ThGetEnvVariable(ms_vsEnvToolsVar, pathToSettupBat) )
{
CL_ERROR("failed to get path to settup bat from env variable:[%s]", ms_vsEnvToolsVar );
return false;
}
CString vsSettupCommand = "call \"" + pathToSettupBat + ms_vsSetupBat + "\"";
if( !RunCommand(vsSettupCommand) )
{
return false;
}
return true;
}
void smts_client_send_preview_res(smts_client_t *client, int status)
{
int r = status;
if (client->status == SMTS_CLIENT_ON_INIT) {
preview_cmd_res_t *preview_res = (preview_cmd_res_t*) malloc(sizeof(preview_cmd_res_t));
preview_cmd_res_t_init(preview_res);
preview_res->status = r;
preview_res->Hue = 0;
preview_res->brightness = 0;
preview_res->contrast = 0;
preview_res->saturation = 0;
// preview_cmd_res_t_bufs_alloc(preview_res);
proto_cmd_t_encode((abstract_cmd_t*) preview_res);
client->status = SMTS_CLIENT_ON_SEND_PREVIEW_RES; // to avoid repeat send preview response
r = tcp_client_send_msg((abstract_tcp_client_t*) client, (abstract_cmd_t*) preview_res,
on_smts_client_send_preview_res_cb_slient);
if (r != 0) {
CL_ERROR("send preview res error:%d,%s.\n", r, smts_strerror(r));
proto_cmd_t_destroy((abstract_cmd_t*) preview_res);
//TODO: send error;
}
}
if (r != 0) {
CL_ERROR("send preview response error:%d,%s\n", r, smts_strerror(r));
stop_smts_client(client, r);
}
return;
}
Bool CCompiler::CopySourceCode( const CString& sourceCode )
{
if( sourceCode.GetLenght() == 0 )
{
CL_ERROR("source code is empty");
return false;
}
FileSystem::FileHandle targetFile = FileSystem::CreateFile( EFileType::E_FILE_TYPE_MEMORY );
CString targetFilePath = GetSolutionCppFile();
if( !CPath::FileExists(targetFilePath) )
{
CL_ERROR( "target file:[%s] does not exists", targetFilePath.GetBuffer() );
return false;
}
if( !targetFile->Open( targetFilePath, EAccesMode::E_ACCES_MODE_WRITE ) )
{
CL_ERROR( "failed to open target file:[%s]", targetFilePath.GetBuffer() );
return false;
}
if( !targetFile->Write( sourceCode.GetBuffer(), sourceCode.GetLenght(), 1 ) )
{
CL_ERROR("failed to write to target file:[%s]", targetFilePath.GetBuffer() );
return false;
}
return true;
}
void CMakeHelpTab::LoadData(bool force)
{
// Thread is busy
if(GetThread() && GetThread()->IsRunning()) {
return;
}
// Invalid cmake executable
wxASSERT(m_plugin->GetCMake());
if(!m_plugin->GetCMake()->IsOk()) {
return;
}
m_force = force;
// Create a new joinable thread
if(CreateThread(wxTHREAD_JOINABLE) != wxTHREAD_NO_ERROR) {
CL_ERROR("Could not create the worker thread!");
return;
}
// For sure :)
wxASSERT(GetThread());
// Run the thread
if(GetThread()->Run() != wxTHREAD_NO_ERROR) {
CL_ERROR("Could not run the worker thread!");
return;
}
}
AverageVelocityCalculator::AverageVelocityCalculator( const Logger* logger,
Profiler* profiler,
const Context* context,
size_t threadCount,
size_t workGroupSize,
cl_uint bufferSideLength,
GLsizeiptr bufferByteSize)
: SharedBufferCalculator( logger,
profiler,
context,
threadCount,
workGroupSize,
0,
bufferSideLength,
bufferByteSize,
"src/kernels/averageVelocity.cl",
GL_RGBA32F)
{
// Create kernels
cl_int status;
kernelAverageVelocity = clCreateKernel(program->getProgram(), "averageVelocity", &status);
CL_ERROR(status);
// Set kernel arguments
CL_ERROR( clSetKernelArg(kernelAverageVelocity, 0, sizeof(bufferSideLength), &bufferSideLength) );
kernelAverageVelocityProfilingId = profiler->registerElement(PROFILING_ELEMENT_NAME);
}
WorkItemCalculator::WorkItemCalculator( const Logger* logger,
Profiler* profiler,
const Context* context,
size_t threadCount,
size_t workGroupSize,
cl_uint bufferSideLength,
GLsizeiptr bufferByteSize,
cl_uint workGroupSideLength)
: SharedBufferCalculator( logger,
profiler,
context,
threadCount,
workGroupSize,
1,
bufferSideLength,
bufferByteSize,
"src/kernels/workItems.cl",
GL_R32F),
kernelWorkItems(NULL)
{
// Create kernels
cl_int status;
kernelWorkItems = clCreateKernel(program->getProgram(), "workItems", &status);
CL_ERROR(status);
// Set kernel arguments
CL_ERROR( clSetKernelArg(kernelWorkItems, 0, sizeof(bufferSideLength), &bufferSideLength) );
CL_ERROR( clSetKernelArg(kernelWorkItems, 1, sizeof(workGroupSideLength), &workGroupSideLength) );
}
static int mock_dvr_dispatch_packet(abstract_tcp_client_t *client, uv_buf_t *buf, int status)
{
int r;
test_mock_dvr_t* dvr = (test_mock_dvr_t*) client;
if (status == 0) {
int32_t cmd = decode_int32(buf->base + 4);
CL_DEBUG("mock dvr recv cmd:0x%x\n",cmd);
switch (cmd) {
// PROTOCOL_MAP(GEN_DISPATCH_SWTICH_CASE, GEN_SWITCH_CASE_ARGS, GEN_SWITCH_CASE_3ARGS)
case 0x00018001: {
mock_dvr_preview_t *t = (mock_dvr_preview_t*) malloc(sizeof(mock_dvr_preview_t));
r = mock_dvr_preview_t_init(t);
r = proto_cmd_t_decode(buf, (abstract_cmd_t*) t);
if (r != 0) {
printf("decode packet:%s error.\n", "mock_dvr_preview");
} else {
/*callback fun */
cmd_imp f = (mock_dvr_preview_impl) == ((void*) 0) ? fun_no_impl : (mock_dvr_preview_impl);
f(client, (abstract_cmd_t*) t);
}
proto_cmd_t_destroy((abstract_cmd_t*) t);
}
break;
default:
CL_ERROR("mock dvr ignore cmd:%x.\n", cmd);
FREE(buf->base);
}
} else {
CL_ERROR("connect to dvr error:%d,%s\n", status, smts_strerror(status));
tcp_client_read_stop((abstract_tcp_client_t*) dvr);
// destroy_test_mock_dvr(dvr, status);
}
return r;
}
Bool CCompiler::OnCompileFail( )
{
CL_TRACE("Enter CCompiler::OnCompileFail");
FileSystem::FileHandle compileLogFile = FileSystem::CreateFile(EFileType::E_FILE_TYPE_MEMORY);
if( !compileLogFile->Open( m_compilerOutputFile, EAccesMode::E_ACCES_MODE_READ ) )
{
CL_ERROR( "failed to open file:[%s]", m_compilerOutputFile.GetBuffer() );
return false;
}
u64 fileSize = compileLogFile->GetSize();
CString fileContent;
fileContent.Resize(fileSize);
if( !compileLogFile->Read( fileContent.GetBuffer(), fileSize, 1 ) )
{
CL_ERROR( "failed to read file content for:[%s]" ,m_compilerOutputFile.GetBuffer() );
return false;
}
#define COMPILER_USE_FULL_DEVENV_OUTPUT
#if !defined(COMPILER_USE_FULL_DEVENV_OUTPUT)
//replace CompilerDummy.cpp with our file
CString slnCppFileName = GetSolutionCppFileRaw();
CString sourceFileName = "CodSursa.cpp";
CRegex regexReplace( slnCppFileName );
fileContent = regexReplace.Replace( fileContent, sourceFileName);
CL_TRACE("fileContent:\n[%s]\n=======================", fileContent.GetBuffer());
//CL_ERROR("fileContent:\n[%s]\n=======================", fileContent.GetBuffer());
const CString regexString = sourceFileName + "\\([0-9]+\\):.*error C[0-9]+:[^\n]*";
CRegex errorRegex( regexString, true );
CRegex::TCaptures errors;
if( !errorRegex.Find( fileContent, errors ) )
{
CL_ERROR( "failed to find errors in file:[%s]",m_compilerOutputFile.GetBuffer() );
return false;
}
for( u64 i=0; i<errors.GetSize(); i++ )
{
const CString& error = errors[i];
m_compileErrors += error;
}
#else
m_compileErrors = fileContent;
#endif //COMPILER_USE_FULL_DEVENV_OUTPUT
return true; // The OnCompileFailed step succeeded;
}
/* main:
*/
gint main ( gint argc,
gchar **argv )
{
Parser *parser;
FILE *infile = NULL;;
gboolean close_infile;
AST *ast;
Dumper *dumper;
gint a;
gchar *srcdir = ".";
gchar *incsubdir = "";
/* CL_DEBUG("hello!"); */
/* command line */
for (a = 1; a < argc; a++)
{
if (!strcmp(argv[a], "-s"))
{
a++;
ASSERT(a < argc);
srcdir = argv[a];
}
else if (!strcmp(argv[a], "-u"))
{
a++;
ASSERT(a < argc);
incsubdir = argv[a];
}
else
{
ASSERT(!infile);
if (!(infile = fopen(argv[a], "r")))
CL_ERROR("could not open '%s' : %s", argv[a], strerror(errno));
close_infile = TRUE;
}
}
if (!infile)
{
infile = stdin;
close_infile = FALSE;
}
/* parse */
parser = parser_new();
if (!(ast = parser_parse(parser, infile)))
CL_ERROR("parse error");
if (close_infile)
fclose(infile);
/* dump */
dumper = dumper_new(srcdir, incsubdir);
dumper_dump(dumper, ast);
dumper_write(dumper);
return 0;
}
/**
* inherit from {@link uv_alloc_cb}
*/
static void tcp_client_alloc_cb(uv_handle_t* handle, size_t size, uv_buf_t* buf)
{
// CL_DEBUG("read freame alloc.\n");
if (size > 0) {
abstract_tcp_client_t *client = (abstract_tcp_client_t*) handle->data;
client_read_tmp_buf_t *packet = &client->recv_tmp_buf;
if (packet->offset < PACKET_LEN_FIELD_SIZE) {
buf->base = (char*) &packet->packet_len + packet->offset;
buf->len = PACKET_LEN_FIELD_SIZE - packet->offset;
} else if (packet->offset == PACKET_LEN_FIELD_SIZE) {
// read packet body.
int32_t packet_len = decode_int32(buf->base);
if (packet_len <= PACKET_LEN_FIELD_SIZE || packet_len > MAX_PACKET_LEN) {
// packet invalid, close handle in read_cb.
CL_ERROR("invalide packet len:%d.\n", packet_len);
packet->packet_len = PACKET_INVALID;
buf->base = NULL;
buf->len = 0;
} else {
packet->packet_len = packet_len;
packet->buf.base = (char*) malloc(packet->packet_len);
packet->buf.len = packet_len;
encode_int32(packet->buf.base, 0, packet_len);
buf->base = packet->buf.base + PACKET_LEN_FIELD_SIZE;
buf->len = packet_len - PACKET_LEN_FIELD_SIZE;
}
} else {
//continue read body.
buf->base = packet->buf.base + packet->offset;
buf->len = packet->packet_len - packet->offset;
}
}
}
const std::vector<cl_uint> AgentMover::getAgentCounts() const
{
cl_int status;
cl_uint* buffer = static_cast<cl_uint*> ( clEnqueueMapBuffer(context->queue,
agentCounts,
CL_TRUE,
CL_MAP_READ,
0,
sizeof(cl_uint) * 8,
0,
NULL,
NULL,
&status) );
CL_ERROR(status);
std::vector<cl_uint> agentCountsVector(8);
cl_uint i = 0;
std::vector<cl_uint>::iterator iterator;
for (iterator = agentCountsVector.begin(); iterator != agentCountsVector.end(); ++iterator)
{
*iterator = buffer[i];
i++;
}
clEnqueueUnmapMemObject(context->queue, agentCounts, buffer, 0, NULL, NULL);
return agentCountsVector;
}
/**
* start preview.
*/
int smts_start_preview(abstract_tcp_client_t* aclient, abstract_cmd_t *preview_cmd)
{
preview_cmd_t *play_cmd = (preview_cmd_t*) preview_cmd;
smts_client_t *client = (smts_client_t*) aclient;
play_cmd_t play;
int r;
play.dvr_id = play_cmd->dvr_id;
play.channel_no = play_cmd->channel_no;
play.frame_mode = play_cmd->frame_mode;
CL_DEBUG("dispatch preview play cmd:{%lld,%d,%d}.\n", play.dvr_id, play.channel_no, play.frame_mode);
r = media_client_start_preview(client, &play);
if (r != 0) {
preview_cmd_res_t *preview_res;
CL_ERROR("start preview error:%d,%s\n", r, smts_strerror(r));
preview_res = (preview_cmd_res_t*) malloc(sizeof(preview_cmd_res_t));
preview_cmd_res_t_init(preview_res);
preview_res->status = r;
preview_res->Hue = 0;
preview_res->brightness = 0;
preview_res->contrast = 0;
preview_res->saturation = 0;
proto_cmd_t_encode((abstract_cmd_t*) preview_res);
r = tcp_client_send_msg((abstract_tcp_client_t*) aclient, (abstract_cmd_t*) preview_res,
on_smts_client_send_error_preview_res_cb);
if (r != 0) {
proto_cmd_t_destroy((abstract_cmd_t*)preview_res);
}
}
return r;
}
/* _on_unrealize:
*/
static void _on_unrealize ( AltkWidget *widget )
{
if (!ALTK_WIDGET_NOWINDOW(widget))
CL_ERROR("[TODO]");
widget->window = NULL;
widget->flags &= ~ALTK_WIDGET_FLAG_REALIZED;
}
void AgentMover::setAgentCounts(const std::vector<cl_uint>& agentCountsVector)
{
cl_int status;
cl_uint* buffer = static_cast<cl_uint*> ( clEnqueueMapBuffer(context->queue,
agentCounts,
CL_TRUE,
CL_MAP_WRITE,
0,
sizeof(cl_uint) * 8,
0,
NULL,
NULL,
&status) );
CL_ERROR(status);
cl_uint i = 0;
std::vector<cl_uint>::const_iterator iterator;
for (iterator = agentCountsVector.begin(); iterator != agentCountsVector.end(); ++iterator)
{
buffer[i] = *iterator;
i++;
}
clEnqueueUnmapMemObject(context->queue, agentCounts, buffer, 0, NULL, NULL);
}
static void dvr_send_frame0(uv_timer_t* handle)
{
test_mock_dvr_t *dvr = (test_mock_dvr_t*) handle->data;
int r = 0;
mock_dvr_frame_t *frame = (mock_dvr_frame_t*) malloc(sizeof(mock_dvr_frame_t));
mock_dvr_frame_t_init(frame);
frame->seqno = dvr->seqno;
if (dvr->seqno % IFRAME_INTERVAL_NUM == 0) {
/// send i frame.
frame->frame_type = FRAME_TYPE_INDEX;
frame->frame.base = dvr->iframe_bin.base;
frame->frame.len = dvr->iframe_bin.len;
} else {
/// send p frame.
frame->frame_type = FRAME_TYPE_PB;
frame->frame.base = dvr->frame_bin.base;
frame->frame.len = dvr->frame_bin.len;
}
frame->st = dvr->seqno * dvr->interval;
// CL_DEBUG("mock dvr send frame:%d\n",frame->seqno);
assert(0 == proto_cmd_t_encode((abstract_cmd_t* )frame));
r = tcp_client_send_msg((abstract_tcp_client_t*) dvr, (abstract_cmd_t*) frame, on_mock_dvr_send_frame_cb);
if (r != 0) {
CL_ERROR("mock dvr send frame error:%d,%s\n", r, smts_strerror(r));
proto_cmd_t_destroy((abstract_cmd_t*) frame);
destroy_test_mock_dvr(dvr, r);
}
dvr->seqno++;
}
wxString ValgrindMemcheckProcessor::GetExecutionCommand(const wxString & originalCommand)
{
//CL_DEBUG1(PLUGIN_PREFIX("ValgrindMemcheckProcessor::GetExecutionCommand()"));
m_outputLogFileName = m_settings->GetValgrindSettings().GetOutputFile();
if (m_settings->GetValgrindSettings().GetOutputInPrivateFolder() && m_outputLogFileName.IsEmpty())
CL_ERROR(PLUGIN_PREFIX("Valgrind output file is not set properly. Using default - file in private folder"));
if (m_settings->GetValgrindSettings().GetOutputInPrivateFolder() || m_outputLogFileName.IsEmpty()) {
if (WorkspaceST::Get()->IsOpen())
m_outputLogFileName = wxFileName(WorkspaceST::Get()->GetPrivateFolder(),
"valgrind.memcheck.log.xml").GetFullPath();
else
m_outputLogFileName = wxFileName(wxStandardPaths::Get().GetTempDir(),
"valgrind.memcheck.log.xml").GetFullPath();
}
wxArrayString suppFiles = GetSuppressionFiles();
wxString suppresions;
for (wxArrayString::iterator it = suppFiles.begin(); it != suppFiles.end(); ++it)
suppresions.Append(wxString::Format(" %s='%s'", m_settings->GetValgrindSettings().GetSuppressionFileOption(),
*it));
return wxString::Format("%s %s %s %s %s %s",
m_settings->GetValgrindSettings().GetBinary(),
m_settings->GetValgrindSettings().GetMandatoryOptions(),
wxString::Format("%s='%s'",
m_settings->GetValgrindSettings().GetOutputFileOption(),
m_outputLogFileName),
suppresions,
m_settings->GetValgrindSettings().GetOptions(),
originalCommand);
}
unsigned int MemCheckOutputView::GetColumnByName(const wxString& name)
{
for(unsigned int i = 0; i < m_dataViewCtrlErrors->GetColumnCount(); i++)
if(m_dataViewCtrlErrors->GetColumn(i)->GetTitle().IsSameAs(name, false)) return i;
CL_ERROR(PLUGIN_PREFIX("Column named '%s' not found.", name));
return -1;
}
/* altk_container_remove:
*/
void altk_container_remove ( AltkContainer *cont,
AltkWidget *child )
{
if (!ALTK_CONTAINER_GET_CLASS(cont)->remove)
CL_ERROR("%s.remove() is not implemented",
l_object_class_name(L_OBJECT_GET_CLASS(cont)));
ALTK_CONTAINER_GET_CLASS(cont)->remove(cont, child);
}
void AverageVelocityCalculator::compute(bool isProfiling, cl_mem densityDiscomfortVelocity)
{
cl_int status;
cl_command_queue queue = context->queue;
status = clEnqueueAcquireGLObjects(queue, 1, &densityDiscomfortVelocity, 0, NULL, NULL);
CL_ERROR(status);
CL_ERROR( clSetKernelArg(kernelAverageVelocity, 1, sizeof(cl_mem), &densityDiscomfortVelocity) );
CL_PROFILE(kernelAverageVelocityProfilingId, isProfiling, queue,
CL_ERROR( clEnqueueNDRangeKernel(queue, kernelAverageVelocity, 1, NULL, &threadCount, &workGroupSize, 0, NULL, &event) )
);
status = clEnqueueReleaseGLObjects(queue, 1, &densityDiscomfortVelocity, 0, NULL, NULL);
CL_ERROR(status);
}
static void _add_option ( char **cmdline,
const char *option )
{
int count;
for (count = 0; cmdline[count]; count++);
if (count >= (MAXCMDLINE-1))
CL_ERROR("MAXCMDLINE reached");
cmdline[count++] = strdup(option);
cmdline[count] = NULL;
}
/* altk_widget_get_shape:
*/
AltkRegion *altk_widget_get_shape ( AltkWidget *widget )
{
CL_ERROR("[TODO] altk_widget_get_shape() is deprecated");
return NULL;
/* AltkRectangle r; */
/* r.x = r.y = 0; */
/* r.width = widget->width; */
/* r.height = widget->height; */
/* return altk_region_rectangle(&r); */
}
static void on_smts_client_send_frame_cb(abstract_tcp_client_t *aclient, abstract_cmd_t *packet, int status)
{
smts_client_t *client = (smts_client_t*) aclient;
smts_frame_res_t *frame = (smts_frame_res_t*) packet;
on_smts_client_send_frame(client->session, client, frame);
if (status != 0) {
CL_ERROR("send frame error:%d,%s\n", status, smts_strerror(status));
stop_smts_client(client, status);
}
}
void client_on_connection(uv_stream_t* server, int status)
{
smts_client_t *smts_client = (smts_client_t*) malloc(sizeof(smts_client_t));
uv_tcp_t* socket;
int r;
init_smts_client(smts_client, server->loop);
socket = &smts_client->socket;
r = uv_accept(server, (uv_stream_t*) socket);
if (r != 0) {
CL_ERROR("accept error:%d,%s\n", r, smts_strerror(r));
close_abstract_tcp_client((abstract_tcp_client_t*) smts_client, socket_close_cb);
return;
}
CL_DEBUG("new client fd:%d connection.\n", socket->io_watcher.fd);
r = tcp_client_start_read((abstract_tcp_client_t*) smts_client, dispatch_packet);
if (r != 0) {
CL_ERROR("start read error:%d,%s\n", r, smts_strerror(r));
close_abstract_tcp_client((abstract_tcp_client_t*) smts_client, socket_close_cb);
return;
}
}
/**
* inheril from {@link uv_connection_cb}
*/
static void on_mock_dvr_connect_cb(uv_stream_t* server, int status)
{
test_mock_dvr_t *dvr = (test_mock_dvr_t*) malloc(sizeof(test_mock_dvr_t));
uv_tcp_t* socket;
int r;
init_test_mock_dvr(dvr, server->loop);
socket = &dvr->socket;
r = uv_accept(server, (uv_stream_t*) socket);
if (r != 0) {
CL_ERROR("accept error:%d,%s\n", r, smts_strerror(r));
close_abstract_tcp_client((abstract_tcp_client_t*) dvr, mock_dvr_close_cb);
return;
}
CL_DEBUG("new client fd:%d connection.\n", socket->io_watcher.fd);
r = tcp_client_start_read((abstract_tcp_client_t*) dvr, mock_dvr_dispatch_packet);
if (r != 0) {
CL_ERROR("start read error:%d,%s\n", r, smts_strerror(r));
close_abstract_tcp_client((abstract_tcp_client_t*) dvr, mock_dvr_close_cb);
return;
}
}
static void on_mock_dvr_send_frame_cb(abstract_tcp_client_t *aclient, abstract_cmd_t *packet, int status)
{
// mock_dvr_frame_t *frame = (mock_dvr_frame_t*) packet;
// CL_DEBUG("free mock dvr frame:%d\n", frame->seqno);
proto_cmd_t_destroy(packet);
if (status != 0) {
test_mock_dvr_t *dvr;
CL_ERROR("mock dvr send frame error:%d,%s\n", status, smts_strerror(status));
dvr = (test_mock_dvr_t*) aclient;
destroy_test_mock_dvr(dvr, status);
}
}
void WorkItemCalculator::compute()
{
cl_int status;
//
// Compute gradient
//
cl_command_queue queue = context->queue;
status = clEnqueueAcquireGLObjects(queue, 1, &sharedTextureBuffers[0], 0, NULL, NULL);
CL_ERROR(status);
CL_ERROR( clSetKernelArg(kernelWorkItems, 2, sizeof(cl_mem), &sharedTextureBuffers[0] ) );
CL_ERROR( clEnqueueNDRangeKernel(queue, kernelWorkItems, 1, NULL, &threadCount, &workGroupSize, 0, NULL, NULL) );
status = clEnqueueReleaseGLObjects(queue, 1, &sharedTextureBuffers[0], 0, NULL, NULL);
CL_ERROR(status);
clReleaseKernel(kernelWorkItems);
kernelWorkItems = NULL;
}
TVec4& TVec4::MakeUnit(int n, TVReal k)
{
if (n == 0)
{ elt[0] = k; elt[1] = vl_zero; elt[2] = vl_zero; elt[3] = vl_zero; }
else if (n == 1)
{ elt[0] = vl_zero; elt[1] = k; elt[2] = vl_zero; elt[3] = vl_zero; }
else if (n == 2)
{ elt[0] = vl_zero; elt[1] = vl_zero; elt[2] = k; elt[3] = vl_zero; }
else if (n == 3)
{ elt[0] = vl_zero; elt[1] = vl_zero; elt[2] = vl_zero; elt[3] = k; }
else
CL_ERROR("(Vec4::MakeUnit) illegal unit vector");
return SELF;
}
int tcp_client_connect(abstract_tcp_client_t *client, char *ip, int32_t port, tcp_client_connect_cb connect_cb)
{
int r = 0;
char *local_ip;
client_connect_req_t *req = (client_connect_req_t*) malloc(sizeof(client_connect_req_t));
struct sockaddr_in addr;
r = uv_tcp_init(client->loop, &client->socket);
local_ip = smts_get_one_addrs();
if (local_ip == NULL) {
r = NET_ADDR_NOT_FOUND;
CL_ERROR("get local addr error:%d,%s.\n", r, smts_strerror(r));
return r;
}
r = uv_ip4_addr(local_ip, 0, &addr);
if (r != 0) {
CL_ERROR("uv_ip4_addr error\n");
return r;
}
r = uv_tcp_bind(&client->socket, (struct sockaddr *) &addr, 0);
if (r != 0) {
CL_ERROR("bind ip:%s error:%d,%s\n", ip, r, smts_strerror(r));
return r;
}
CL_DEBUG("bind local addr:%s .\n", local_ip);
r = uv_ip4_addr(ip, port, &client->addr);
if (r != 0) {
CL_ERROR("uv_ip4_addr error\n");
return r;
}
req->client = client;
req->req.data = req;
req->cb = connect_cb;
r = uv_tcp_connect(&req->req, &client->socket, (const struct sockaddr*) &client->addr, on_tcp_client_connect_cb);
return r;
}
/* filecmp:
*/
static gint filecmp ( const gchar *fname1,
const gchar *fname2 )
{
struct stat s1, s2;
GMappedFile *m1, *m2;
gint r;
GError *error = NULL;
if (stat(fname1, &s1) != 0)
CL_ERROR("could not stat '%s' : %s", fname1, strerror(errno));
if (stat(fname2, &s2) != 0)
CL_ERROR("could not stat '%s' : %s", fname2, strerror(errno));
if (s1.st_size != s2.st_size)
return 1;
if (!(m1 = g_mapped_file_new(fname1, FALSE, &error)))
CL_ERROR("could not open '%s' : %s", fname1, error->message);
if (!(m2 = g_mapped_file_new(fname2, FALSE, &error)))
CL_ERROR("could not open '%s' : %s", fname2, error->message);
r = memcmp(g_mapped_file_get_contents(m1),
g_mapped_file_get_contents(m2),
s1.st_size);
g_mapped_file_unref(m1);
g_mapped_file_unref(m2);
return r;
}
/* _seek:
*/
static void _seek ( LStream *stream,
gint64 offset,
LStreamSeekType whence )
{
#define m (L_MEM_STREAM(stream))
switch (whence)
{
case L_STREAM_SEEK_SET:
ASSERT(offset >= 0 && offset <= m->data_size); /* [fixme] clamp ? */
m->pos = offset;
break;
default:
CL_ERROR("[TODO] seek(whence=%d)", whence);
}
#undef m
}
