Var var_large_or_qual(Var a,Var b)
{
Var result;
result.content.type=VAR_TYPE_BOOL;
if(a.content.type==VAR_TYPE_INT && b.content.type==VAR_TYPE_INT)
{
result.content.var_value.bool_value=a.content.var_value.int_value>=b.content.var_value.int_value;
}
else if(a.content.type==VAR_TYPE_BOOL && b.content.type==VAR_TYPE_BOOL)
{
result.content.var_value.bool_value=a.content.var_value.bool_value<=b.content.var_value.bool_value;
}
else if(a.content.type==VAR_TYPE_INT && b.content.type==VAR_TYPE_BOOL)
{
result.content.var_value.bool_value=a.content.var_value.int_value>=b.content.var_value.bool_value;
}
else if(a.content.type==VAR_TYPE_BOOL && b.content.type==VAR_TYPE_INT)
{
result.content.var_value.bool_value=a.content.var_value.bool_value>=b.content.var_value.int_value;
}
else if(a.content.type!=VAR_TYPE_OBJ && b.content.type!=VAR_TYPE_OBJ)
{
result.content.var_value.bool_value= var_get_value(a)>=var_get_value(b);
}
return result;
}
int main(){
struct Variable var;
var_init(&var, "lol", "lolllvm", V_INT);
assert (strcmp("lol", var_get_name(&var)) == 0);
assert (strcmp("lolllvm", var_get_llvm_name(&var)) == 0);
assert (var_is_int(&var) != 0);
assert (var_is_float(&var) == 0);
assert (var_get_type(&var) == V_INT);
assert (var_is_special(&var) == 0);
var_init(&var, "lol", "lolllvm", V_FLOAT|V_SPECIAL);
var_info(&var);
assert (var_is_int(&var) == 0);
assert (var_is_float(&var) != 0);
assert (var_get_type(&var) == V_FLOAT);
assert (var_is_special(&var) != 0);
var_set_value(&var, -131);
assert (var_get_value(&var) == -131);
var_set_value(&var, 1.234);
assert (((var_get_value(&var)) - 1.234) < 0.00001);
assert (var_get_value(&var) != 1);
var_set_modified(&var, V_MODIFIED);
assert (var_is_modified(&var) != 0);
var_set_modified(&var, V_NULL);
assert (var_is_modified(&var) == 0);
var_set_type(&var, V_FLOAT);
assert (var_is_int(&var) == 0);
assert (var_is_float(&var) != 0);
assert (var_get_type(&var) == V_FLOAT);
var_set_special(&var, V_SPECIAL);
assert (var_is_special(&var) != 0);
var_set_type(&var, V_INT);
assert (var_is_int(&var) != 0);
assert (var_is_float(&var) == 0);
assert (var_get_type(&var) == V_INT);
var_set_access(&var, V_NULL);
assert (var_is_writable(&var) == 0);
var_set_access(&var, V_WRITABLE);
assert (var_is_writable(&var) != 0);
var.flags |= 1;
assert (var_is_declared(&var) != 0);
/* var_set_nb_args(&var, 13); */
/* assert (var_get_nb_args(&var) == 13); */
printf("Tests OK (sauf get_nb_args)\n");
}
/* POSIX says that variable assignments passed on the command line should be
* propagated to sub makes through MAKEFLAGS.
*/
void
Var_AddCmdline(const char *name)
{
Var *v;
unsigned int i;
BUFFER buf;
char *s;
Buf_Init(&buf, MAKE_BSIZE);
for (v = ohash_first(&global_variables, &i); v != NULL;
v = ohash_next(&global_variables, &i)) {
/* This is not as expensive as it looks: this function is
* called before parsing Makefiles, so there are just a
* few non cmdling variables in there.
*/
if (!(v->flags & VAR_FROM_CMD)) {
continue;
}
/* We assume variable names don't need quoting */
Buf_AddString(&buf, v->name);
Buf_AddChar(&buf, '=');
for (s = var_get_value(v); *s != '\0'; s++) {
if (strchr(quotable, *s))
Buf_AddChar(&buf, '\\');
Buf_AddChar(&buf, *s);
}
Buf_AddSpace(&buf);
}
Var_Append(name, Buf_Retrieve(&buf));
Buf_Destroy(&buf);
}
/*两数相除*/
Var var_divide(Var a, Var b)
{
Var result;
if(a.content.type==VAR_TYPE_INT && b.content.type==VAR_TYPE_INT)
{
/*在整数相除时,如果两数不能整除则要转换成实数类型*/
if(a.content.var_value.int_value%b.content.var_value.int_value==0)
{
result.content.type=VAR_TYPE_INT;
result.content.var_value.int_value=a.content.var_value.int_value/b.content.var_value.int_value;
}
else
{
result.content.type=VAR_TYPE_REAL;
result.content.var_value.real_value=var_get_value(a)/var_get_value(b);
}
}
else if(a.content.type==VAR_TYPE_REAL && b.content.type==VAR_TYPE_REAL)
{
result.content.type=VAR_TYPE_REAL;
result.content.var_value.real_value=a.content.var_value.real_value/b.content.var_value.real_value;
}
else if(a.content.type==VAR_TYPE_REAL && b.content.type==VAR_TYPE_INT)
{
result.content.type=VAR_TYPE_REAL;
result.content.var_value.real_value=(a.content.var_value.real_value)/(1.0*b.content.var_value.int_value);
}
else if(a.content.type==VAR_TYPE_INT && b.content.type==VAR_TYPE_REAL)
{
result.content.type=VAR_TYPE_REAL;
result.content.var_value.real_value=1.0*a.content.var_value.int_value/b.content.var_value.real_value;
}
else if(a.content.type==VAR_TYPE_BOOL || b.content.type==VAR_TYPE_BOOL)
{
printf("error the boolean type's var can take part in divide-caculate\n");
exit(0);
}
else
{
printf("this way of dividing is not supported yet\n");
exit(0);
}
return result;
}
static char *
get_expanded_value(const char *name, const char *ename, int idx, uint32_t k,
SymTable *ctxt, bool err, bool *freePtr)
{
char *val;
/* Before doing any modification, we have to make sure the
* value has been fully expanded. If it looks like recursion
* might be necessary (there's a dollar sign somewhere in
* the variable's value) we just call Var_Subst to do any
* other substitutions that are necessary. Note that the
* value returned by Var_Subst will have been dynamically
* allocated, so it will need freeing when we return.
*/
if (idx == GLOBAL_INDEX) {
Var *v = find_global_var(name, ename, k);
if (v == NULL)
return NULL;
if ((v->flags & POISONS) != 0)
poison_check(v);
if ((v->flags & VAR_DUMMY) != 0)
return NULL;
val = var_get_value(v);
if (strchr(val, '$') != NULL) {
push_used(v);
val = Var_Subst(val, ctxt, err);
pop_used(v);
*freePtr = true;
}
} else {
if (ctxt != NULL) {
if (idx < LOCAL_SIZE)
val = ctxt->locals[idx];
else
val = ctxt->locals[EXTENDED2SIMPLE(idx)];
} else
val = NULL;
if (val == NULL)
return NULL;
if (idx >= LOCAL_SIZE) {
if (IS_EXTENDED_F(idx))
val = Var_GetTail(val);
else
val = Var_GetHead(val);
*freePtr = true;
}
}
return val;
}
/* Set or add a global variable, in VAR_CMD or VAR_GLOBAL context.
*/
static void
var_set_append(const char *name, const char *ename, const char *val, int ctxt,
bool append)
{
Var *v;
uint32_t k;
int idx;
idx = classify_var(name, &ename, &k);
if (idx != GLOBAL_INDEX) {
Parse_Error(PARSE_FATAL, "Trying to %s dynamic variable $%s",
append ? "append to" : "set", varnames[idx]);
return;
}
v = find_global_var(name, ename, k);
if (v->flags & POISON_NORMAL)
Parse_Error(PARSE_FATAL, "Trying to %s poisoned variable %s\n",
append ? "append to" : "set", v->name);
/* so can we write to it ? */
if (ctxt == VAR_CMD) { /* always for command line */
(append ? var_append_value : var_set_value)(v, val);
v->flags |= VAR_FROM_CMD;
if ((v->flags & VAR_SHELL) == 0) {
/* Any variables given on the command line are
* automatically exported to the environment,
* except for SHELL (as per POSIX standard).
*/
esetenv(v->name, val);
}
if (DEBUG(VAR))
printf("command:%s = %s\n", v->name, var_get_value(v));
} else if ((v->flags & VAR_FROM_CMD) == 0 &&
(!checkEnvFirst || (v->flags & VAR_FROM_ENV) == 0)) {
(append ? var_append_value : var_set_value)(v, val);
if (DEBUG(VAR))
printf("global:%s = %s\n", v->name, var_get_value(v));
} else if (DEBUG(VAR))
printf("overridden:%s = %s\n", v->name, var_get_value(v));
}
/* Check if there's any reason not to use the variable in this context.
*/
static void
poison_check(Var *v)
{
if (v->flags & POISON_NORMAL) {
Parse_Error(PARSE_FATAL,
"Poisoned variable %s has been referenced\n", v->name);
return;
}
if (v->flags & VAR_DUMMY) {
Parse_Error(PARSE_FATAL,
"Poisoned variable %s is not defined\n", v->name);
return;
}
if (v->flags & POISON_EMPTY)
if (strcmp(var_get_value(v), "") == 0)
Parse_Error(PARSE_FATAL,
"Poisoned variable %s is empty\n", v->name);
}
/* XXX different semantics for Var_Valuei() and Var_Definedi():
* references to poisoned value variables will error out in Var_Valuei(),
* but not in Var_Definedi(), so the following construct works:
* .poison BINDIR
* BINDIR ?= /usr/bin
*/
char *
Var_Valuei(const char *name, const char *ename)
{
Var *v;
uint32_t k;
int idx;
idx = classify_var(name, &ename, &k);
if (idx != GLOBAL_INDEX) {
Parse_Error(PARSE_FATAL,
"Trying to get value of dynamic variable $%s",
varnames[idx]);
return NULL;
}
v = find_global_var(name, ename, k);
if (v->flags & POISONS)
poison_check(v);
if ((v->flags & VAR_DUMMY) == 0)
return var_get_value(v);
else
return NULL;
}
static void
print_var(Var *v)
{
printf("%-16s%s = %s\n", v->name, interpret(v->flags),
(v->flags & VAR_DUMMY) == 0 ? var_get_value(v) : "(none)");
}
//TODO check number of arguments given to builtins
object_t *eval(object_t *exp, object_t *env) {
char comeback = 1;
while(comeback) {
comeback = 0;
if(is_self_evaluating(exp)) {
return exp;
}
if(list_begins_with(exp, quote_symbol)) {
return cadr(exp);
}
// (define... )
if(list_begins_with(exp, define_symbol)) {
object_t *var = cadr(exp);
// (define a b)
if(issymbol(var)) {
object_t *val = caddr(exp);
return define_var(env, var, val);
}
// (define (a ...) ...) TODO use scheme macro
if(ispair(var)) {
object_t *name = car(cadr(exp)),
*formals = cdr(cadr(exp)),
*body = cddr(exp),
*lambda = cons(lambda_symbol,
cons(formals, body));
exp = cons(define_symbol,
cons(name, cons(lambda, empty_list)));
comeback = 1;
continue;
}
fprintf(stderr, "Syntax error.\n");
exit(-1);
}
// (set! a b)
if(list_begins_with(exp, set_symbol)) {
object_t *var = cadr(exp);
object_t *val = caddr(exp);
return set_var(env, var, val);
}
// (if c a b)
if(list_begins_with(exp, if_symbol)) {
exp = eval_if(env, cadr(exp), caddr(exp), cadddr(exp));
comeback = 1;
continue;
}
// (cond ...)
if(list_begins_with(exp, cond_symbol)) {
object_t *tail = cons(void_symbol, empty_list);
object_t *ifs = tail; //empty_list;
object_t *rules = reverse_list(cdr(exp));
while(!isemptylist(rules)) {
object_t *rule = car(rules),
*condition = car(rule),
*consequence = cadr(rule);
if(isemptylist(consequence)) {
consequence = cons(void_obj, empty_list);
}
ifs = cons(if_symbol,
cons(condition,
cons(consequence,
cons(ifs, empty_list))));
rules = cdr(rules);
}
exp = ifs;
comeback = 1;
continue;
}
// (begin ...)
if(list_begins_with(exp, begin_symbol)) {
object_t *result = empty_list, *exps;
for(exps = cdr(exp); ! isemptylist(exps); exps = cdr(exps)) {
result = eval(car(exps), env);
}
return result;
}
if(list_begins_with(exp, lambda_symbol)) {
object_t *fn = cons(begin_symbol,
cdr(cdr(exp)));
return make_compound_proc(empty_list, cadr(exp),
fn,
env);
}
// (let ...)
if(list_begins_with(exp, let_symbol)) {
//if(! issymbol(cadr(exp)))
object_t *bindings = cadr(exp);
object_t *body = cddr(exp);
object_t *formals = empty_list;
object_t *values = empty_list;
while(!isemptylist(bindings)) {
formals = cons(caar(bindings), formals);
values = cons(cadr(car(bindings)), values);
bindings = cdr(bindings);
}
exp = cons(cons(lambda_symbol, cons(formals, body)),
values);
comeback = 1;
continue;
}
if(issymbol(exp)) {
return var_get_value(env, exp);
}
if(ispair(exp)) {
object_t *exp_car = car(exp);
object_t *fn = eval(exp_car, env); //var_get_value(env, car);
if(!iscallable(fn)) {
fprintf(stderr, "object_t is not callable\n");
exit(-1);
}
object_t *args = cdr(exp);
object_t *evaluated_args = evaluate_list(env, args, empty_list);
if(isprimitiveproc(fn)) {
return fn->value.prim_proc.fn(evaluated_args);
} else if(iscompoundproc(fn)) {
object_t *fn_formals = fn->value.compound_proc.formals;
object_t *fn_body = fn->value.compound_proc.body;
object_t *fn_env = fn->value.compound_proc.env;
ARGS_EQ(evaluated_args, list_size(fn_formals));
exp = fn_body;
env = extend_environment(fn_formals, evaluated_args, fn_env);
comeback = 1;
continue;
}
assert(0);
}
}
fprintf(stderr, "Unable to evaluate expression: \n");
write(exp);
exit(-1);
}
