/*=============================================================================
* DTREE LIST
*/
dtree_t *dtree_list(char *parse)
{
char *p;
dtree_t h[1], *e;
h->n = 0;
e = h;
if(p = envGet("userdir")) e = dtree_seek(p, parse, e);
if(p = envGet("basedir")) e = dtree_seek(p, parse, e);
e = dtree_seek(".", parse, e);
return h->n;
}
static int valueToStringInternal(Value *v, char *s, int n) {
Node *t;
int i;
switch (v->type) {
case BUILTIN_FUN_VALUE_TYPE:
return mySnprintf(s, n, "<builtin-function@%p>", v->data);
case NONE_VALUE_TYPE:
return mySnprintf(s, n, "none");
case INT_VALUE_TYPE:
return mySnprintf(s, n, "%d", v->data);
case CLOSURE_VALUE_TYPE: {
int len = 0;
Node *f = ((Closure *)v->data)->f;
len += mySnprintf(s + len, n - len, "fun %s(",
getStrId((long)chld(f, 0)->data));
t = chld(f, 1);
for (i = 0; i < chldNum(t); i++) {
if (i) {
len += mySnprintf(s + len, n - len, ", ");
}
len += mySnprintf(s + len, n - len, "%s",
getStrId((long)chld(t, i)->data));
}
len += mySnprintf(s + len, n - len, ")");
return len;
}
case LIST_VALUE_TYPE: {
int len = 0;
List *l = v->data;
len += mySnprintf(s + len, n - len, "[");
for (i = 0; i < listSize(l); i++) {
if (i) {
len += mySnprintf(s + len, n - len, ", ");
}
len += valueToStringInternal(listGet(l, i), s + len, n - len);
}
len += mySnprintf(s + len, n - len, "]");
return len;
}
case STRING_VALUE_TYPE: {
return mySnprintf(s, n, "%s", v->data);
}
case ENV_VALUE_TYPE: {
List *keys = envGetAllIds(v->data);
int len = 0;
len += mySnprintf(s, n, "env parent->%p { ", getEnvFromValue(v)->parent);
int keyN = listSize(keys);
for (i = 0; i < keyN; i++) {
long key = (long)listGet(keys, i);
len += mySnprintf(s + len, n - len, "%s->%p ", getStrId(key),
envGet(v->data, key));
}
len += mySnprintf(s + len, n - len, "}");
freeList(keys);
return len;
}
default:
error("cannot print unknown value type: %d at %p\n", v->type, v);
}
}
static int BLOrelo()
{
char *fn, *path, *file, err[1000];
raceC* r;
fn = envGet("BLOrace");
path = dataFindPath(fn);
if(path == NULL)
{
pe("can't find race file %s\n", fn);
return -1;
}
file = txtLoad(path);
free(path);
if(file == NULL)
{
pe("can't load race file %s\n", fn);
return -1;
}
r = raceLoad(file, err);
free(file);
if(r == NULL)
{
pe("error: %s\n", err);
return -1;
}
BLOrace(r);
return 0;
}
void *envGet(Env *origin, Env *curr, char *key, bool createEmpty){
static const char fnName[] __attribute__((unused)) = "envGet()";
VarList *vl = NULL;
bool found = false;
void *data = NULL;
if(curr != NULL){
if(curr->data != NULL){
vl = (VarList*)curr->data;
if(VarList_exists(vl, key)){
data = VarList_get(vl, key);
found = true;
}
}
if(!found){
/* Search in parent */
if(curr->parent != NULL){
data = envGet(origin, curr->parent, key, createEmpty);
}
else{
/* Already at the top */
/* See if there is an environment string with the same name */
if(key[0] == '$') key++;
if(getenv(key) != NULL){
/* Create a copy of the environment string in the original context */
if(origin != NULL){
if(origin->data == NULL){
origin->data = new_VarList();
}
VarList_setString((VarList *)origin->data, key, getenv(key));
data = VarList_get((VarList *)origin->data, key);
}
}
else{
/* Search exhausted */
if(createEmpty){
if(origin != NULL){
if(origin->data == NULL){
origin->data = new_VarList();
}
VarList_setString((VarList *)origin->data, key, "");
data = VarList_get((VarList *)origin->data, key);
}
}
else{
data = NULL;
}
}
}
}
}
return data;
}
/*=============================================================================
* INTERPRETE
*/
cmdC* cmdInterprete(char* s, char* fe)
{
// clear args
for(int i = 0; cmd_args[i]; i++)
memset(cmd_args[i], 0, sizeof(argT));
// convert '=' and ',' to spaces
for(char* c = s; *c; c++)
if(*c == '=' || *c == ',') *c = ' ';
// process command or recognize environment variables
cmdC* c = cmdParse(s);
if(c == NULL)
{
// check if an env var with this name is present
char *w = cmd_copy_word(arg1.s, s);
if(envGet(arg1.s))
{
// fallback to 'set' command //
strcpy(arg0.s, "set");
strncpy(arg2.s, cmd_skip_spaces(w), CMD_ARGSTRING_BF-1);
arg1.s[CMD_ARGSTRING_BF-1] = '\0';
return cmdParse("set");
}
cmd_copy_word(arg0.s, s);
pe("%sunknown command '%s'.\n", fe, arg0.s);
return NULL;
}
// save command
arg_cmd = c;
// process arguments
s = cmd_syntax_re(s, c->Syntax);
if(s)
{
pe("%ssyntax error, %s.\n", fe, s);
return 0;
}
// return gracefully
return c;
}
char *Env_getString(Env *e, char *key){
static const char fnName[] __attribute__((unused)) = "Env_get()";
return (char *)envGet(e, e, key, true);
}
void *Env_get(Env *e, char *key){
static const char fnName[] __attribute__((unused)) = "Env_get()";
return envGet(e, e, key, false);
}
const char* zGetEnvCmd(struct context* ctx, const char* cmd, const char* param) {
return envGet(param, "");
}
