自学教程：C++ CSTRING函数代码示例

IO_METHOD(IoObject, shellExecute){	LPCTSTR operation;	LPCTSTR file;	LPCTSTR parameters;	LPCTSTR directory;	int displayFlag;	int result;	operation = CSTRING(IoMessage_locals_symbolArgAt_(m, locals, 0));	file = CSTRING(IoMessage_locals_symbolArgAt_(m, locals, 1));	parameters = IoMessage_argCount(m) > 2 ? CSTRING(IoMessage_locals_symbolArgAt_(m, locals, 2)) : NULL;	directory = IoMessage_argCount(m) > 3 ? CSTRING(IoMessage_locals_symbolArgAt_(m, locals, 3)) : NULL;	displayFlag = IoMessage_argCount(m) > 4 ? IoMessage_locals_intArgAt_(m, locals, 4) : SW_SHOWNORMAL;	result = (int)ShellExecute(NULL, operation, file, parameters, directory, displayFlag);	if(result > 32)	{		return self;	}	else	{		return (IoObject *)IoError_newWithMessageFormat_(IOSTATE, "ShellExecute Error %i", result);	}}

IoObject *IoSQLite3_execWithCallback(IoSQLite3 *self,									 IoObject *locals, IoMessage *m, IoSymbol *s, ResultRowCallback *callback){	IoList *results;	if (!DATA(self)->db)	{		IoSQLite3_justOpen(self);		if (!DATA(self)->db)		{			return IONIL(self);		}	}	DATA(self)->results = IOREF(IoList_new(IOSTATE));	if (DATA(self)->debugOn)	{		IoState_print_(IOSTATE, "*** %s ***/n", CSTRING(s));	}	{		char *zErrMsg;		sqlite3_exec(DATA(self)->db, CSTRING(s), callback, self, &zErrMsg);		IoSQLite3_showError(self);	}	results = DATA(self)->results;	DATA(self)->results = NULL;	return results;}

static mlval add_external_ml_value(mlval arg){ char *str, *name;  mlval item = MLUNIT;  mlval current = external_ml_values;  name = CSTRING(FIELD(arg,0));  declare_root(&item, 0);  declare_root(&current, 0);  for(;;){    if (MLISNIL(current)) break;        item = MLHEAD(current);    str  = CSTRING(FIELD(item,0));    if (strcmp(name,str) == 0)      { FIELD(item,1) = FIELD(arg,1);  /* Updates existing record */        break;      };    item = MLUNIT;    current = MLTAIL(current);  };  if (item == MLUNIT)    { external_ml_values = cons(arg,external_ml_values); };  retract_root(&item);  retract_root(&current);  return(MLUNIT);}

