Ejemplo n.º 1
0
IoEvDNSRequest *IoEvDNSRequest_rawClone(IoEvDNSRequest *proto)
{
	IoObject *self = IoObject_rawClonePrimitive(proto);
	IoObject_setDataPointer_(self, 0x0);
	return self;
}
Ejemplo n.º 2
0
IoCFFIFunction *IoCFFIFunction_rawClone(IoCFFIFunction *proto)
{
	IoObject *self = IoObject_rawClonePrimitive(proto);
	IoObject_setDataPointer_(self, calloc(1, sizeof(IoCFFIFunctionData)));
	return self;
}
Ejemplo n.º 3
0
IoClutterStage *IoClutterStage_newWithActor(void *state, ClutterActor *actor) {
  IoClutterStage *self = IoClutterStage_new(state);
  IoObject_setDataPointer_(self, actor);
  return self;
}
Ejemplo n.º 4
0
IoObject* IoMySQL_rawClone(IoObject* proto) {
	IoObject* self = IoObject_rawClonePrimitive(proto);
	IoObject_setDataPointer_(self, calloc(1, sizeof(IoMySQLData)));
	return self;
}
Ejemplo n.º 5
0
IoList *IoList_proto(void *state)
{
	IoMethodTable methodTable[] = {
	{"with",        IoList_with},

	// access

	{"indexOf",     IoList_indexOf},
	{"contains",    IoList_contains},
	{"containsIdenticalTo", IoList_containsIdenticalTo},
	{"capacity",    IoList_capacity},
	{"size",        IoList_size},

	// mutation

	{"setSize",     IoList_setSize},
	{"removeAll",   IoList_removeAll},
	{"appendSeq",   IoList_appendSeq},
	{"append",      IoList_append},
	{"prepend",     IoList_prepend},
	{"push",        IoList_append},

	{"appendIfAbsent", IoList_appendIfAbsent},

	{"remove",      IoList_remove},
	{"pop",         IoList_pop},

	{"atInsert",    IoList_atInsert},
	{"at",          IoList_at},
	{"atPut",       IoList_atPut},

	{"removeAt",    IoList_removeAt},
	{"swapIndices", IoList_swapIndices},

	{"preallocateToSize", IoList_preallocateToSize},

	{"first",           IoList_first},
	{"last",            IoList_last},
	{"slice",           IoList_slice},
	{"sliceInPlace",    IoList_sliceInPlace},


	{"sortInPlace",     IoList_sortInPlace},
	{"sortInPlaceBy",   IoList_sortInPlaceBy},
	{"foreach",         IoList_foreach},
	{"reverseInPlace",	IoList_reverseInPlace},
	{"reverseForeach",  IoList_reverseForeach},
	
	{"asEncodedList",   IoList_asEncodedList},
	{"fromEncodedList", IoList_fromEncodedList},
	{"join", IoList_join},
	{NULL, NULL},
	};

	IoObject *self = IoObject_new(state);
	IoObject_tag_(self, IoList_newTag(state));

	IoObject_setDataPointer_(self, List_new());
	IoState_registerProtoWithId_((IoState *)state, self, protoId);

	IoObject_addMethodTable_(self, methodTable);
	return self;
}
Ejemplo n.º 6
0
IoClutterInputDevice *IoClutterInputDevice_newWithDevice(void *state, ClutterInputDevice *device) {
  IoClutterInputDevice *self = IoClutterInputDevice_new(state);
  IoObject_setDataPointer_(self, device);
  return self;
}
Ejemplo n.º 7
0
IoSecureServer *IoSecureServer_proto(void *state)
{
	initSSL();
	
	IoObject *self = IoObject_new(state);
	
	IoObject_tag_(self, IoSecureServer_newTag(state));
	
	IoObject_setDataPointer_(self, (SecureServerData *)calloc(1, sizeof(SecureServerData)));
	SSL_CTX *ctx = SSL_CTX_new(TLSv1_server_method());
	DATA(self)->ssl_ctx = ctx;
	SSL_CTX_set_default_passwd_cb(ctx, IoSecureSockets_Password_Callback);
	SSL_CTX_set_default_passwd_cb_userdata(ctx, self);
	SSL_CTX_set_verify(ctx, SSL_VERIFY_NONE, IoSecureSockets_Verify_Callback);
	
	#ifdef DTLS_IMPLEMENTED
	IoObject_setSlot_to_(self, IOSYMBOL("supportsDTLS"), IOTRUE(self));
	#else
	IoObject_setSlot_to_(self, IOSYMBOL("supportsDTLS"), IOFALSE(self));
	#endif
	//doc SecureServer supportsDTLS Returns true if server supports DTLS, false otherwise.

	IoState_registerProtoWithFunc_((IoState *)state, self, IoSecureServer_proto);
	
	{
		IoMethodTable methodTable[] = {
		{"setKeyFile", IoSecureServer_setKeyFile},
		//doc SecureServer setKeyFile(path) Sets the key file. Returns self.
		
		{"setCertFile", IoSecureServer_setCertFile},
		//doc SecureServer setCertFile(path) Sets the certificate file. Returns self.
		
		{"setCAFile", IoSecureServer_setCAFile},
		//doc SecureServer setCAFile(path) Sets the CA file. Returns self.
		
		{"setCRLFile", IoSecureServer_setCRLFile},
		//doc SecureServer setCRLFile(path) Sets the CRL file. Returns self.
		
		{"useTLS", IoSecureServer_useTLS},
		//doc SecureServer useTLS Returns useTLS value.

		{"useDTLS", IoSecureServer_useDTLS},
		//doc SecureServer useDTLS Returns useDTLS value.

		{"setRequiresClientCertificate", IoSecureServer_setRequiresClientCertificate},
		//doc SecureServer setRequiresClientCertificate(aBool) Sets the requires client certificate attribute. Returns self.
		
		{"tlsWrap", IoSecureServer_tlsWrap},
		//doc SecureServer tlsWrap Returns tlsWrap value.
		
		#ifdef DTLS_IMPLEMENTED
		{"dtlsWrap", IoSecureServer_dtlsWrap},
		//doc SecureServer dtlsWrap Returns dtlsWrap value.
		
		{"udpRecvIP", IoSecureServer_udpRecvIP},
		//doc SecureServer udpRecvIP Returns udpRecvIP value.
		
		{"dispatchUdp", IoSecureServer_dispatchUDP},
		//doc SecureServer dispatchUdp Returns dispatchUdp value.
		
		#endif
		{NULL, NULL}
		};
		IoObject_addMethodTable_(self, methodTable);
	}
	
	return self;
}
Ejemplo n.º 8
0
Archivo: IoFile.c Proyecto: achoy/io
IoFile *IoFile_proto(void *state)
{
	IoMethodTable methodTable[] = {
	{"descriptor", IoFile_descriptor},
	{"descriptorId", IoFile_descriptor}, // compatible with Socket
	// standard I/O
	{"standardInput", IoFile_standardInput},
	{"standardOutput", IoFile_standardOutput},
	{"standardError", IoFile_standardError},

	// path
	{"setPath", IoFile_setPath},
	{"path", IoFile_path},
	{"name", IoFile_lastPathComponent},
	{"temporaryFile", IoFile_temporaryFile},

	// info
	{"exists", IoFile_exists},
	{"size", IoFile_size},

	// open and close
	{"openForReading", IoFile_openForReading},
	{"openForUpdating", IoFile_openForUpdating},
	{"openForAppending", IoFile_openForAppending},
	{"mode", IoFile_mode},

	{"open", IoFile_open},
	{"reopen", IoFile_reopen},
	{"popen", IoFile_popen},
	{"close", IoFile_close},

	{"isOpen", IoFile_isOpen},

	// reading
	{"contents", IoFile_contents},
	{"asBuffer", IoFile_asBuffer},
	{"readLine", IoFile_readLine},
	{"readLines", IoFile_readLines},
	{"readStringOfLength", IoFile_readStringOfLength_},
	{"readBufferOfLength", IoFile_readBufferOfLength_},
	{"readToBufferLength", IoFile_readToBufferLength},
	{"at", IoFile_at},
	{"foreach", IoFile_foreach},
	{"foreachLine", IoFile_foreachLine},

	// writing
	{"write", IoFile_write},
	{"atPut", IoFile_atPut},
	{"flush", IoFile_flush},

	// positioning
	{"rewind", IoFile_rewind},
	{"setPosition", IoFile_position_},
	{"position", IoFile_position},
	{"positionAtEnd", IoFile_positionAtEnd},
	{"isAtEnd", IoFile_isAtEnd},

	// other
	{"remove", IoFile_remove},
	{"moveTo", IoFile_moveTo_},
	{"truncateToSize", IoFile_truncateToSize},
/*
	{"makeUnbuffered", IoFile_makeUnbuffered},
	{"makeLineBuffered", IoFile_makeLineBuffered},
	{"makeFullyBuffered", IoFile_makeFullyBuffered},
*/
	{NULL, NULL},
	};

	IoObject *self = IoObject_new(state);
	IoObject_tag_(self, IoFile_newTag(state));

	IoObject_setDataPointer_(self, io_calloc(1, sizeof(IoFileData)));
	DATA(self)->path  = IOSYMBOL("");
	DATA(self)->mode  = IOSYMBOL("r+");
	DATA(self)->flags = IOFILE_FLAGS_NONE;
	IoState_registerProtoWithId_((IoState *)state, self, protoId);

	IoObject_addMethodTable_(self, methodTable);
	IoFile_statInit(self);
	return self;
}
Ejemplo n.º 9
0
Archivo: IoMessage.c Proyecto: ADTSH/io
IoMessage *IoMessage_proto(void *state)
{
	IoMethodTable methodTable[] = {
	{"clone", IoMessage_clone},

	{"name", IoMessage_protoName},
	{"setName", IoMessage_protoSetName},

	{"next", IoMessage_next},
	{"setNext", IoMessage_setNext},
	{"isEndOfLine", IoMessage_isEOL},
	{"nextIgnoreEndOfLines", IoMessage_nextIgnoreEOLs},
	{"last", IoMessage_last},
	{"lastBeforeEndOfLine", IoMessage_lastBeforeEOL},

	{"argAt", IoMessage_argAt},
	{"arguments", IoMessage_arguments},
	{"setArguments", IoMessage_setArguments},
	{"appendArg", IoMessage_appendArg},
	{"appendCachedArg", IoMessage_appendCachedArg},
	{"argCount", IoMessage_argCount_},

	{"cachedResult", IoMessage_cachedResult},
	{"setCachedResult", IoMessage_setCachedResult},
	{"removeCachedResult", IoMessage_removeCachedResult},
	{"hasCachedResult", IoMessage_hasCachedResult},

	{"lineNumber", IoMessage_lineNumber},
	{"setLineNumber", IoMessage_setLineNumber},

	{"characterNumber", IoMessage_characterNumber},
	{"setCharacterNumber", IoMessage_setCharacterNumber},

	{"label", IoMessage_label},
	{"setLabel", IoMessage_setLabel},

	{"code", IoMessage_descriptionString},
	{"doInContext", IoMessage_doInContext},
	{"fromString", IoMessage_fromString},
	{"argsEvaluatedIn", IoMessage_argsEvaluatedIn},
	{"asString", IoMessage_asString},

	{"asMessageWithEvaluatedArgs", IoMessage_asMessageWithEvaluatedArgs},

	{"opShuffle", IoMessage_opShuffle},
	{"opShuffleC", IoMessage_opShuffle},
	
	#ifdef IOMESSAGE_HASPREV
	{"previous", IoMessage_previous},
	#endif

	{NULL, NULL},
	};

	IoObject *self = IoObject_new(state);
	IoMessageData *d;
	IoObject_setDataPointer_(self, io_calloc(1, sizeof(IoMessageData)));
	d = IoObject_dataPointer(self);

	IoObject_tag_(self, IoMessage_newTag(state));
	d->args  = List_new();
	d->name  = IOSYMBOL("[unnamed]");
	d->label = IOSYMBOL("[unlabeled]");
	//d->charNumber = -1;
	d->lineNumber = -1;
	IoState_registerProtoWithId_((IoState *)state, self, protoId);

	IoObject_addMethodTable_(self, methodTable);
	return self;
}
Ejemplo n.º 10
0
Archivo: IoSyslog.c Proyecto: BMeph/io
IoSyslog *IoSyslog_rawClone(IoSyslog *proto)
{
	IoObject *self = IoObject_rawClonePrimitive(proto);
	IoObject_setDataPointer_(self, cpalloc(IoObject_dataPointer(proto), sizeof(IoSyslogData)));
	return self;
}
Ejemplo n.º 11
0
Archivo: IoTagDB.c Proyecto: ADTSH/io
IoTagDB *IoTagDB_rawClone(IoTagDB *proto)
{
	IoObject *self = IoObject_rawClonePrimitive(proto);
	IoObject_setDataPointer_(self, TagDB_new());
	return self;
}
Ejemplo n.º 12
0
IoCurses *IoCurses_proto(void *state)
{
	IoObject *self = IoObject_new(state);
	IoObject_tag_(self, IoCurses_newTag(state));

	IoObject_setDataPointer_(self, calloc(1, sizeof(IoCursesData)));
	IoState_registerProtoWithFunc_(state, self, IoCurses_proto);

	{
		IoMethodTable methodTable[] = {
		{"begin", IoCurses_begin},
		{"end",      IoCurses_end},

		//{"nodelay",  IoCurses_nodelay},
		//{"cBreak",   IoCurses_cBreak},
		//{"noCBreak", IoCurses_noCBreak},
		//{"echo",   IoCurses_echo},
		//{"noEcho", IoCurses_noEcho},
		{"move",   IoCurses_move},
		{"write",  IoCurses_print},
		{"writeCharacter", IoCurses_writeCharacter},
		//{"insert", IoCurses_insert},
		//{"delete", IoCurses_delete},
		//{"get",    IoCurses_get},
		{"asyncReadCharacter",  IoCurses_getCh},
		//{"input",  IoCurses_input},
		//{"erase",  IoCurses_erase},
		{"clear",  IoCurses_clear},
		//{"clearToEndOfLine", IoCurses_clearToEndOfLine},
		{"refresh",  IoCurses_refresh},

		{"x", IoCurses_x},
		{"y", IoCurses_y},

		{"width",    IoCurses_width},
		{"height",   IoCurses_height},

		{"hasColors", IoCurses_hasColors},

		{"setBackgroundBlack",   IoCurses_setBackgroundBlack},
		{"setBackgroundBlue",    IoCurses_setBackgroundBlue},
		{"setBackgroundGreen",   IoCurses_setBackgroundGreen},
		{"setBackgroundCyan",    IoCurses_setBackgroundCyan},
		{"setBackgroundRed",     IoCurses_setBackgroundRed},
		{"setBackgroundMagenta", IoCurses_setBackgroundMagenta},
		{"setBackgroundYellow",  IoCurses_setBackgroundYellow},
		{"setBackgroundWhite",   IoCurses_setBackgroundWhite},

		{"setForegroundBlack",   IoCurses_setForegroundBlack},
		{"setForegroundBlue",    IoCurses_setForegroundBlue},
		{"setForegroundGreen",   IoCurses_setForegroundGreen},
		{"setForegroundCyan",    IoCurses_setForegroundCyan},
		{"setForegroundRed",     IoCurses_setForegroundRed},
		{"setForegroundMagenta", IoCurses_setForegroundMagenta},
		{"setForegroundYellow",  IoCurses_setForegroundYellow},
		{"setForegroundWhite",   IoCurses_setForegroundWhite},
		{NULL, NULL},
		};

		IoObject_addMethodTable_(self, methodTable);
	}
	return self;
}
Ejemplo n.º 13
0
IoCurses *IoCurses_rawClone(IoCurses *proto)
{
	IoCurses *self = IoObject_rawClonePrimitive(proto);
	IoObject_setDataPointer_(self, cpalloc(DATA(proto), sizeof(IoCursesData)));
	return self;
}
Ejemplo n.º 14
0
IoCairoGlyph *IoCairoGlyph_rawClone(IoCairoGlyph *proto)
{
	IoObject *self = IoObject_rawClonePrimitive(proto);
	IoObject_setDataPointer_(self, cpalloc(IoObject_dataPointer(proto), sizeof(cairo_glyph_t)));
	return self;
}
Ejemplo n.º 15
0
IoDirectory *IoDirectory_rawClone(IoDirectory *proto)
{
	IoObject *self = IoObject_rawClonePrimitive(proto);
	IoObject_setDataPointer_(self, cpalloc(IoObject_dataPointer(proto), sizeof(IoDirectoryData)));
	return self;
}
Ejemplo n.º 16
0
Archivo: IoDate.c Proyecto: Akiyah/io
IoDate *IoDate_proto(void *state)
{
	IoMethodTable methodTable[] = {
	{"asSerialization", IoDate_asSerialization},
	{"fromSerialization", IoDate_fromSerialization},
	{"now", IoDate_now},
	{"clock", IoDate_clock},
	{"copy", IoDate_copy},
	{"cpuSecondsToRun", IoDate_cpuSecondsToRun},
	{"year", IoDate_year},
	{"setYear", IoDate_setYear},
	{"month", IoDate_month},
	{"setMonth", IoDate_setMonth},
	{"day", IoDate_day},
	{"setDay", IoDate_setDay},
	{"hour", IoDate_hour},
	{"setHour", IoDate_setHour},
	{"minute", IoDate_minute},
	{"setMinute", IoDate_setMinute},
	{"second", IoDate_second},
	{"setSecond", IoDate_setSecond},
	{"isDaylightSavingsTime", IoDate_isDaylightSavingsTime},
	{"zone", IoDate_zone},
	{"isDST", IoDate_isDST},
	{"setGmtOffset", IoDate_setGmtOffset},
	{"gmtOffset", IoDate_gmtOffset},
	{"gmtOffsetSeconds", IoDate_gmtOffsetSeconds},
	{"convertToUTC", IoDate_convertToUTC},
	{"convertToZone", IoDate_convertToZone},
	{"convertToLocal", IoDate_convertToLocal},
	{"setToUTC", IoDate_setToUTC},
	{"isValidTime", IoDate_isValidTime},
	{"secondsSince", IoDate_secondsSince_},
	{"secondsSinceNow", IoDate_secondsSinceNow},
	{"isPast", IoDate_isPast},
	//{"dateAfterSeconds", IoDate_dateAfterSeconds_},
	{"asString", IoDate_asString},
	{"asNumber", IoDate_asNumber},
	{"fromNumber", IoDate_fromNumber},
	{"fromString", IoDate_fromString},
	{"print", IoDate_printDate},
	{"+", IoDate_add},
	{"-", IoDate_subtract},
	{"+=", IoDate_addInPlace},
	{"-=", IoDate_subtractInPlace},
	{NULL, NULL},
	};

	IoObject *self = IoObject_new(state);

	IoObject_tag_(self, IoDate_newTag(state));
	IoObject_setDataPointer_(self, Date_new());

	/*doc Date format
	Returns the format string for the receiver. The default is "%Y-%m-%d %H:%M:%S %Z".
	*/
	
	IoObject_setSlot_to_(self, IOSYMBOL("format"), IOSYMBOL("%Y-%m-%d %H:%M:%S %Z"));
	IoState_registerProtoWithFunc_((IoState *)state, self, IoDate_proto);

	IoObject_addMethodTable_(self, methodTable);
	return self;
}
Ejemplo n.º 17
0
IoCairoRectangle *IoCairoRectangle_rawClone(IoCairoRectangle *proto)
{
	IoObject *self = IoObject_rawClonePrimitive(proto);
	IoObject_setDataPointer_(self, cpalloc(IoObject_dataPointer(proto), sizeof(cairo_rectangle_t)));
	return self;
}
Ejemplo n.º 18
0
IoBlowfish *IoBlowfish_rawClone(IoBlowfish *proto)
{
	IoObject *self = IoObject_rawClonePrimitive(proto);
	IoObject_setDataPointer_(self, calloc(1, sizeof(IoBlowfishData)));
	return self;
}
Ejemplo n.º 19
0
IoIPAddress *IoIPAddress_rawClone(IoIPAddress *proto)
{
	IoObject *self = IoObject_rawClonePrimitive(proto);
	IoObject_setDataPointer_(self, IPAddress_new());
	return self;
}
Ejemplo n.º 20
0
IoCairoFontFace *IoCairoFontFace_newWithRawFontFace_(void *state, cairo_font_face_t *face)
{
	IoCairoFontFace *self = IOCLONE(IoState_protoWithInitFunction_(state, IoCairoFontFace_proto));
	IoObject_setDataPointer_(self, face);
	return self;
}
Ejemplo n.º 21
0
IoAsyncRequest *IoAsyncRequest_rawClone(IoAsyncRequest *proto)
{
	IoObject *self = IoObject_rawClonePrimitive(proto);
	IoObject_setDataPointer_(self, calloc(1, sizeof(struct aiocb)));
	return self;
}
Ejemplo n.º 22
0
IoLZOEncoder *IoLZOEncoder_rawClone(IoLZOEncoder *proto)
{
	IoObject *self = IoObject_rawClonePrimitive(proto);
	IoObject_setDataPointer_(self, calloc(1, sizeof(IoLZOData)));
	return self;
}
Ejemplo n.º 23
0
IoTokyoCabinetPrefixCursor *IoTokyoCabinetPrefixCursor_newWithDB_(void *state, void *bdb)
{
	IoObject *self = IoTokyoCabinetPrefixCursor_new(state);
	IoObject_setDataPointer_(self, tcbdbcurnew((TCBDB *)bdb));
	return self;
}
Ejemplo n.º 24
0
IoCairoFontExtents *IoCairoFontExtents_rawClone(IoCairoFontExtents *proto)
{
	IoObject *self = IoObject_rawClonePrimitive(proto);
	IoObject_setDataPointer_(self, cpalloc(EXTENTS(proto), sizeof(cairo_font_extents_t)));
	return self;
}