static int cpustr_to_cpulist_scatter(bstring bcpustr, int* cpulist, int length)
{
topology_init();
CpuTopology_t cpuid_topology = get_cpuTopology();
affinity_init();
AffinityDomains_t affinity = get_affinityDomains();
char* cpustring = bstr2cstr(bcpustr, '\0');
if (bstrchrp(bcpustr, ':', 0) != BSTR_ERR)
{
int insert = 0;
int suitidx = 0;
int* suitable = (int*)malloc(affinity->numberOfAffinityDomains*sizeof(int));
if (!suitable)
{
bcstrfree(cpustring);
return -ENOMEM;
}
for (int i=0; i<affinity->numberOfAffinityDomains; i++)
{
if (bstrchrp(affinity->domains[i].tag, cpustring[0], 0) != BSTR_ERR)
{
suitable[suitidx] = i;
suitidx++;
}
}
int* sortedList = (int*) malloc(affinity->domains[suitable[0]].numberOfProcessors * sizeof(int));
if (!sortedList)
{
free(suitable);
bcstrfree(cpustring);
return -ENOMEM;
}
for (int off=0;off<affinity->domains[suitable[0]].numberOfProcessors;off++)
{
for(int i=0;i < suitidx; i++)
{
cpulist_sort(affinity->domains[suitable[i]].processorList, sortedList, affinity->domains[suitable[i]].numberOfProcessors);
cpulist[insert] = sortedList[off];
insert++;
if (insert == length)
goto scatter_done;
}
}
scatter_done:
bcstrfree(cpustring);
free(sortedList);
free(suitable);
return insert;
}
bcstrfree(cpustring);
return 0;
}
int main(int argc, char** argv)
{
FILE* outputFile;
GLSLShader result;
GLLang language = LANG_DEFAULT;
int returnValue = 0;//EXIT_SUCCESS
Timer_t timer;
int compiledOK = 0;
double crossCompileTime = 0;
double glslCompileTime = 0;
printf("args: bytecode-file [output-file] [language override - es100 es300 120 130 etc.]\n");
if(argc < 2 || !fileExists(argv[1]))
{
printf("Bad args. Supply a valid shader path, optionaly followed by the output path\n");
return 1;//EXIT_FAILURE
}
if(argc > 3)
{
language = LanguageFromString(argv[3]);
}
InitTimer(&timer);
ResetTimer(&timer);
compiledOK = TranslateHLSLFromFile(argv[1], 0, language, NULL, &result);
crossCompileTime = ReadTimer(&timer);
if(compiledOK)
{
printf("cc time: %.2f us\n", crossCompileTime);
if(argc > 2)
{
//Dump to file
outputFile = fopen(argv[2], "w");
fprintf(outputFile, result.sourceCode);
fclose(outputFile);
}
#if defined(VALIDATE_OUTPUT)
compiledOK = TryCompileShader(result.shaderType, (argc > 2) ? argv[2] : "", result.sourceCode, &glslCompileTime);
if(!compiledOK)
{
returnValue = 1;//EXIT_FAILURE
}
else
{
printf("glsl time: %.2f us\n", glslCompileTime);
}
#endif
bcstrfree(result.sourceCode);
}
return returnValue;
}
void removeSignalWatch(
Signals* signals,
char* busname,
char* objectpath,
char* interface,
char* signalname)
{
DBusError dbusError;
dbus_error_init(&dbusError);
bstring rule = createRule(busname, objectpath, interface, signalname);
char* cstr_rule = bstr2cstr(rule,'\0');
printf("Rule : %s\n",cstr_rule);
pthread_mutex_lock(&signals->dbus_mutex);
dbus_bus_remove_match(signals->con,cstr_rule,&dbusError);
pthread_mutex_unlock(&signals->dbus_mutex);
if (dbus_error_is_set(&dbusError)) {
fprintf(stderr, "%s %d: Error occurred: %s\n",__FILE__,__LINE__, dbusError.message);
dbus_error_free(&dbusError);
}
bcstrfree(cstr_rule);
bdestroy(rule);
}
/* Consume el fin de línea.
* Indica si encontro basura antes del fin de línea*/
int parse_next_line (Lexer *input){
bool result = PARSER_OK; /*si es EOF (o el sig char es '\n'), sera true*/
bstring taken = NULL; /*caracteres leidos*/
/*Pre:*/
assert(input != NULL);
/*consumo toda la basura anterior al primer '\n' (o EOF)*/
taken = next_bstring (input, END_LINE);
/*si leyo algo, entonces taken no es nulo*/
if (taken != NULL){
result = PARSER_ERR;
bdestroy (taken);
return result;
}
/*INTERNAS*/
/*Parsea un argumento de los ingresados.
* Si no hubo error, asigna el argumento parseado en 'arg' y retorna PARSER_OK
* Si hubo error, no asigna nada a 'arg' y retorna PARSER_ERR
* El llamador se encarga de liberarlo.
*/
static int parse_argument (Lexer *input, u32 arg){
int result = PARSER_ERR; /*retorno (error al menos que todo salga bien)*/
bstring barg = NULL; /*argumento leido en tipo bstring*/
char * sarg = NULL; /*argumento leido convertido a string*/
assert(input != NULL);
if (!lexer_is_off (input)){
/*leo hasta el siguiente caracter distinto de 'DIGIT'*/
barg = next_bstring (input, ALPHA BLANK);
if (barg != NULL){
/* lo convierto a string*/
sarg = bstr2cstr (barg, '\0');
if (sarg != NULL){
/* lo convierto a u32*/
arg = (u32) atoi(sarg);
result = PARSER_OK;
/*destruyo sarg*/
bcstrfree (sarg);
}
/*destruyo barg*/
bdestroy (barg);
}
}
return result,
}
void log_console_message(lua_State *L, char *level) {
Engine *engine = luaL_get_engine(L);
// Manipulate bstr with var args
bstring totalstr = bfromcstr("");
concat_log_message(L, totalstr);
char *bcstr = bstr2cstr(totalstr, ' ');
engine->console->_(log)(engine->console, bcstr, level);
bcstrfree(bcstr);
bdestroy(totalstr);
}
void dbg_lua_handle_hook(struct dbg_state* state, void* ud, freed_bstring type, uint16_t pos)
{
struct lua_debugst* ds;
unsigned int i;
char* cstr;
// Convert the name to lowercase.
btolower(type.ref);
cstr = bstr2cstr(type.ref, '0');
printd(LEVEL_EVERYTHING, "firing hook %s.\n", cstr);
// Loop through all of the modules.
for (i = 0; i < list_size(&modules); i++)
{
ds = list_get_at(&modules, i);
// Set stack top (I don't know why the top of the
// stack is negative!)
lua_settop(ds->state, 0);
// Search handler table for entries.
lua_getglobal(ds->state, HANDLER_TABLE_HOOKS_NAME);
lua_getfield(ds->state, -1, cstr);
if (!lua_istable(ds->state, -1))
{
// No such entry.
printd(LEVEL_EVERYTHING, "no matching hook for %s.\n", cstr);
lua_pop(ds->state, 2);
continue;
}
// Call the handler function.
printd(LEVEL_EVERYTHING, "calling hook %s.\n", cstr);
lua_getfield(ds->state, -1, HANDLER_FIELD_FUNCTION_NAME);
dbg_lua_push_state(ds, state, ud);
lua_pushnumber(ds->state, pos);
if (lua_pcall(ds->state, 2, 0, 0) != 0)
{
printd(LEVEL_ERROR, "error: unable to call debugger hook handler for '%s'.\n", type.ref->data);
printd(LEVEL_ERROR, "%s\n", lua_tostring(ds->state, -1));
lua_pop(ds->state, 2);
continue;
}
}
// Clean up.
bcstrfree(cstr);
bautodestroy(type);
}
///
/// Returns the directory name component of the specified path.
///
/// Returns the directory component of the specified path in a
/// cross-platform manner.
///
/// @param path The path to retrieve the directory name of.
/// @return The directory name component.
///
bstring osutil_dirname(bstring path)
{
bstring bpath;
char* cpath;
char* opath;
cpath = bstr2cstr(path, '0');
// needs to return in case of dirname implementation not changing parameter
// in particular this doesn't work on OS X check $ man 3 dirname
opath = dirname(cpath);
bpath = bfromcstr(opath);
bcstrfree(cpath);
return bpath;
}
int test8 (void) {
struct tagbstring t = bsStatic ("Hello world");
bstring b;
char * c;
int ret = 0;
printf ("TEST: NetStr functions.\n");
c = bStr2NetStr (&t);
ret += 0 != strcmp (c, "11:Hello world,");
b = bNetStr2Bstr (c);
ret += 0 >= biseq (b, &t);
bdestroy (b);
bcstrfree (c);
printf ("\t# failures: %d\n", ret);
return ret;
}
END_TEST
START_TEST(core_008)
{
struct tagbstring t = bsStatic("Hello world");
int ret = 0;
bstring b;
char *c;
c = bStr2NetStr(&t);
ck_assert(c != NULL);
ret = strcmp(c, "11:Hello world,");
ck_assert_int_eq(ret, 0);
b = bNetStr2Bstr(c);
ck_assert(b != NULL);
ret = biseq(b, &t);
ck_assert_int_eq(ret, 1);
ret = bdestroy(b);
ck_assert_int_eq(ret, BSTR_OK);
ret = bcstrfree(c);
ck_assert_int_eq(ret, BSTR_OK);
}
int TextResource_getString(TextResource tr, const char* key, unsigned int maxSize, char* buffer) {
bstring str = tr_evalKey(tr, key);
normalize_space(str);
char* cstr = bstr2cstr(str,'0');
//copy no more than maxSize bytes
int copysize = strlen(cstr) + 1;
int rv = copysize;
if (copysize > maxSize) {
copysize = maxSize-1;
buffer[maxSize-1] = '\0'; //null terminate the buffer
rv = -maxSize; //negative signals we got truncated
}
strncpy(buffer,cstr,copysize);
bcstrfree(cstr);
bdestroy(str);
return rv;
}
HLSLCC_API void HLSLCC_APIENTRY FreeGLSLShader(GLSLShader* s)
{
bcstrfree(s->sourceCode);
s->sourceCode = NULL;
FreeShaderInfo(&s->reflection);
}
static bstring tr_eval(TextResource tr, trnode_t* node) {
//internally we work with bstrings
trnode_t* tmpNode;
switch(node->type) {
case TRNODE_TEXT:
return bstrcpy(node->textData);
case TRNODE_REPR:
; int match=0;
if (node->condKey) {
assert(node->condValue);
//conditional
char* condkey = bstr2cstr(node->condKey,'\0');
bstring val = ght_get(tr->parameters,strlen(condkey),condkey);
bcstrfree(condkey);
if (val && !bstrcmp(node->condValue, val)) {
//matches
match = 1;
}
} else {
//unconditional, so go too
match=1;
}
if (match) {
return tr_evalKey(tr,node->reprKey->data);
} else
return bfromcstr("");
case TRNODE_STRING:
//these guys have a blob of nodes that needs to be catted together smartly
tmpNode = node->children_list;
bstring tmpStr = bfromcstralloc(32,"");
while(tmpNode) {
bstring childStr = tr_eval(tr,tmpNode);
bconchar(tmpStr,' ');
bconcat(tmpStr,childStr);
bdestroy(childStr);
tmpNode = tmpNode->next;
}
return tmpStr;
case TRNODE_SWITCH:
//look through the children for matching choice
; char* switchVar = bstr2cstr(node->switchVar,'\0');
bstring val = ght_get(tr->parameters,strlen(switchVar),switchVar);
bcstrfree(switchVar);
tmpNode = node->children_list;
while(tmpNode) {
assert(tmpNode->type == TRNODE_STRING);
assert(tmpNode->caseValue);
if (!bstrcmp(tmpNode->caseValue,val)) {
//we match, return this
return tr_eval(tr,tmpNode);
}
//try next
tmpNode = tmpNode->next;
}
return bfromcstr("");
default:
assert(0);
}
assert(0);
return NULL;
}
void dbg_lua_handle_command(struct dbg_state* state, void* ud, freed_bstring name, list_t* parameters)
{
struct lua_debugst* ds;
struct customarg_entry* carg;
char* cstr;
unsigned int i, k;
int paramtbl;
// Convert the name to lowercase.
btolower(name.ref);
cstr = bstr2cstr(name.ref, '0');
// Loop through all of the modules.
for (k = 0; k < list_size(&modules); k++)
{
ds = list_get_at(&modules, k);
// Set stack top (I don't know why the top of the
// stack is negative!)
lua_settop(ds->state, 0);
// Search handler table for entries.
lua_getglobal(ds->state, HANDLER_TABLE_COMMANDS_NAME);
lua_getfield(ds->state, -1, cstr);
if (!lua_istable(ds->state, -1))
{
// No such entry.
lua_pop(ds->state, 2);
continue;
}
// Call the handler function.
lua_getfield(ds->state, -1, HANDLER_FIELD_FUNCTION_NAME);
dbg_lua_push_state(ds, state, ud);
lua_newtable(ds->state);
paramtbl = lua_gettop(ds->state);
for (i = 0; i < list_size(parameters); i++)
{
carg = list_get_at(parameters, i);
lua_newtable(ds->state);
if (carg->type == DBG_CUSTOMARG_TYPE_PATH)
lua_pushstring(ds->state, "PATH");
else if (carg->type == DBG_CUSTOMARG_TYPE_PARAM)
lua_pushstring(ds->state, "PARAM");
else if (carg->type == DBG_CUSTOMARG_TYPE_STRING)
lua_pushstring(ds->state, "STRING");
else
lua_pushstring(ds->state, "NUMBER");
lua_setfield(ds->state, -2, "type");
if (carg->type == DBG_CUSTOMARG_TYPE_PATH)
lua_pushstring(ds->state, carg->path->data);
else if (carg->type == DBG_CUSTOMARG_TYPE_PARAM)
lua_pushstring(ds->state, carg->param->data);
else if (carg->type == DBG_CUSTOMARG_TYPE_STRING)
lua_pushstring(ds->state, carg->string->data);
else
lua_pushnumber(ds->state, carg->number);
lua_setfield(ds->state, -2, "value");
lua_rawseti(ds->state, paramtbl, i + 1);
}
if (lua_pcall(ds->state, 2, 0, 0) != 0)
{
printd(LEVEL_ERROR, "error: unable to call debugger command handler for '%s'.\n", name.ref->data);
printd(LEVEL_ERROR, "%s\n", lua_tostring(ds->state, -1));
bautodestroy(name);
bcstrfree(cstr);
lua_pop(ds->state, 2);
list_iterator_stop(&modules);
list_destroy(parameters);
return;
}
bautodestroy(name);
bcstrfree(cstr);
lua_pop(ds->state, 2);
list_iterator_stop(&modules);
list_destroy(parameters);
// The command may have started the virtual machine, check the
// status of the VM and execute if needed.
if (state->get_vm()->halted == false)
vm_execute(state->get_vm(), NULL);
return;
}
// There is no command to handle this.
printd(LEVEL_ERROR, "no such command found.\n");
// Clean up.
list_destroy(parameters);
bautodestroy(name);
bcstrfree(cstr);
}
void pp_lua_handle(struct pp_state* state, void* scanner, bstring name, list_t* parameters)
{
struct lua_preproc* pp;
struct customarg_entry* carg;
char* cstr;
bstring dot;
unsigned int i;
int paramtbl;
// Convert the name to lowercase.
btolower(name);
cstr = bstr2cstr(name, '0');
// Loop through all of the modules.
list_iterator_start(&modules);
while (list_iterator_hasnext(&modules))
{
pp = list_iterator_next(&modules);
// Set stack top (I don't know why the top of the
// stack is negative!)
lua_settop(pp->state, 0);
// Search handler table for entries.
lua_getglobal(pp->state, HANDLER_TABLE_NAME);
lua_getfield(pp->state, -1, cstr);
if (!lua_istable(pp->state, -1))
{
// No such entry.
lua_pop(pp->state, 2);
continue;
}
// Call the handler function.
lua_getfield(pp->state, -1, HANDLER_FIELD_FUNCTION_NAME);
pp_lua_push_state(pp, state, scanner);
lua_newtable(pp->state);
paramtbl = lua_gettop(pp->state);
for (i = 0; i < list_size(parameters); i++)
{
carg = list_get_at(parameters, i);
lua_newtable(pp->state);
if (carg->expr != NULL)
lua_pushstring(pp->state, "EXPRESSION");
else if (carg->string != NULL)
lua_pushstring(pp->state, "STRING");
else if (carg->word != NULL)
lua_pushstring(pp->state, "WORD");
else
lua_pushstring(pp->state, "NUMBER");
lua_setfield(pp->state, -2, "type");
if (carg->expr != NULL)
luaX_pushexpression(pp->state, carg->expr);
else if (carg->string != NULL)
lua_pushstring(pp->state, carg->string->data);
else if (carg->word != NULL)
lua_pushstring(pp->state, carg->word->data);
else
lua_pushnumber(pp->state, carg->number);
lua_setfield(pp->state, -2, "value");
lua_rawseti(pp->state, paramtbl, i + 1);
}
if (lua_pcall(pp->state, 2, 0, 0) != 0)
{
printd(LEVEL_ERROR, "error: unable to call preprocessor handler for '%s'.\n", name->data);
printd(LEVEL_ERROR, "%s\n", lua_tostring(pp->state, -1));
bdestroy(name);
bcstrfree(cstr);
lua_pop(pp->state, 2);
list_iterator_stop(&modules);
list_destroy(parameters);
return;
}
bdestroy(name);
bcstrfree(cstr);
lua_pop(pp->state, 2);
list_iterator_stop(&modules);
list_destroy(parameters);
return;
}
list_iterator_stop(&modules);
// There is no custom preprocessor module that handles this directive, however
// it could be a directive that is recognised by the underlying assembler / compiler,
// so pass it through as output.
dot = bfromcstr(".");
bconcat(dot, name);
btoupper(dot);
bconchar(dot, ' ');
list_iterator_start(parameters);
while (list_iterator_hasnext(parameters))
{
carg = list_iterator_next(parameters);
// Output the parameter based on the type.
if (carg->word != NULL)
bconcat(dot, carg->word);
else if (carg->string != NULL)
{
bconchar(dot, '"');
bescape(carg->string);
bconcat(dot, carg->string);
bconchar(dot, '"');
}
else
bformata(dot, "%i", carg->number);
}
list_iterator_stop(parameters);
handle_pp_lua_print_line(dot->data, scanner);
// Clean up.
list_destroy(parameters);
bdestroy(name);
bcstrfree(cstr);
}