IoObject *IoDBI_with(IoDBI *self, IoObject *locals, IoMessage *m){	//doc DBI with(driverName) Get a new connection with the given driver.		IoObject *name = IoMessage_locals_valueArgAt_(m, locals, 0);	if (!ISSYMBOL(name))	{		IoState_error_(IOSTATE, m, "argument 0 to method '%s' must be a Symbol, not a '%s'/n",			CSTRING(IoMessage_name(m)), IoObject_name(name));		return IONIL(self);	}	if (DATA(self)->didInit != 1)	{		IoDBI_init(self, locals, m);	}	dbi_conn c = dbi_conn_new(CSTRING(name));	if (c == NULL)	{		IoState_error_(IOSTATE, m, "libdbi error during dbi_conn_new/n");		return IONIL(self);	}	return IoDBIConn_new(IOSTATE, c);}

IoDynLib *IoDynLib_callPluginInitFunc(IoDynLib *self, IoObject *locals, IoMessage *m){	/*doc DynLib callPluginInit(functionName)	Call's the dll function of the specified name. 	Returns the result as a Number or raises an exception on error.	*/		intptr_t rc = 0;	intptr_t *params = NULL;	void *f = DynLib_pointerForSymbolName_(DATA(self),									CSTRING(IoMessage_locals_symbolArgAt_(m, locals, 0)));	if (f == NULL)	{		IoState_error_(IOSTATE, m, "Error resolving call '%s'.",					CSTRING(IoMessage_locals_symbolArgAt_(m, locals, 0)));		return IONIL(self);	}	if (IoMessage_argCount(m) < 1)	{		IoState_error_(IOSTATE, m, "Error, you must give an init function name to check for.");		return IONIL(self);	}	params = io_calloc(1, sizeof(intptr_t) * 2);	params[0] = (intptr_t)IOSTATE;	params[1] = (intptr_t)IOSTATE->lobby;	rc = ((intptr_t (*)(intptr_t, intptr_t))f)(params[0], params[1]);	io_free(params);	return IONUMBER(rc);}

IoObject *IoSQLite_open(IoSQLite *self, IoObject *locals, IoMessage *m){	/*doc SQLite open(optionalPathString)	Opens the database.Returns self on success or nil upon failure.	If the databse is locked, "yield" will be called until it is 	accessable or timeoutSeconds has expired.	*/	char *zErrMsg;	if (DATA(self)->debugOn)	{		IoState_print_(IOSTATE, "IoSQLite opening '%s'/n", CSTRING(DATA(self)->path));	}	DATA(self)->db = sqlite_open(CSTRING(DATA(self)->path), 0, &zErrMsg);	if (!DATA(self)->db)	{		IoSQLite_error_(self, zErrMsg);	}	else	{		IoSQLite_error_(self, "");	}	sqlite_busy_handler(DATA(self)->db, IoSQLite_busyHandler, self);	sqlite_busy_timeout(DATA(self)->db, DATA(self)->timeoutSeconds*1000);	return self;}

VALUE rb_digest(int argc, VALUE *argv, VALUE self) {    VALUE string, options, method = Qnil;    rb_scan_args(argc, argv, "11", &string, &options);    if (TYPE(options) == T_HASH)        method = rb_hash_aref(options, sMethod);    int algo = NIL_P(method) ? 0 : FIX2INT(method);    return SIZET2NUM(algo == 1 ? djhash(CSTRING(string)) : sdbm(CSTRING(string)));}

IO_METHOD(IoDate, asString){	/*doc Date asString(optionalFormatString)	Returns a string representation of the receiver using thereceivers format. If the optionalFormatString argument is present, thereceiver's format is set to it first. Formatting is according to ANSI Cdate formatting rules.<p><pre>	%a abbreviated weekday name (Sun, Mon, etc.)%A full weekday name (Sunday, Monday, etc.)%b abbreviated month name (Jan, Feb, etc.)%B full month name (January, February, etc.)%c full date and time string%d day of the month as two-digit decimal integer (01-31)%H hour as two-digit 24-hour clock decimal integer (00-23)%I hour as two-digit 12-hour clock decimal integer (01-12)%m month as a two-digit decimal integer (01-12)%M minute as a two-digit decimal integer (00-59)%p either "AM" or "PM"%S second as a two-digit decimal integer (00-59)%U number of week in the year as two-digit decimal integer (00-52)with Sunday considered as first day of the week%w weekday as one-digit decimal integer (0-6) with Sunday as 0%W number of week in the year as two-digit decimal integer (00-52)with Monday considered as first day of the week%x full date string (no time); in the C locale, this is equivalentto "%m/%d/%y".%y year without century as two-digit decimal number (00-99)%Y year with century as four-digit decimal number%Z time zone name (e.g. EST);null string if no time zone can be obtained%% stands for '%' character in output string.</pre>	*/	char *format = "%Y-%m-%d %H:%M:%S %Z";	if (IoMessage_argCount(m) == 1)	{		format = CSTRING(IoMessage_locals_symbolArgAt_(m, locals, 0));	}	else	{		IoObject *f = IoObject_getSlot_(self, IOSYMBOL("format"));		if (ISSEQ(f)) { format = CSTRING(f); }	}	{		UArray *ba = Date_asString(DATA(self), format);		return IoState_symbolWithUArray_copy_(IOSTATE, ba, 0);	}}

VALUE db_postgres_adapter_initialize(VALUE self, VALUE options) {    char *connection_info;    VALUE db, user, pass, host, port, ssl;    Adapter *a = db_postgres_adapter_handle(self);    if (TYPE(options) != T_HASH)        rb_raise(eSwiftArgumentError, "options needs to be a hash");    db   = rb_hash_aref(options, ID2SYM(rb_intern("db")));    user = rb_hash_aref(options, ID2SYM(rb_intern("user")));    pass = rb_hash_aref(options, ID2SYM(rb_intern("password")));    host = rb_hash_aref(options, ID2SYM(rb_intern("host")));    port = rb_hash_aref(options, ID2SYM(rb_intern("port")));    ssl  = rb_hash_aref(options, ID2SYM(rb_intern("ssl")));    if (NIL_P(db))        rb_raise(eSwiftConnectionError, "Invalid db name");    if (NIL_P(host))        host = rb_str_new2("127.0.0.1");    if (NIL_P(port))        port = rb_str_new2("5432");    if (NIL_P(user))        user = sUser;    if (!NIL_P(ssl) && TYPE(ssl) != T_HASH)            rb_raise(eSwiftArgumentError, "ssl options needs to be a hash");    connection_info = (char *)malloc(4096);    snprintf(connection_info, 4096, "dbname='%s' user='%s' password='%s' host='%s' port='%s'",        CSTRING(db), CSTRING(user), CSTRING(pass), CSTRING(host), CSTRING(port));    if (!NIL_P(ssl)) {        append_ssl_option(connection_info, 4096, ssl, "sslmode",      "allow");        append_ssl_option(connection_info, 4096, ssl, "sslcert",      0);        append_ssl_option(connection_info, 4096, ssl, "sslkey",       0);        append_ssl_option(connection_info, 4096, ssl, "sslrootcert",  0);        append_ssl_option(connection_info, 4096, ssl, "sslcrl",       0);    }    a->connection = PQconnectdb(connection_info);    free(connection_info);    if (!a->connection)        rb_raise(eSwiftRuntimeError, "unable to allocate database handle");    if (PQstatus(a->connection) == CONNECTION_BAD)        rb_raise(eSwiftConnectionError, PQerrorMessage(a->connection));    PQsetNoticeProcessor(a->connection, (PQnoticeProcessor)db_postgres_adapter_notice, (void*)self);    PQsetClientEncoding(a->connection, "utf8");    return self;}

IoObject *IoCFFIPointer_castTo(IoCFFIPointer *self, IoObject *locals, IoMessage *m){    IoObject *toType = IoMessage_locals_valueArgAt_(m, locals, 0);    IoObject *o = IoState_on_doCString_withLabel_(IOSTATE, toType, "?typeString", "IoCFFIPointer_castTo");    if(!ISNIL(o)) {        char *typeStr = CSTRING(o);        switch(typeStr[0]) {            case '^':                toType = IOCLONE(toType);                *(DATA(toType)->valuePointer) = *((void **)IoCFFIDataType_ValuePointerFromObject_(toType, self));                return toType;            case '*':                toType = IOCLONE(toType);                IoCFFIDataType_rawSetValue(toType, self);                return toType;            default:                IoState_error_(IOSTATE, m, "Wrong type to cast to.");                break;        }    }    else {        // Mm... well, if the type to cast to does not have a typeString slot,        // it should be an Io Object, so the address stored here is a pointer to an        // Io Object. Simply cast the pointer and return it... dangerous but...                IoObject *obj = (IoObject *)*(DATA(self)->valuePointer);        if(ISOBJECT(obj))            return (IoObject *)*(DATA(self)->valuePointer);    }    return IONIL(self);}

IO_METHOD(IoSeq, replaceMap){	/*doc Sequence replaceMap(aMap)	In the receiver, the keys of aMap replaced with its values. Returns self.	*/	IoMap *map = IoMessage_locals_mapArgAt_(m, locals, 0);	UArray *ba = DATA(self);	IO_ASSERT_NOT_SYMBOL(self);	PHASH_FOREACH(IoMap_rawHash(map), k, v,		{		IoSymbol *subSeq = k;		IoSymbol *otherSeq = v;		if (ISSEQ(otherSeq))		{			UArray_replace_with_(ba, DATA(subSeq), DATA(otherSeq));		}		else		{			IoState_error_(IOSTATE, m,							"argument 0 to method '%s' must be a Map with Sequence values, not '%s'",							CSTRING(IoMessage_name(m)), IoObject_name(otherSeq));		}		}	);

void IoCoroutine_rawPrintBackTrace(IoCoroutine *self){	IoObject *e = IoCoroutine_rawException(self);	IoMessage *caughtMessage = IoObject_rawGetSlot_(e, IOSYMBOL("caughtMessage"));	if (IoObject_rawGetSlot_(e, IOSYMBOL("showStack"))) // sanity check	{		IoState_on_doCString_withLabel_(IOSTATE, e, "showStack", "[Coroutine]");	}	else	{		IoSymbol *error = IoObject_rawGetSlot_(e, IOSYMBOL("error"));		if (error)		{			fputs(CSTRING(error), stderr);			fputs("/n", stderr);		}		else		{			fputs("error: [missing error slot in Exception object]/n", stderr);		}		if (caughtMessage)		{			UArray *ba = IoMessage_asMinimalStackEntryDescription(caughtMessage);			fputs(UArray_asCString(ba), stderr);			fputs("/n", stderr);			UArray_free(ba);		}	}}

	IoValue *IoObject_catchException(IoObject *self, IoObject *locals, IoMessage *m)	{	  IoValue *result;	  IoMessage_assertArgCount_(m, 3);	  {		 IoString *exceptionName = (IoString *)IoMessage_locals_stringArgAt_(m, locals, 0);		 IoExceptionCatch *eCatch = IoState_pushExceptionCatchWithName_((IoState*)self->tag->state, 		   CSTRING(exceptionName));		 TInt r = 0;		 TRAP(r, result = (IoValue*)IoMessage_locals_valueArgAt_(m, locals, 1);				 IoState_popExceptionCatch_((IoState*)self->tag->state, eCatch););		if(r != 0)		{ 		  IoObject_setSlot_to_((IoObject*)locals, USTRING("exceptionName"), eCatch->caughtName);		  if (eCatch->caughtDescription)		  { 			IoObject_setSlot_to_(locals, USTRING("exceptionDescription"), 			  eCatch->caughtDescription); 		  }		  else		  { 			IoObject_setSlot_to_(locals, USTRING("exceptionDescription"), 			  USTRING("<no description>")); 		  }      		  IoState_popExceptionCatch_((IoState*)self->tag->state, eCatch);		  result = (IoValue*)IoMessage_locals_valueArgAt_(m, locals, 2);		}	  }

Uint64Array *IoTagDB_tagArrayForTagNames_(IoTagDB *self, IoMessage *m, IoList *tagNames){	TagDB *tdb = DATA(self);	Uint64Array *tags = Uint64Array_new();	int i;	for (i = 0; i < IoList_rawSize(tagNames); i ++)	{		IoSeq *tagName = IoList_rawAt_(tagNames, i);		symbolid_t keyid;				IOASSERT(ISSEQ(tagName), "tag names must be Sequences");		keyid = TagDB_idForSymbol_size_(tdb, CSTRING(tagName), IoSeq_rawSize(tagName));		Uint64Array_append_(tags, keyid);		/*		{		Datum *keyDatum = TagDB_symbolForId_(tdb, keyid);			printf("%s -> %i && ", CSTRING(tagName), (int)keyid);		printf("%i -> %s/n", (int)keyid, (char *)(keyDatum->data));		Datum_free(keyDatum);		}		*/	}	return tags;}

IO_METHOD(IoSandbox, doSandboxString){	/*doc Sandbox doSandboxString(aString)	Evaluate aString inside the Sandbox.	*/	IoState *boxState = IoSandbox_boxState(self);	char *s = IoMessage_locals_cStringArgAt_(m, locals, 0);	IoObject *result = IoState_doSandboxCString_(boxState, s);	if (ISSYMBOL(result))	{		return IOSYMBOL(CSTRING(result));	}	if (ISSEQ(result))	{		return IOSEQ(IOSEQ_BYTES(result), IOSEQ_LENGTH(result));	}	if (ISNUMBER(result))	{		return IONUMBER(CNUMBER(result));	}	return IONIL(self);}

IoObject *IoFont_drawString(IoFont *self, IoObject *locals, IoMessage *m){	/*doc Font drawString(aString, optionalStartIndex, optionalEndIndex)	Draws aString using the optional start and end indexes, if supplied. Returns self.<p>Note; Fonts are drawn as RGBA pixel maps. These blending options are recommended:<pre>	glEnable(GL_BLEND)glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)</pre>		*/	IoSymbol *textString = IoMessage_locals_seqArgAt_(m, locals, 0);	int startIndex = 0;	int endIndex;	if (IoMessage_argCount(m) > 1)	{		startIndex = IoNumber_asInt(IoMessage_locals_numberArgAt_(m, locals, 1));		if (startIndex > (int)IoSeq_rawSize(textString)) startIndex = (int)IoSeq_rawSize(textString);	}	if (IoMessage_argCount(m) > 2)	{		endIndex = IoNumber_asInt(IoMessage_locals_numberArgAt_(m, locals, 2));	}	else	{		endIndex = IoSeq_rawSize(textString);	}	GLFont_drawString(DATA(self)->font, CSTRING(textString) , startIndex, endIndex);	IoFont_checkError(self, locals, m);	return self;}

IoObject *IoFont_lengthOfString(IoFont *self, IoObject *locals, IoMessage *m){	/*doc Font widthOfString(aString)	Returns a Number with the width that aString would render 	to with the receiver's current settings.	*/	IoSymbol *text = IoMessage_locals_seqArgAt_(m, locals, 0);	int startIndex = 0;	int max = IoSeq_rawSize(text);	int endIndex = max;	if (IoMessage_argCount(m) == 2)	{		startIndex = IoNumber_asInt(IoMessage_locals_numberArgAt_(m, locals, 1));		if (startIndex > max) startIndex = max;	}	if (IoMessage_argCount(m) > 2)	{		endIndex = IoNumber_asInt(IoMessage_locals_numberArgAt_(m, locals, 2));		if (startIndex > max) endIndex = max;	}	return IONUMBER( GLFont_lengthOfString( DATA(self)->font, CSTRING(text), startIndex, endIndex) );}

int IoAVCodec_openFile(IoAVCodec *self){	//AVInputFormat *inputFormat;	IoObject *fileName = IoObject_symbolGetSlot_(self, IOSYMBOL("path"));	int err = av_open_input_file(&DATA(self)->formatContext, CSTRING(fileName), NULL, 0, NULL);	return err;}

IoObject *IoAVCodec_open(IoAVCodec *self, IoObject *locals, IoMessage *m){	/*doc AVCodec open	Opens the input file. Return self on success or raises an exception on error.	*/		int err;	IoAVCodec_registerIfNeeded(self);	IoAVCodec_freeContextIfNeeded(self);	IoAVCodec_createContextIfNeeded(self);	DATA(self)->isAtEnd = 0;	err = IoAVCodec_openFile(self);	if (err != 0)	{		IoObject *fileName = IoObject_symbolGetSlot_(self, IOSYMBOL("path"));		IoState_error_(IOSTATE, m, "error %i opening file %s/n", err, CSTRING(fileName));		return IONIL(self);	}	IoAVCodec_findStreams(self);	av_read_play(DATA(self)->formatContext);	return self;}

VALUE db_postgres_statement_initialize(VALUE self, VALUE adapter, VALUE sql) {    PGresult *result;    Statement *s = db_postgres_statement_handle(self);    Adapter *a   = db_postgres_adapter_handle_safe(adapter);    snprintf(s->id, 128, "s%s", CSTRING(rb_uuid_string()));    s->adapter = adapter;    if (!a->native)        sql = db_postgres_normalized_sql(sql);    result = PQprepare(a->connection, s->id, CSTRING(sql), 0, 0);    db_postgres_check_result(result);    PQclear(result);    return self;}

//doc ClutterColor fromString(str)IO_METHOD(IoClutterColor, fromString) {  ClutterColor color;  char *seq = CSTRING(IoMessage_locals_seqArgAt_(m, locals, 0));  clutter_color_from_string(&color, seq);  return IoClutterColor_newWithColor(IOSTATE, color);}