Exemple #1
0
    static ejsval
    Constant_getBoolValue (ejsval env, ejsval _this, int argc, ejsval *args)
    {
        REQ_BOOL_ARG (0, b);

        return Value_new (llvm::Constant::getIntegerValue(llvm::Type::getInt8Ty(llvm::getGlobalContext()), llvm::APInt(8, b?1:0)));
    }
Exemple #2
0
    ejsval
    IRBuilder_createResume(ejsval env, ejsval _this, int argc, ejsval *args)
    {
        REQ_LLVM_VAL_ARG(0, val);

        return Value_new (_llvm_builder.CreateResume(val));
    }
Exemple #3
0
Fichier : eval.c Projet : 7hens/yas
static Value _evalForeach (Procedure self) {
	Exp exp = self->exp;
	Exp pairs = exp->u.ternary->a;
	Value collection = _EVAL(exp->u.ternary->b);
	if (!collection) return NULL;

	Value key = NULL, value = NULL;
	if (pairs->type == COMMA_EXP) {
		key = pairs->u.binary->a->u.value;
		value = pairs->u.binary->b->u.value;
	} else {
		value = pairs->u.value;
	}

	Assoc assoc = Value_pairs(collection, exp->type == IN_EXP);
	Assoc assocNode = assoc;
	Value result = Value_new(at_Array, NULL);
	int endIndex = 0;
	while (self->active && (assocNode = assocNode->next)) {
		self->active = 1;
		_set(self, key, assocNode->key);
		_set(self, value, assocNode->value);
		Value_set(result, Value_number(endIndex++),  _EVAL(exp->u.ternary->c));
	}
	Assoc_free(assoc);
	free(self);
	Value_set(result, at_TV_endIndex, Value_number(endIndex));
	return result;
}
Exemple #4
0
Fichier : eval.c Projet : 7hens/yas
// ================================================================================================
// _evalTrue, _evalWhile, _evalForeach, _evalBreak, _evalSwitch
// ================================================================================================
static Value _evalTrue (Procedure self, Exp exp) {
	Value result = NULL, key = NULL, value = NULL;
	Exp iColon = NULL;
	real endIndex = 0;
	result = Value_new(at_True, NULL);
	while (exp) {
		TRAVERSEL_COMMA_EXP(exp, iColon);
		if (!iColon) continue;
		if (iColon->type == ASSIGN_EXP) {
			result->meta = at_Function;
			result->u.proc = Procedure_new(self, NULL, NULL, result, iColon->u.binary->b);
		} else {
			if (iColon->type != COLON_EXP && iColon->type != ACCESSOR_EXP) {
				key = Value_number(endIndex++);
				value = _EVAL(iColon);
			} else {
				key = _EVAL(iColon->u.binary->a);
				value = (iColon->type == ACCESSOR_EXP
					? Value_functionAccessor(self, iColon->u.binary->b)
					: _EVAL(iColon->u.binary->b)
				);
				if (Value_is(key, at_Number)) {
					endIndex = key->u.number + 1;
				}
			}
			Value_set(result, key, value);
		}
	}
	return result;
}
Exemple #5
0
    ejsval
    IRBuilder_createBr(ejsval env, ejsval _this, int argc, ejsval *args)
    {
        REQ_LLVM_BB_ARG(0, dest);

        return Value_new (_llvm_builder.CreateBr(dest));
    }
Exemple #6
0
    static ejsval
    Constant_getAggregateZero (ejsval env, ejsval _this, int argc, ejsval *args)
    {
        REQ_LLVM_TYPE_ARG (0, ty);

        return Value_new (llvm::ConstantAggregateZero::get(ty));
    }
Exemple #7
0
 ejsval
 IRBuilder_createBitCast(ejsval env, ejsval _this, int argc, ejsval *args)
 {
     REQ_LLVM_VAL_ARG(0, V);
     REQ_LLVM_TYPE_ARG(1, dest_ty);
     FALLBACK_EMPTY_UTF8_ARG(2, name);
     return Value_new (_llvm_builder.CreateBitCast(V, dest_ty, name));
 }
