static Editor
getCreateEditorView(View v, Size size)
{ Editor e;
Int w, h;
if ( notDefault(size) )
{ w = size->w;
h = size->h;
} else
w = h = DEFAULT;
if ( (e = newObject(ClassEditor, DEFAULT, w, h, EAV)) )
{ FontObj f;
if ( (f = getClassVariableValueObject(v, NAME_font)) )
send(e, NAME_font, f, EAV);
answer(e);
}
fail;
}
static status
initialiseBlockv(Block b, int argc, Any *argv)
{ int n;
initialiseCode((Code) b);
assign(b, members, newObject(ClassChain, EAV));
for(n=0; n<argc; n++)
{ if ( instanceOfObject(argv[n], ClassVar) )
{ if ( isNil(b->parameters) )
assign(b, parameters, newObjectv(ClassCodeVector, 1, &argv[n]));
else
appendVector(b->parameters, 1, &argv[n]);
} else
break;
}
for( ; n < argc; n++ )
appendChain(b->members, argv[n]);
succeed;
}
Variable AVM::createNewObject(const Common::UString &name, std::vector<Variable> arguments) {
Variable variable = getVariable(name);
if (!variable.isFunction())
throw Common::Exception("Object is not a function");
if (!variable.asObject()->hasMember("prototype"))
throw Common::Exception("Object has no prototype");
ObjectPtr newObject(new Object(variable.asObject()->getMember("prototype").asObject().get()));
Function *constructor = dynamic_cast<Function *>(variable.asObject().get());
if (!constructor)
throw Common::Exception("Constructor is not a function");
byte counter = 1;
if (constructor->getPreloadRootFlag()) {
storeRegister(_variables["_root"], counter);
counter += 1;
}
if (constructor->getPreloadThisFlag()) {
storeRegister(Variable(newObject), counter);
counter += 1;
}
if (constructor->getPreloadSuperFlag()) {
storeRegister(Variable(newObject->getMember("constructor")), counter);
counter += 1;
}
for (size_t i = 0; i < arguments.size(); ++i) {
storeRegister(arguments[i], counter);
counter += 1;
}
(*constructor)(*this);
return Variable(newObject);
}
Something socketReadBytes(Thread *thread) {
int connectionAddress = *(int *)stackGetThisObject(thread)->value;
EmojicodeInteger n = unwrapInteger(stackGetVariable(0, thread));
Object *bytesObject = newArray(n);
size_t read = recv(connectionAddress, bytesObject->value, n, 0);
if (read < 1) {
return NOTHINGNESS;
}
stackPush(somethingObject(bytesObject), 0, 0, thread);
Object *obj = newObject(CL_DATA);
Data *data = obj->value;
data->length = read;
data->bytesObject = stackGetThisObject(thread);
data->bytes = data->bytesObject->value;
stackPop(thread);
return somethingObject(obj);
}
std::shared_ptr<Hinge> Hinge::Spawn(std::string RigidBodyIDA, CML::Vec3 PivotPointA, CML::Vec3 AxesA,
double BreakingThreshold,
double Low,
double High,
double Softness,
double BiasFactor,
double RelaxationFactor,
double MaxMotorImpulse)
{
PhysicsManager& physicsManager = PhysicsManager::GetInstance();
std::shared_ptr<Hinge> newObject(new Hinge());
auto iter = Resource::RigidBodyList.find(RigidBodyIDA);
if(iter != Resource::RigidBodyList.end())
{
newObject->Info.RigidBodyA = std::pair<std::string, std::weak_ptr<RigidBody>>(RigidBodyIDA, iter->second);
}
else
{
Logger::LogError("Error creating Hinge, the rigid body could not be found");
}
newObject->Info.PivotPointA = PivotPointA;
newObject->Info.AxesA = AxesA;
newObject->Info.BreakingThreshold = BreakingThreshold;
newObject->Info.Low = Low;
newObject->Info.High = High;
newObject->Info.Softness = Softness;
newObject->Info.BiasFactor = BiasFactor;
newObject->Info.RelaxationFactor = RelaxationFactor;
newObject->Info.MaxMotorImpulse = MaxMotorImpulse;
newObject->Init();
return newObject;
}
static void systemSystem(Thread *thread) {
FILE *f = popen(stringToCString(thread->variable(0).object), "r");
if (f == nullptr) {
thread->returnNothingnessFromFunction();
return;
}
size_t bufferUsedSize = 0;
int bufferSize = 50;
auto buffer = thread->retain(newArray(bufferSize));
while (fgets(buffer->val<char>() + bufferUsedSize, bufferSize - (int)bufferUsedSize, f) != nullptr) {
bufferUsedSize = strlen(buffer->val<char>());
if (bufferSize - bufferUsedSize < 2) {
bufferSize *= 2;
buffer = resizeArray(buffer.unretainedPointer(), bufferSize, thread);
}
}
bufferUsedSize = strlen(buffer->val<char>());
EmojicodeInteger len = u8_strlen_l(buffer->val<char>(), bufferUsedSize);
auto so = thread->retain(newObject(CL_STRING));
auto *string = so->val<String>();
string->length = len;
Object *chars = newArray(len * sizeof(EmojicodeChar));
string = so->val<String>();
string->charactersObject = chars;
u8_toucs(string->characters(), len, buffer->val<char>(), bufferUsedSize);
thread->release(2);
thread->returnFromFunction(so.unretainedPointer());
}
object_t* z_div(list_t* args) {
object_t* a = z_nth(args,0);
object_t* b = z_nth(args,1);
object_t* result = newObject();
if ((z_typeof(a) == Int && b->value->value.i == 0) || (z_typeof(a) == Float && b->value->value.f == 0)) {
return z_exception("Division by zero.");
}
if(z_typeof(a) == z_typeof(b) && z_typeof(a) == Int) {
result->value->value = (generic_value_t) (a->value->value.i / b->value->value.i);
result->value->type = Int;
} else if(z_typeof(a) == z_typeof(b) && z_typeof(a) == Float) {
result->value->value = (generic_value_t) (a->value->value.f / b->value->value.f);
result->value->type = Float;
} else if(z_typeof(a) == Float && z_typeof(b) == Int) {
result->value->value = (generic_value_t) (a->value->value.f / b->value->value.i);
result->value->type = Float;
} else if(z_typeof(a) == Int && z_typeof(b) == Float) {
result->value->value = (generic_value_t) (a->value->value.i / b->value->value.f);
result->value->type = Float;
} else {
exception("Type mismatch", a);
}
return result;
}
std::shared_ptr<BallSocket> BallSocket::Spawn(std::string RigidBodyIDA, CML::Vec3 PivotPointA,
std::string RigidBodyIDB, CML::Vec3 PivotPointB,
double BreakingThreshold)
{
std::shared_ptr<BallSocket> newObject(new BallSocket());
auto iter = Resource::RigidBodyList.find(RigidBodyIDA);
if(iter != Resource::RigidBodyList.end())
{
newObject->Info.RigidBodyA = std::pair<std::string, std::weak_ptr<RigidBody>>(RigidBodyIDA, iter->second);
}
else
{
Logger::LogError("Error creating BallSocket, the rigid body could not be found");
}
newObject->Info.PivotPointA = PivotPointA;
iter = Resource::RigidBodyList.find(RigidBodyIDB);
if(iter != Resource::RigidBodyList.end())
{
newObject->Info.RigidBodyB = std::pair<std::string, std::weak_ptr<RigidBody>>(RigidBodyIDB, iter->second);
}
else
{
Logger::LogError("Error creating BallSocket, the rigid body could not be found");
}
newObject->Info.PivotPointB = PivotPointB;
newObject->Info.BreakingThreshold = BreakingThreshold;
newObject->Init();
return newObject;
}
void nbObjectInit(NB_Stem *stem){
nb_DisabledType=NbObjectType(stem,"disabled",NB_OBJECT_KIND_CONSTANT|NB_OBJECT_KIND_PERMANENT,TYPE_SPECIAL,disabledName,nbDisabledShow,NULL);
nb_DisabledType->apicelltype=NB_TYPE_DISABLED;
nb_Disabled=newObject(nb_DisabledType,NULL,sizeof(NB_Object));
nb_Disabled->refcnt=(unsigned int)-1; /* flag as perminent object */
nb_TrueType=NbObjectType(stem,"true",NB_OBJECT_KIND_TRUE|NB_OBJECT_KIND_REAL|NB_OBJECT_KIND_CONSTANT|NB_OBJECT_KIND_PERMANENT,TYPE_SPECIAL,trueName,nbTrueShow,NULL);
nb_TrueType->apicelltype=NB_TYPE_TRUE;
nb_True=newObject(nb_TrueType,NULL,sizeof(NB_Real));
nb_True->refcnt=(unsigned int)-1; /* flag as perminent object */
((NB_Real *)nb_True)->value=1;
nb_FalseType=NbObjectType(stem,"false",NB_OBJECT_KIND_FALSE|NB_OBJECT_KIND_REAL|NB_OBJECT_KIND_CONSTANT|NB_OBJECT_KIND_PERMANENT,TYPE_SPECIAL,falseName,nbFalseShow,NULL);
nb_FalseType->apicelltype=NB_TYPE_FALSE;
nb_False=newObject(nb_FalseType,NULL,sizeof(NB_Real));
nb_False->refcnt=(unsigned int)-1; /* flag as perminent object */
((NB_Real *)nb_False)->value=0;
nb_UnknownType=NbObjectType(stem,"unknown",NB_OBJECT_KIND_UNKNOWN|NB_OBJECT_KIND_CONSTANT|NB_OBJECT_KIND_PERMANENT,TYPE_SPECIAL,unknownName,nbUnknownShow,NULL);
nb_UnknownType->apicelltype=NB_TYPE_UNKNOWN;
nb_Unknown=newObject(nb_UnknownType,NULL,sizeof(NB_Object));
nb_Unknown->refcnt=(unsigned int)-1; /* flag as perminent object */
nb_UndefinedType=nbObjectType(stem,"undefined",NB_OBJECT_KIND_CONSTANT|NB_OBJECT_KIND_PERMANENT,TYPE_SPECIAL,nbUndefinedShow,NULL);
nb_UndefinedType->apicelltype=NB_TYPE_UNDEFINED;
nb_Undefined=newObject(nb_UndefinedType,NULL,sizeof(NB_Object));
nb_Undefined->refcnt=(unsigned int)-1; /* flag as perminent object */
nb_PlaceholderType=nbObjectType(stem,"placeholder",NB_OBJECT_KIND_CONSTANT|NB_OBJECT_KIND_PERMANENT,TYPE_SPECIAL,nbPlaceholderShow,NULL);
nb_PlaceholderType->apicelltype=NB_TYPE_PLACEHOLDER;
nb_Placeholder=newObject(nb_PlaceholderType,NULL,sizeof(NB_Object));
nb_Placeholder->refcnt=(unsigned int)-1; /* flag as perminent object */
nb_DisabledType->object.value=nb_Unknown;
nb_UnknownType->object.value=nb_Unknown;
nb_UndefinedType->object.value=nb_Unknown;
nb_PlaceholderType->object.value=nb_Unknown;
nb_TypeType=nbObjectType(stem,"type",NB_OBJECT_KIND_CONSTANT|NB_OBJECT_KIND_PERMANENT,TYPE_WELDED,nbTypeShow,NULL);
}
Object::Object(QScriptEnginePrivate *eng, QScriptClassInfo *classInfo):
Core(eng, classInfo)
{
newObject(&publicPrototype, eng->nullValue());
}
ixPo newInteger(integer ix)
{
return (ixPo)newObject(ixClass,ix);
}
void vm_push_obj(object *obj){
Object* o = newObject(global_vm, OBJ_POINTER);
o->pvalue = obj;
o->free=delete_obj;
push(global_vm, o);
}
END_IT
IT("Parses date and time strings")
str1 = newString(strDup("3/24/1988 5:42am"));
SHOULD_EQUAL(newDate(str1), 575185320)
freeStr(str1);
str2 = newString(strDup("10/11/2000 15:12:34"));
SHOULD_EQUAL(newDate(str2), 971277154)
freeStr(str2);
END_IT
END_DESCRIBE
DESCRIBE(newObject, "tap_obj* newObject (datatype type, property* props)")
IT("Creates a new object with the given type and properties")
expression* expr = newExpressionInt(5);
tap_obj* obj = newObject(TYPE_OBJ, newProperty("x", newTypelist(TYPE_INT), PROP_PRIVACY_PUBLIC, PROP_RANGE_LOCAL, expr));
SHOULD_EQUAL(obj->type, TYPE_OBJ)
SHOULD_EQUAL(strcmp(obj->props->name, "x"), 0)
freeExpr(expr);
freeObj(obj);
END_IT
END_DESCRIBE
DESCRIBE(copyObject, "tap_obj* copyObject (tap_obj* obj)")
IT("Copies the given object, copying its type and properties")
expression* expr = newExpressionFlo(-9.8);
tap_obj* obj1 = newObject(TYPE_OBJ, newProperty("y", newTypelist(TYPE_FLO), PROP_PRIVACY_PRIVATE, PROP_RANGE_GLOBAL, expr));
tap_obj* obj2 = copyObject(obj1);
SHOULD_NOT_EQUAL(obj1, obj2)
SHOULD_EQUAL(obj1->type, obj2->type)
SHOULD_NOT_EQUAL(obj1->props, obj2->props)
inline Object *hashMapObject(HashMap *hm, const MemTag memTag) {
return newObject(hm, HashMapTag, memTag);
}
inline Object *doubleObject(const double d) {
double *dMem = (double *)malloc(sizeof(*dMem));
*dMem = d;
return newObject(dMem, DoubleTag, Heapd);
}
inline Object *kvObject(Object *key, Object *value) {
KeyValue *kv = kvStruct(key, value);
return newObject(kv, KeyValueTag, Heapd);
}
object_t* z_println(list_t* args) {
z_print(args);
printf("\n");
return newObject();
}
QScriptValue QDeclarativeContextScriptClass::newUrlContext(const QString &url)
{
QScriptEngine *scriptEngine = QDeclarativeEnginePrivate::getScriptEngine(engine);
return newObject(scriptEngine, this, new UrlContextData(url));
}
static Graphical
getDefaultArrowJoint(Joint jt)
{ answer(newObject(ClassArrow, EAV));
}
void pushInt(VM* vm, int intValue) {
Object* object = newObject(vm, OBJ_INT);
object->value = intValue;
push(vm, object);
}
listPo cons(objectPo head, listPo tail) {
return O_LIST(newObject(listClass, head, tail));
}
object_t* z_cond_placeholder(list_t* args) {
return newObject();
}
QScriptValue QDeclarativeObjectMethodScriptClass::newMethod(QObject *object, const QDeclarativePropertyCache::Data *method)
{
QScriptEngine *scriptEngine = QDeclarativeEnginePrivate::getScriptEngine(engine);
return newObject(scriptEngine, this, new MethodData(object, *method));
}
inline Object *intObject(const uint64 u) {
uint32 *uMem = (uint32 *)malloc(sizeof(*uMem));
*uMem = u;
return newObject(uMem, LIntTag, Heapd);
}
retCode connectRemote(char *where, int port,
ioEncoding encoding, logical waitForMe,
ioPo *inC, ioPo *outC) {
int sock;
struct sockaddr_in serv_addr;
char *host = getHostname(where);
struct in_addr *addr = host != NULL ? getHostIP(host, 0) : NULL;
if (addr != NULL) {
/* Attempt to establish links to the server */
memset((char *) &serv_addr, 0, sizeof(serv_addr));
serv_addr.sin_family = AF_INET;
serv_addr.sin_addr = *addr;
serv_addr.sin_port = htons((u_short) port);
/* Create the socket ... */
if ((sock = socket(AF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET) {
return Error;
} else {
ioPo conn = O_IO(newObject(sockClass, host, sock, encoding, ioREAD | ioWRITE));
configureIo(O_FILE(conn), (waitForMe ? turnOnBlocking : turnOffBlocking));
while (connect(sock, (struct sockaddr *) &serv_addr, sizeof(serv_addr)) != 0) {
switch (errno) { // Unix version
case EACCES:
case EADDRNOTAVAIL:
outMsg(logFile, "Address %U not available", host);
markHostUnavail(host);
closeFile(O_IO(conn));
return Error;
case ECONNREFUSED:
outMsg(logFile, "Connection to %U refused", host);
markHostUnavail(host);
closeFile(O_IO(conn));
return Error;
case ETIMEDOUT:
outMsg(logFile, "Connection to %U timed out", host);
markHostUnavail(host);
closeFile(O_IO(conn));
return Error;
case ENETUNREACH:
outMsg(logFile, "Network down or %U unreachable", host);
markHostUnavail(host);
closeFile(O_IO(conn));
return Error;
case EALREADY:
case EINTR:
case EWOULDBLOCK:
case EINPROGRESS:
closeFile(O_IO(conn));
return Fail;
default:
outMsg(logFile, "Connection to %U refused", host);
markHostUnavail(host);
closeFile(O_IO(conn));
return Error;
}
}
*inC = conn;
*outC = conn;
return Ok;
}
} else {
outMsg(logFile, "cant resolve host %U", where);
return Error;
}
}
object_t* z_print(list_t* args) {
object_t* obj = newObject();
object_t* o = z_first(args);
struct atom *atom;
if(o == NULL) {
printf("undefined");
return obj;
}
switch(o->value->type) {
case Int:
printf("%d", o->value->value.i);
return obj;
case Float:
printf("%f", o->value->value.f);
return obj;
case Char:
printf("%c", o->value->value.c);
return obj;
case String:
printf("%s",o->value->value.s);
return obj;
case Bool:
if(o->value->value.b) {
printf("True");
} else {
printf("False");
}
return obj;
case List:
atom = o->value->value.l->head;
printf("( ");
while (atom != NULL) {
object_t *l = z_list();
z_conj(l->value->value.l, atom->value);
z_print(l->value->value.l);
printf(" ");
atom = atom->next;
}
printf(")");
return obj;
case Exception:
printf("<Exception Object>");
return obj;
case Function:
if (o->value->value.function->body != NULL) {
printf("<Function Object> ( %s ", o->value->value.function->name);
atom = o->value->value.function->args->head;
printf("( ");
while (atom != NULL) {
object_t *l = z_list();
z_conj(l->value->value.l, atom->value);
z_print(l->value->value.l);
printf(" ");
atom = atom->next;
}
printf(") ");
atom = o->value->value.function->body->head;
printf("( ");
while (atom != NULL) {
object_t *l = z_list();
z_conj(l->value->value.l, atom->value);
z_print(l->value->value.l);
printf(" ");
atom = atom->next;
}
printf(") )");
} else {
printf("<Native Function Object>");
}
return obj;
case FunctionReference:
printf("%s",o->value->value.s);
return obj;
case Symbol:
printf("%s", o->value->value.s);
return obj;
}
printf("<object> @ %d", o->id);
}
QScriptValue QDeclarativeContextScriptClass::newContext(QDeclarativeContextData *context, QObject *scopeObject)
{
QScriptEngine *scriptEngine = QDeclarativeEnginePrivate::getScriptEngine(engine);
return newObject(scriptEngine, this, new ContextData(context, scopeObject));
}
void SerializerBase::invokeRead(Archive &ar)
{
Node node( "", "", 0, false );
Node * pNode = NULL;
if (ar.isFlagSet(Archive::NODE_ALREADY_READ))
{
LocalStorage & localStorage = ar.getIstream()->getLocalStorage();
pNode = reinterpret_cast<Node *>(localStorage.getNode());
}
else
{
if ( ! ar.getIstream()->begin(node) )
return;
pNode = &node;
}
// Detect polymorphism, either through pointers or through references
if (!ar.isFlagSet(Archive::POLYMORPHIC))
{
if ( ar.isFlagSet(Archive::POINTER)
|| (!ar.isFlagSet(Archive::PARENT) && isDerived()))
{
if (pNode->type.length() > 0)
{
ar.setFlag(Archive::POLYMORPHIC, true );
std::string derivedTypeName = pNode->type.cpp_str();
getSerializerPolymorphic(derivedTypeName);
ar.getIstream()->getLocalStorage().setNode(pNode);
ar.setFlag(Archive::NODE_ALREADY_READ);
invokeSerializerPolymorphic(ar);
return;
}
}
}
// May now assume that the object is not polymorphic
UInt32 nid = pNode->id;
bool bId = pNode->id ? true : false;
bool bNode = pNode->ref ? false : true;
bool bPointer = ar.isFlagSet(Archive::POINTER);
ar.clearState();
if (bId && bNode && bPointer)
{
newObject(ar);
addToInputContext(ar.getIstream(), nid);
serializeContents(ar);
}
else if ( !bId && bNode && bPointer )
{
newObject(ar);
serializeContents(ar);
}
else if (bId && !bNode && bPointer)
{
queryInputContext(ar.getIstream(), nid);
setFromId();
}
else if (bId && bNode && !bPointer)
{
addToInputContext(ar.getIstream(), nid);
serializeContents(ar);
}
else if (!bId && bNode && !bPointer )
{
serializeContents(ar);
}
else if (!bId && !bNode && bPointer)
{
setToNull();
}
else if (!bId && !bNode && !bPointer)
{
RCF::Exception e(RCF::_RcfError_DeserializationNullPointer());
RCF_THROW(e);
}
else if (bId && !bNode && !bPointer)
{
RCF::Exception e(RCF::_SfError_RefMismatch());
RCF_THROW(e);
}
ar.getIstream()->end();
}
QScriptValue QDeclarativeContextScriptClass::newSharedContext()
{
QScriptEngine *scriptEngine = QDeclarativeEnginePrivate::getScriptEngine(engine);
return newObject(scriptEngine, this, new ContextData());
}
void pushInt(VM* vm, int value) {
Object* obj = newObject(vm, ObjInt);
obj->value = value;
pushStack(vm, obj);
}