Exemple #8
0
 ejsval
 IRBuilder_createOr(ejsval env, ejsval _this, int argc, ejsval *args)
 {
     REQ_LLVM_VAL_ARG(0, lhs);
     REQ_LLVM_VAL_ARG(1, rhs);
     FALLBACK_EMPTY_UTF8_ARG(2, name);
     return Value_new (_llvm_builder.CreateOr(lhs, rhs, name));
 }
Exemple #9
0
    static ejsval
    Constant_getIntegerValue (ejsval env, ejsval _this, int argc, ejsval *args)
    {
        REQ_LLVM_TYPE_ARG (0, ty);
        REQ_INT_ARG (1, v);

        if (argc == 2) {
            return Value_new (llvm::Constant::getIntegerValue(ty, llvm::APInt(ty->getPrimitiveSizeInBits(), v)));
        }
        else if (argc == 3 && EJSVAL_IS_NUMBER(args[2]) && ty->getPrimitiveSizeInBits() == 64) {
            uint64_t vhi = v;
            uint32_t vlo = (uint32_t)EJSVAL_TO_NUMBER(args[2]);
            return Value_new (llvm::Constant::getIntegerValue(ty, llvm::APInt(ty->getPrimitiveSizeInBits(), (int64_t)((vhi << 32) | vlo))));
        }
        else
            abort(); // FIXME throw an exception
    }
Exemple #10
0
    ejsval
    IRBuilder_createGlobalStringPtr(ejsval env, ejsval _this, int argc, ejsval *args)
    {
        REQ_UTF8_ARG(0, val);
        FALLBACK_EMPTY_UTF8_ARG(1, name);

        return Value_new (_llvm_builder.CreateGlobalStringPtr(val, name));
    }
Exemple #11
0
    ejsval
    IRBuilder_createCondBr(ejsval env, ejsval _this, int argc, ejsval *args)
    {
        REQ_LLVM_VAL_ARG(0, cond);
        REQ_LLVM_BB_ARG(1, thenPart);
        REQ_LLVM_BB_ARG(2, elsePart);

        return Value_new (_llvm_builder.CreateCondBr(cond, thenPart, elsePart));
    }
Exemple #12
0
    ejsval
    IRBuilder_createICmpULt(ejsval env, ejsval _this, int argc, ejsval *args)
    {
        REQ_LLVM_VAL_ARG(0, left);
        REQ_LLVM_VAL_ARG(1, right);
        FALLBACK_EMPTY_UTF8_ARG(2, name);

        return Value_new (_llvm_builder.CreateICmpULT(left, right, name));
    }
Exemple #13
0
    ejsval
    IRBuilder_createStructGetElementPointer(ejsval env, ejsval _this, int argc, ejsval *args)
    {
        REQ_LLVM_VAL_ARG(0, val);
        REQ_INT_ARG(1, idx);
        FALLBACK_EMPTY_UTF8_ARG(2, name);

        return Value_new (_llvm_builder.CreateStructGEP(val, idx, name));
    }
Exemple #14
0
    ejsval
    IRBuilder_createExtractValue(ejsval env, ejsval _this, int argc, ejsval *args)
    {
        REQ_LLVM_VAL_ARG(0, val);
        REQ_INT_ARG(1, idx);
        FALLBACK_EMPTY_UTF8_ARG(2, name);

        return Value_new (_llvm_builder.CreateExtractValue(val, idx, name));
    }
Exemple #15
0
static inline void
expose_VM(STATE, VALUE lobby)
{
  VALUE vm = Value_new(state, ObjectType);
  Value_set(state, lobby, "VM", vm);

  // VM.primitives map
  DArray *prims    = DArray_create(sizeof(VALUE), 10);
  VALUE primitives = Map_new(state, prims);
  Value_set(state, vm, "primitives", primitives);

  // Object
  DEFPRIM("to_s", Primitive_to_s);
  DEFPRIM("prototype", Primitive_prototype);
  DEFPRIM("or", Primitive_or);

  DEFPRIM("equals", Primitive_equals);
  DEFPRIM("is", Primitive_is);
  DEFPRIM("print", Primitive_print);
  DEFPRIM("puts", Primitive_puts);
  DEFPRIM("require", Primitive_require);
  DEFPRIM("clone", Primitive_clone);

  // Vector
  DEFPRIM("vector_[]", Primitive_Vector_at);
  DEFPRIM("vector_push", Primitive_Vector_push);
  DEFPRIM("vector_to_map", Primitive_Vector_to_map);
  DEFPRIM("vector_each", Primitive_Vector_each);
  DEFPRIM("vector_each_with_index", Primitive_Vector_each_with_index);

  // Number
  DEFPRIM("number_+", Primitive_Number_add);
  DEFPRIM("number_-", Primitive_Number_sub);
  DEFPRIM("number_*", Primitive_Number_mul);
  DEFPRIM("number_/", Primitive_Number_div);
  DEFPRIM("number_<", Primitive_Number_lt);
  DEFPRIM("number_>", Primitive_Number_gt);

  // String
  DEFPRIM("string_+", Primitive_String_concat);

  // Map
  DEFPRIM("map_each", Primitive_Map_each);

  // VM.types map
  DArray *ts = DArray_create(sizeof(VALUE), 10);
  VALUE types = Map_new(state, ts);
  Value_set(state, vm, "types", types);

  DEFVALUE("object", Object_bp);
  DEFVALUE("number", Number_bp);
  DEFVALUE("string", String_bp);
  DEFVALUE("vector", Vector_bp);
  DEFVALUE("map", Map_bp);
  DEFVALUE("closure", Closure_bp);
}
Exemple #16
0
    ejsval
    IRBuilder_createSelect(ejsval env, ejsval _this, int argc, ejsval *args)
    {
        REQ_LLVM_VAL_ARG(0, C);
        REQ_LLVM_VAL_ARG(1, True);
        REQ_LLVM_VAL_ARG(2, False);
        FALLBACK_EMPTY_UTF8_ARG(3, name);

        return Value_new(_llvm_builder.CreateSelect(C, True, False, name));
    }
Exemple #17
0
void Runtime_init(STATE) {
  Object_bp = Value_new(state, ObjectType);

  Number_bp = Value_from_prototype(state, NumberType, Object_bp);
  String_bp = Value_from_prototype(state, StringType, Object_bp);
  Vector_bp = Value_from_prototype(state, VectorType, Object_bp);
  Map_bp = Value_from_prototype(state, MapType, Object_bp);
  Closure_bp = Value_from_prototype(state, ClosureType, Object_bp);

  // Init extern constants
  TrueObject  = Value_new(state, TrueType);
  TrueObject->data.as_num = 1;
  FalseObject = Value_new(state, FalseType);
  FalseObject->data.as_num = 0;
  NilObject   = Value_new(state, NilType);
  NilObject->data.as_num = 0;

  // These primitives cannot go in the prelude because they are used there.
  DEFNATIVE(Object_bp, "[]", Primitive_Map_get);
  DEFNATIVE(Object_bp, "[]=", Primitive_Map_set);
}
  static ejsval
  ConstantArray_get (ejsval env, ejsval _this, int argc, ejsval *args)
  {
    REQ_LLVM_TYPE_ARG(0, array_type);
    REQ_ARRAY_ARG(1, elements);

    std::vector< llvm::Constant*> element_constants;
    for (int i = 0; i < EJSARRAY_LEN(elements); i ++) {
      element_constants.push_back (static_cast<llvm::Constant*>(Value_GetLLVMObj(EJSDENSEARRAY_ELEMENTS(elements)[i])));
    }

    return Value_new (llvm::ConstantArray::get(static_cast<llvm::ArrayType*>(array_type), element_constants));
  }
Exemple #19
0
Fichier : eval.c Projet : 7hens/yas
static Value _evalWhile (Procedure self) {
	Exp exp = self->exp;
	Value cond = _EVAL(exp->u.binary->a);
	Value result = Value_new(at_Array, NULL);
	int endIndex = 0;
	while (self->active && (exp->type == WHILE_EXP && cond || exp->type == UNTIL_EXP && !cond)) {
		self->active = 1;
		Value_set(result, Value_number(endIndex++), _EVAL(exp->u.binary->b));
		cond = _EVAL(exp->u.binary->a);
	}
	free(self);
	Value_set(result, at_TV_endIndex, Value_number(endIndex));
	return result;
}
Exemple #20
0
    ejsval
    IRBuilder_createPhi(ejsval env, ejsval _this, int argc, ejsval *args)
    {
        abort();
#if notyet
        REQ_LLVM_TYPE_ARG(0, ty);
        REQ_INT_ARG(1, incoming_values);
        FALLBACK_EMPTY_UTF8_ARG(2, name);

        ejsval rv = Value_new (_llvm_builder.CreatePHI(ty, incoming_values, name));
        free (name);
        return rv;
#endif
    }
Exemple #21
0
    ejsval
    IRBuilder_createInBoundsGetElementPointer(ejsval env, ejsval _this, int argc, ejsval *args)
    {
        REQ_LLVM_VAL_ARG(0, val);
        REQ_ARRAY_ARG(1, idxv);
        FALLBACK_EMPTY_UTF8_ARG(2, name);

        std::vector<llvm::Value*> IdxV;
        for (unsigned i = 0, e = EJSARRAY_LEN(idxv); i != e; ++i) {
            IdxV.push_back (Value_GetLLVMObj(EJSDENSEARRAY_ELEMENTS(idxv)[i]));
            if (IdxV.back() == 0) abort(); // XXX throw an exception here
        }

        return Value_new (_llvm_builder.CreateInBoundsGEP(val, IdxV, name));
    }
Exemple #22
0
    ejsval
    Function_prototype_get_args(ejsval env, ejsval _this, int argc, ejsval *args)
    {
        Function* fun = ((Function*)EJSVAL_TO_OBJECT(_this));
        int size = fun->llvm_fun->arg_size();
        ejsval result = _ejs_array_new(0, EJS_FALSE);

        unsigned Idx = 0;
        for (llvm::Function::arg_iterator AI = fun->llvm_fun->arg_begin(); Idx != size;
             ++AI, ++Idx) {
            ejsval val = Value_new(AI);
            _ejs_array_push_dense (result, 1, &val);
        }
        return result;
    }
Exemple #23
0
Fichier : eval.c Projet : 7hens/yas
static Value _evalTo (Procedure self, ExpType type, Exp a, Exp b, Exp c) {
	Value va = _EVAL(a), vb = _EVAL(b), vc = _EVAL(c);
	if (!vc) { vc = Value_number(1); }
	if (!(Value_is(va, at_Number) && Value_is(vb, at_Number) && Value_is(vc, at_Number))) {
		yyerror("wrong to expression with NAN.");
		return NULL;
	}
	Value result =  Value_new(at_Array, NULL);
	int endIndex = 0;
	real i = va->u.number;
	for (;i < vb->u.number || i == vb->u.number && type == TO_EXP; i += vc->u.number) {
		Value_set(result, Value_number(endIndex++), Value_number(i));
	}
	Value_set(result, at_TV_endIndex, Value_number(endIndex));
	return result;
}
Exemple #24
0
 ejsval
 IRBuilder_createUnreachable(ejsval env, ejsval _this, int argc, ejsval *args)
 {
     return Value_new (_llvm_builder.CreateUnreachable());
 }
Exemple #25
0
 ejsval
 IRBuilder_createRetVoid(ejsval env, ejsval _this, int argc, ejsval *args)
 {
     return Value_new(_llvm_builder.CreateRetVoid());
 }
Exemple #26
0
 static ejsval
 Constant_getNull (ejsval env, ejsval _this, int argc, ejsval *args)
 {
     REQ_LLVM_TYPE_ARG (0, ty);
     return Value_new (llvm::Constant::getNullValue(ty));
 }