コード例 #1
0
ファイル: sdl2.c プロジェクト: rvedam/interim
Cell* keyfs_open() {
  return alloc_int(1);
}
コード例 #2
0
ファイル: output.c プロジェクト: CharlesJB/mpiGadem
SEXP print_result_R(Sites *site,int nsites,int numSeq,char **seq,char **rseq,int *seqLen,
                    double logev,double **opwm,int pwmLen,int id,char *sdyad,char *pwmConsensus,int numCycle,
                    double pvalueCutoff,double maxpFactor,int *geneID) {

    register int i,j;
    int cn[4];//maxHeaderLen;
    int *seqCn;

    SEXP PWM;
    SEXP seqConsencus;
    SEXP motifname;
    SEXP motifname2;
    SEXP returnData;
    SEXP LengthSequence;

    SEXP SequencesIdent;
    SEXP StrandIdent;
    SEXP AccessionIdent;
    SEXP PositionIdent;
    SEXP SeqIden;
    SEXP PValue;
    SEXP GADEMList;

    PROTECT(returnData=NEW_LIST(5));
    PROTECT(GADEMList=NEW_LIST(6));


    PROTECT(PWM=allocMatrix(REALSXP,4,pwmLen));
    PROTECT(seqConsencus=NEW_CHARACTER(1));
    PROTECT(motifname=NEW_INTEGER(1));
    PROTECT(motifname2=NEW_CHARACTER(1));
    PROTECT(SequencesIdent=NEW_CHARACTER(nsites));
    PROTECT(PositionIdent=NEW_INTEGER(nsites));
    PROTECT(SeqIden=NEW_INTEGER(nsites));
    PROTECT(StrandIdent=NEW_CHARACTER(nsites));
    PROTECT(AccessionIdent=NEW_INTEGER(nsites));
    PROTECT(PValue=NEW_NUMERIC(nsites));
    PROTECT(LengthSequence=NEW_INTEGER(nsites));

    int increment_sequence=0;
    int compt=0;
    seqCn=alloc_int(numSeq);

    //maxHeaderLen=min(maxHeaderLen,MAX_SEQ_HEADER);

    for (i=0; i<numSeq; i++) seqCn[i]=0;
    for (i=0; i<nsites; i++) seqCn[site[i].seq]++;

    for (i=0; i<4; i++) cn[i]=0;
    for (i=0; i<numSeq; i++) {
        if (seqCn[i]==0) cn[0]++;
        if (seqCn[i]==1) cn[1]++;
        if (seqCn[i]==2) cn[2]++;
        if (seqCn[i]>2)  cn[3]++;
    }
    if (seqCn) {
        free(seqCn);
        seqCn=NULL;
    }

    for (i=0; i<nsites; i++) {
        //SET_STRING_ELT(AccessionIdent,increment_sequence,mkChar(geneID[site[i].seq]));
        INTEGER(AccessionIdent)[increment_sequence]=(geneID[site[i].seq]);

        if (site[i].rev=='0') {
            if (site[i].pos<0) {
                char sequence_conca[100]="";
                for (j=0; j<pwmLen+site[i].pos; j++) {
                    switch(seq[site[i].seq][j]) {
                    case 'a':
                        strcat(sequence_conca,"A");
                        break;
                    case 'c':
                        strcat(sequence_conca,"C");
                        break;
                    case 'g':
                        strcat(sequence_conca,"G");
                        break;
                    case 't':
                        strcat(sequence_conca,"T");
                        break;
                    case 'n':
                        strcat(sequence_conca,"N");
                        break;
                    default:
                        break;
                    }
                }
            }
            else {
                char sequence_conca[100]="";
                for (j=site[i].pos; j<min(seqLen[site[i].seq],site[i].pos+pwmLen); j++) {
                    switch(seq[site[i].seq][j]) {
                    case 'a':
                        strcat(sequence_conca,"A");
                        break;
                    case 'c':
                        strcat(sequence_conca,"C");
                        break;
                    case 'g':
                        strcat(sequence_conca,"G");
                        break;
                    case 't':
                        strcat(sequence_conca,"T");
                        break;
                    case 'n':
                        strcat(sequence_conca,"N");
                        break;
                    default:
                        break;
                    }
                }
                SET_STRING_ELT(SequencesIdent,increment_sequence,mkChar(sequence_conca));
            }

            // print flanking region
            for (j=site[i].pos+pwmLen; j<min(site[i].pos+pwmLen+FLANKING_BASES,seqLen[site[i].seq]); j++)

                SET_STRING_ELT(StrandIdent,increment_sequence,mkChar("+"));
            INTEGER(SeqIden)[increment_sequence]=site[i].seq+1;
            INTEGER(PositionIdent)[increment_sequence]=site[i].pos+1;
            DOUBLE_DATA(PValue)[increment_sequence]=site[i].pvalue;
            increment_sequence=increment_sequence+1;
        }
        else {

            if (site[i].pos<0) {
                char sequence_conca[50]="";
                //for (j=site[i].pos; j<0; j++) fprintf(fq,"X");
                for (j=0; j<pwmLen+site[i].pos; j++) {
                    switch(rseq[site[i].seq][j]) {
                    case 'a':
                        strcat(sequence_conca,"A");
                        break;
                    case 'c':
                        strcat(sequence_conca,"C");
                        break;
                    case 'g':
                        strcat(sequence_conca,"G");
                        break;
                    case 't':
                        strcat(sequence_conca,"T");
                        break;
                    case 'n':
                        strcat(sequence_conca,"N");
                        break;
                    default:
                        break;
                    }
                }
            }
            else {
                char sequence_conca[50]="";
                for (j=site[i].pos; j<min(seqLen[site[i].seq],site[i].pos+pwmLen); j++) {
                    switch(rseq[site[i].seq][j]) {
                    case 'a':
                        strcat(sequence_conca,"A");
                        break;
                    case 'c':
                        strcat(sequence_conca,"C");
                        break;
                    case 'g':
                        strcat(sequence_conca,"G");
                        break;
                    case 't':
                        strcat(sequence_conca,"T");
                        break;
                    case 'n':
                        strcat(sequence_conca,"N");
                        break;
                    default:
                        break;
                    }
                }
                SET_STRING_ELT(SequencesIdent,increment_sequence,mkChar(sequence_conca));
            }
            if (site[i].pos+pwmLen-seqLen[site[i].seq]>0) {
                //for (j=seqLen[site[i].seq]; j<site[i].pos+pwmLen; j++) fprintf(fq,"X");
            }
            // print flanking region
            for (j=site[i].pos+pwmLen; j<min(site[i].pos+pwmLen+FLANKING_BASES,seqLen[site[i].seq]); j++)
                SET_STRING_ELT(StrandIdent,increment_sequence,mkChar("-"));
            INTEGER(SeqIden)[increment_sequence]=site[i].seq+1;
            INTEGER(PositionIdent)[increment_sequence]=seqLen[site[i].seq]-site[i].pos;
            DOUBLE_DATA(PValue)[increment_sequence]=site[i].pvalue;
            increment_sequence=increment_sequence+1;

        }
    }


    for (int aa=0; aa<pwmLen; aa++)
    {
        for(int bb=0; bb<4; bb++)
        {
            NUMERIC_DATA(PWM)[compt]=opwm[aa][bb];
            compt++;
        }
    }


    SET_STRING_ELT(seqConsencus,0,mkChar(pwmConsensus));
    INTEGER(LengthSequence)[0]=125;
    INTEGER(motifname)[0]=id;

    const char base[] = "m";
    char filename [ FILENAME_MAX ];
    int number = id;
    sprintf(filename, "%s%d", base, number);

    SET_STRING_ELT(motifname2,0,mkChar(filename));

    SET_VECTOR_ELT(returnData,0,seqConsencus);
    SET_VECTOR_ELT(returnData,2,LengthSequence);
    SET_VECTOR_ELT(returnData,4,motifname2);
    SET_VECTOR_ELT(returnData,1,PWM);
    SET_VECTOR_ELT(GADEMList,0,SequencesIdent);
    SET_VECTOR_ELT(GADEMList,1,StrandIdent);
    SET_VECTOR_ELT(GADEMList,2,PositionIdent);
    SET_VECTOR_ELT(GADEMList,3,PValue);
    SET_VECTOR_ELT(GADEMList,4,AccessionIdent);
    SET_VECTOR_ELT(GADEMList,5,SeqIden);

    SET_VECTOR_ELT(returnData,3,GADEMList);

    UNPROTECT(13);
    return (returnData);

}
コード例 #3
0
ファイル: ExternalInterface.cpp プロジェクト: bendmorris/lime
value nme_display_object_get_z(value inHandle) { return alloc_int(0); }
コード例 #4
0
ファイル: cgi.c プロジェクト: MattTuttle/neko
/**
	parse_multipart_data : onpart:function:2 -> ondata:function:3 -> void
	<doc>
	Incrementally parse the multipart data. call [onpart(name,filename)] for each part
	found and [ondata(buf,pos,len)] when some data is available
	</doc>
**/
static value parse_multipart_data( value onpart, value ondata ) {
	value buf;
	int len = 0;
	mcontext *c = CONTEXT();
	const char *ctype = ap_table_get(c->r->headers_in,"Content-Type");
	value boundstr;
	val_check_function(onpart,2);
	val_check_function(ondata,3);
	buf = alloc_empty_string(BUFSIZE);
	if( !ctype || strstr(ctype,"multipart/form-data") == NULL )
		return val_null;
	// extract boundary value
	{
		const char *boundary, *bend;
		if( (boundary = strstr(ctype,"boundary=")) == NULL )
			neko_error();
		boundary += 9;
		PARSE_HEADER(boundary,bend);
		len = (int)(bend - boundary);
		boundstr = alloc_empty_string(len+2);
		if( val_strlen(boundstr) > BUFSIZE / 2 )
			neko_error();
		val_string(boundstr)[0] = '-';
		val_string(boundstr)[1] = '-';
		memcpy(val_string(boundstr)+2,boundary,len);
	}
	len = 0;
    if( !ap_should_client_block(c->r) )
		neko_error();
	while( true ) {
		char *name, *end_name, *filename, *end_file_name, *data;
		int pos;
		// refill buffer
		// we assume here that the the whole multipart header can fit in the buffer
		fill_buffer(c,buf,&len);
		// is boundary at the beginning of buffer ?
		if( len < val_strlen(boundstr) || memcmp(val_string(buf),val_string(boundstr),val_strlen(boundstr)) != 0 )
			return discard_body(c);
		name = memfind(val_string(buf),len,"Content-Disposition:");
		if( name == NULL )
			break;
		name = memfind(name,len - (int)(name - val_string(buf)),"name=");
		if( name == NULL )
			return discard_body(c);
		name += 5;
		PARSE_HEADER(name,end_name);
		data = memfind(end_name,len - (int)(end_name - val_string(buf)),"\r\n\r\n");
		if( data == NULL )
			return discard_body(c);
		filename = memfind(name,(int)(data - name),"filename=");
		if( filename != NULL ) {
			filename += 9;
			PARSE_HEADER(filename,end_file_name);
		}
		data += 4;
		pos = (int)(data - val_string(buf));
		// send part name
		val_call2(onpart,copy_string(name,(int)(end_name - name)),filename?copy_string(filename,(int)(end_file_name - filename)):val_null);
		// read data
		while( true ) {
			const char *boundary;
			// recall buffer
			memmove(val_string(buf),val_string(buf)+pos,len - pos);
			len -= pos;
			pos = 0;
			fill_buffer(c,buf,&len);
			// lookup bounds
			boundary = memfind(val_string(buf),len,val_string(boundstr));
			if( boundary == NULL ) {
				if( len == 0 )
					return discard_body(c);
				// send as much buffer as possible to client
				if( len < BUFSIZE )
					pos = len;
				else
					pos = len - val_strlen(boundstr) + 1;
				val_call3(ondata,buf,alloc_int(0),alloc_int(pos));
			} else {
				// send remaining data
				pos = (int)(boundary - val_string(buf));
				val_call3(ondata,buf,alloc_int(0),alloc_int(pos-2));
				// recall
				memmove(val_string(buf),val_string(buf)+pos,len - pos);
				len -= pos;
				break;
			}
		}
	}
	return val_null;
}
コード例 #5
0
ファイル: NekoAPI.cpp プロジェクト: FoxInFreefall/ghostbutter
value  api_alloc_array(int arg1)
{
   if (!gNekoNewArray)
	   return alloc_array(arg1);
	return val_call1(*gNekoNewArray,alloc_int(arg1));
}
コード例 #6
0
ファイル: Uniform.cpp プロジェクト: Amadren/hx-gameplay
// FIXME: assume GLenum is always integral
// DECL: const GLenum getType() const;
value hx_Uniform_getType(value thisObj)
{
    Uniform *_thisObj;
    ValueToObject(thisObj, _thisObj);
    return alloc_int(_thisObj->getType());
}
コード例 #7
0
ファイル: api.cpp プロジェクト: aik6980/systools
static value misc_get_key_state( value key ) {
	int r;
	val_check(key,int);
	r = systools_misc_get_key_state(val_int(key));
	return alloc_int(r);
}
コード例 #8
0
ファイル: Image.cpp プロジェクト: Amadren/hx-gameplay
// DECL: inline unsigned int getWidth() const;
value hx_Image_getWidth(value thisObj)
{
    Image *_thisObj;
    ValueToObject(thisObj, _thisObj);
    return alloc_int(_thisObj->getWidth());
}
コード例 #9
0
ファイル: interp.c プロジェクト: robinp/neko
#define ERASE 0

#define address_int(a)	(((int_val)(a)) | 1)
#define int_address(a)	(int_val*)(a & ~1)

extern field id_add, id_radd, id_sub, id_rsub, id_mult, id_rmult, id_div, id_rdiv, id_mod, id_rmod;
extern field id_get, id_set;
extern value neko_alloc_module_function( void *m, int_val pos, int nargs );
extern char *jit_boot_seq;
extern char *jit_handle_trap;
typedef void (*jit_handle)( neko_vm * );
extern int neko_can_jit();

value NEKO_TYPEOF[] = {
	alloc_int(0),
	alloc_int(2),
	alloc_int(3),
	alloc_int(4),
	alloc_int(5),
	alloc_int(6),
	alloc_int(7),
	alloc_int(8)
};

static void default_printer( const char *s, int len, void *out ) {
	while( len > 0 ) {
		int p = (int)fwrite(s,1,len,(FILE*)out);
		if( p <= 0 ) {
			fputs("[ABORTED]",(FILE*)out);
			break;
コード例 #10
0
ファイル: GL.cpp プロジェクト: ma-gnesium/HxGL
value createProgram( )
{
	return alloc_int(
		glCreateProgram( ) );
}
コード例 #11
0
ファイル: GL.cpp プロジェクト: ma-gnesium/HxGL
value createShader( value shaderType )
{
	return alloc_int(
		glCreateShader(
			(GLenum)val_int( shaderType ) ) );
}
コード例 #12
0
ファイル: GL.cpp プロジェクト: ma-gnesium/HxGL
//WebGL style bind
value createBuffer( )
{
	GLuint bID;
	glGenBuffers( 1, &bID );
	return alloc_int (bID);
}
コード例 #13
0
ファイル: sdl2.c プロジェクト: rvedam/interim
Cell* fbfs_read() {
  return alloc_int(0);
}
コード例 #14
0
ファイル: sdl2.c プロジェクト: rvedam/interim
Cell* fbfs_open() {
  sdl_init(0);
  return alloc_int(1);
}
コード例 #15
0
ファイル: Technique.cpp プロジェクト: Amadren/hx-gameplay
// DECL: unsigned int getPassCount() const;
value hx_Technique_getPassCount(value thisObj)
{
    Technique *_thisObj;
    ValueToObject(thisObj, _thisObj);
    return alloc_int(_thisObj->getPassCount());
}
コード例 #16
0
ファイル: serialize.c プロジェクト: exaphaser/neko_mod
static value unserialize_rec( sbuffer *b, value loader ) {
	switch( read_char(b) ) {
	case 'N':
		return val_null;
	case 'T':
		return val_true;
	case 'F':
		return val_false;
	case 'i':
		return alloc_int(read_int(b));
	case 'I':
		return alloc_int32(read_int(b));
	case 'f':
		{
			tfloat d;
			read_str(b,sizeof(tfloat),&d);
			return alloc_float(d);
		}
	case 's':
		{
			int l = read_int(b);
			value v;
			if( l < 0 || l > max_string_size )
				ERROR();
			v = alloc_empty_string(l);
			add_ref(b,v);
			read_str(b,l,(char*)val_string(v));
			return v;
		}
	case 'o':
		{
			int f;
			value o = alloc_object(NULL);
			add_ref(b,o);
			while( (f = read_int(b)) != 0 ) {
				value fval = unserialize_rec(b,loader);
				alloc_field(o,(field)f,fval);
			}
			switch( read_char(b) ) {
			case 'p':
				{
					value v = unserialize_rec(b,loader);
					if( !val_is_object(v) )
						ERROR();
					((vobject*)o)->proto = (vobject*)v;
				}
				break;
			case 'z':
				break;
			default:
				ERROR();
			}
			return o;
		}
	case 'r':
		{
			int n = read_int(b);
			if( n < 0 || n >= b->nrefs )
				ERROR();
			return b->trefs[b->nrefs - n - 1];
		}
	case 'a':
		{
			int i;
			int n = read_int(b);
			value o;
			value *t;
			if( n < 0 || n > max_array_size )
				ERROR();
			o = alloc_array(n);
			t = val_array_ptr(o);
			add_ref(b,o);
			for(i=0;i<n;i++)
				t[i] = unserialize_rec(b,loader);
			return o;

		}
	case 'p':
		{
			int nargs = read_int(b);
			vfunction *f = (vfunction*)alloc_function((void*)1,nargs,NULL);
			vfunction *f2;
			value name;
			add_ref(b,(value)f);
			name = unserialize_rec(b,loader);
			f2 = (vfunction*)val_ocall2(loader,id_loadprim,name,alloc_int(nargs));
			if( !val_is_function(f2) || val_fun_nargs(f2) != nargs )
				failure("Loader returned not-a-function");
			f->t = f2->t;
			f->addr = f2->addr;
			f->module = f2->module;
			return (value)f;
		}
	case 'L':
		{
			vfunction *f = (vfunction*)alloc_function((void*)1,0,NULL);
			value mname;
			int pos;
			int nargs;
			value env;
			add_ref(b,(value)f);
			mname = unserialize_rec(b,loader);
			pos = read_int(b);
			nargs = read_int(b);
			env = unserialize_rec(b,loader);
			if( !val_is_array(env) )
				ERROR();
			{
				value exp = val_ocall2(loader,id_loadmodule,mname,loader);
				value mval;
				unsigned int i;
				int_val *mpos;
				neko_module *m;
				if( !val_is_object(exp) ) {
					buffer b = alloc_buffer("module ");
					val_buffer(b,mname);
					buffer_append(b," is not an object");
					bfailure(b);
				}
				mval = val_field(exp,id_module);
				if( !val_is_kind(mval,neko_kind_module) ) {
					buffer b = alloc_buffer("module ");
					val_buffer(b,mname);
					buffer_append(b," has invalid type");
					bfailure(b);
				}
				m = (neko_module*)val_data(mval);
				mpos = m->code + pos;
				for(i=0;i<m->nglobals;i++) {
					vfunction *g = (vfunction*)m->globals[i];
					if( val_is_function(g) && g->addr == mpos && g->module == m && g->nargs == nargs ) {
						f->t = VAL_FUNCTION;
						f->env = env;
						f->addr = mpos;
						f->nargs = nargs;
						f->module = m;
						return (value)f;
					}
				}
				{
					buffer b = alloc_buffer("module ");
					val_buffer(b,mname);
					buffer_append(b," has been modified");
					bfailure(b);
				}
			}
			return val_null;
		}
	case 'x':
		{
			value mname = unserialize_rec(b,loader);
			value data = unserialize_rec(b,loader);
			value exports = val_ocall2(loader,id_loadmodule,mname,loader);
			value s;
			if( !val_is_object(exports) ) {
				buffer b = alloc_buffer("module ");
				val_buffer(b,mname);
				buffer_append(b," is not an object");
				bfailure(b);
			}
			s = val_field(exports,id_unserialize);
			if( !val_is_function(s) || (val_fun_nargs(s) != 1 && val_fun_nargs(s) != VAR_ARGS) ) {
				buffer b = alloc_buffer("module ");
				val_buffer(b,mname);
				buffer_append(b," has invalid __unserialize function");
			}
			s = val_call1(s,data);
			add_ref(b,s);
			return s;
		}
	case 'h':
		{
			int i;
			vhash *h = (vhash*)alloc(sizeof(vhash));
			h->ncells = read_int(b);
			h->nitems = read_int(b);
			h->cells = (hcell**)alloc(sizeof(hcell*)*h->ncells);
			for(i=0;i<h->ncells;i++)
				h->cells[i] = NULL;
			for(i=0;i<h->nitems;i++) {
				hcell **p;
				hcell *c = (hcell*)alloc(sizeof(hcell));
				c->hkey = read_int(b);
				c->key = unserialize_rec(b,loader);
				c->val = unserialize_rec(b,loader);
				c->next = NULL;
				p = &h->cells[c->hkey % h->ncells];
				while( *p != NULL )
					p = &(*p)->next;
				*p = c;
			}
			return alloc_abstract(k_hash,h);
		}
	default:
		ERROR();
		return val_null;
	}
}
コード例 #17
0
ファイル: JNI.cpp プロジェクト: haxiomic/lime
	value JObjectToHaxe (JNIEnv *inEnv, JNIType inType, jobject inObject) {

		if (inObject == 0) {

			return alloc_null ();

		}

		if (inType.isUnknownType ()) {

			jclass cls = inEnv->GetObjectClass (inObject);

			if (cls) {

				for (int i = 0; i < jniELEMENTS; i++) {

					if (JNIType::elementClass[i] == 0) continue;

					if (inEnv->IsSameObject (cls, JNIType::elementClass[i])) {

						inType = JNIType ((JNIElement)i, 0);
						break;

					}

				}

				if (inType.isUnknownType ()) {

					for (int i = 0; i < jniELEMENTS; i++) {

						if (JNIType::elementArrayClass[i] == 0) continue;

						if (inEnv->IsSameObject (cls, JNIType::elementArrayClass[i])) {

							inType = JNIType ((JNIElement)i, 1);
							break;

						}

					}

				}

				if (inType.isUnknownType ()) {

					if (inEnv->CallBooleanMethod (cls, isArrayClass)) {

						inType = JNIType (jniUnknown, 1);

					}

				}

			}

			if (inType.isUnknownType ()) {

				inType = JNIType (jniObject, 0);

			}

		}

		if (inType.arrayDepth > 1 || (inType.arrayDepth == 1 && inType.element < jniPODStart)) {

			int len = inEnv->GetArrayLength ((jarray)inObject);
			value result = alloc_array (len);
			JNIType child = inType.elemType ();

			for (int i = 0; i < len; i++) {

				val_array_set_i (result, i, JObjectToHaxe (inEnv, child, inEnv->GetObjectArrayElement ((jobjectArray)inObject, i)));

			}

			return result;

		} else if (inType.arrayDepth == 1) {

			int len = inEnv->GetArrayLength ((jarray)inObject);
			value result = alloc_array (len);

			switch (inType.element) {

				ARRAY_SET (Boolean, jboolean, alloc_bool)
				//ARRAY_SET (Byte, jbyte, alloc_int)
				ARRAY_SET (Char, jchar, alloc_int)
				ARRAY_SET (Short, jshort, alloc_int)
				ARRAY_SET (Int, jint, alloc_int)
				ARRAY_SET (Long, jlong, alloc_int)
				ARRAY_SET (Float, jfloat, alloc_float)
				ARRAY_SET (Double, jdouble, alloc_float)

				case jniByte:
				{
					if (len > 0) {

						jboolean copy;
						jbyte *data = inEnv->GetByteArrayElements ((jbyteArray)inObject, &copy);

						for (int i = 0; i < len; i++) {

							val_array_set_i (result, i, alloc_int (data[i]));

						}

						inEnv->ReleaseByteArrayElements ((jbyteArray)inObject, data, JNI_ABORT);

					}
				}
				break;

			}

			return result;

		} else {
コード例 #18
0
ファイル: SDLSystem.cpp プロジェクト: bubba169/lime
	value System::GetDisplay (int id) {
		
		if (!init) {
			
			id_bounds = val_id ("bounds");
			id_currentMode = val_id ("currentMode");
			id_height = val_id ("height");
			id_name = val_id ("name");
			id_pixelFormat = val_id ("pixelFormat");
			id_refreshRate = val_id ("refreshRate");
			id_supportedModes = val_id ("supportedModes");
			id_width = val_id ("width");
			init = true;
			
		}
		
		int numDisplays = GetNumDisplays ();
		
		if (id < 0 || id >= numDisplays) {
			
			return alloc_null ();
			
		}
		
		value display = alloc_empty_object ();
		alloc_field (display, id_name, alloc_string (SDL_GetDisplayName (id)));
		
		SDL_Rect bounds = { 0, 0, 0, 0 };
		SDL_GetDisplayBounds (id, &bounds);
		alloc_field (display, id_bounds, Rectangle (bounds.x, bounds.y, bounds.w, bounds.h).Value ());
		
		SDL_DisplayMode currentDisplayMode = { SDL_PIXELFORMAT_UNKNOWN, 0, 0, 0, 0 };
		SDL_DisplayMode displayMode = { SDL_PIXELFORMAT_UNKNOWN, 0, 0, 0, 0 };
		
		SDL_GetCurrentDisplayMode (id, &currentDisplayMode);
		
		int numDisplayModes = SDL_GetNumDisplayModes (id);
		value supportedModes = alloc_array (numDisplayModes);
		value mode;
		
		for (int i = 0; i < numDisplayModes; i++) {
			
			SDL_GetDisplayMode (id, i, &displayMode);
			
			if (displayMode.format == currentDisplayMode.format && displayMode.w == currentDisplayMode.w && displayMode.h == currentDisplayMode.h && displayMode.refresh_rate == currentDisplayMode.refresh_rate) {
				
				alloc_field (display, id_currentMode, alloc_int (i));
				
			}
			
			mode = alloc_empty_object ();
			alloc_field (mode, id_height, alloc_int (displayMode.h));
			
			switch (displayMode.format) {
				
				case SDL_PIXELFORMAT_ARGB8888:
					
					alloc_field (mode, id_pixelFormat, alloc_int (ARGB32));
					break;
				
				case SDL_PIXELFORMAT_BGRA8888:
				case SDL_PIXELFORMAT_BGRX8888:
					
					alloc_field (mode, id_pixelFormat, alloc_int (BGRA32));
					break;
				
				default:
					
					alloc_field (mode, id_pixelFormat, alloc_int (RGBA32));
				
			}
			
			alloc_field (mode, id_refreshRate, alloc_int (displayMode.refresh_rate));
			alloc_field (mode, id_width, alloc_int (displayMode.w));
			
			val_array_set_i (supportedModes, i, mode);
			
		}
		
		alloc_field (display, id_supportedModes, supportedModes);
		return display;
		
	}
コード例 #19
0
ファイル: api.cpp プロジェクト: aik6980/systools
static value clipboard_set_text( value text ) {
	val_check(text, string);
	return alloc_int(systools_clipboard_set_text(val_string(text)));
}
コード例 #20
0
ファイル: ExternalInterface.cpp プロジェクト: fserb/RTMidi
value rtmidi_out_getportcount(value obj) {
  RtMidiOut *midiout = (RtMidiOut *)(intptr_t)val_float(obj);
  return alloc_int(midiout->getPortCount());
}
コード例 #21
0
ファイル: api.cpp プロジェクト: aik6980/systools
static value win_show_popup_menu( value w, value m )
{
	val_check_kind(m,k_menu);
	return alloc_int(systools_popup_menu_show( val_hwnd(w), val_menu(m) ));
}
コード例 #22
0
ファイル: ExternalInterface.cpp プロジェクト: fserb/RTMidi
value rtmidi_in_getportcount(value obj) {
  RtMidiIn *midiin = (RtMidiIn *)(intptr_t)val_float(obj);
  return alloc_int(midiin->getPortCount());
}
コード例 #23
0
ファイル: NekoAPI.cpp プロジェクト: FoxInFreefall/ghostbutter
value  api_alloc_int(int arg1)
{
   // TODO int32 ?
	return alloc_int(arg1);
}
コード例 #24
0
ファイル: mysql.c プロジェクト: fantoine/haxe-templo2
/**
	result_get_length : 'result -> int
	<doc>Return the number of rows returned or affected</doc>
**/
static value result_get_length( value o ) {
	if( val_is_int(o) )
		return o;
	val_check_kind(o,k_result);
	return alloc_int( (int)mysql_num_rows(RESULT(o)->r) );
}
コード例 #25
0
ファイル: main.c プロジェクト: MattTuttle/neko
static value read_bytecode( value str, value pos, value len ) {
	size_t rlen = fread(val_string(str)+val_int(pos),1,val_int(len),self);
	return alloc_int(rlen);
}
コード例 #26
0
ファイル: mysql.c プロジェクト: fantoine/haxe-templo2
/**
	result_get_nfields : 'result -> int
	<doc>Return the number of fields in a result row</doc>
**/
static value result_get_nfields( value o ) {
	val_check_kind(o,k_result);
	return alloc_int(RESULT(o)->nfields);
}
コード例 #27
0
ファイル: ofImage.cpp プロジェクト: andyli/openFrameworks
//----------------------------------------------------
inline void  ofImage::allocatePixels(ofPixels &pix, int width, int height, int bpp){

	bool bNeedToAllocate = false;
	if (pix.bAllocated == true){
		if ( (pix.width == width) && (pix.height == height) && (pix.bitsPerPixel == bpp)){
			//ofLog(OF_LOG_NOTICE,"we are good, no reallocation needed");
			bNeedToAllocate = false;
		 } else {
			//delete[] pix.pixels;
			bNeedToAllocate = true;
		 }
	} else {
		bNeedToAllocate = true;
	}

	int byteCount = bpp / 8;

	if (bNeedToAllocate == true){
		pix.width			= width;
		pix.height			= height;
		pix.bitsPerPixel	= bpp;
		pix.bytesPerPixel	= bpp / 8;
		switch (pix.bitsPerPixel){
			case 8:
				pix.glDataType		= GL_LUMINANCE;
				pix.ofImageType		= OF_IMAGE_GRAYSCALE;
				break;
			case 24:
				pix.glDataType		= GL_RGB;
				pix.ofImageType		= OF_IMAGE_COLOR;
				break;
			case 32:
				pix.glDataType		= GL_RGBA;
				pix.ofImageType		= OF_IMAGE_COLOR_ALPHA;
				break;
		}

		//pix.pixels			= new unsigned char[pix.width*pix.height*byteCount];
		pix.pixels			= (unsigned char *) buffer_data(val_to_buffer(val_ocall1(handler, val_id("__newByteData"), alloc_int(pix.width*pix.height*byteCount))));
		pix.bAllocated		= true;
	}
}
コード例 #28
0
ファイル: mysql.c プロジェクト: fantoine/haxe-templo2
/**
	result_next : 'result -> object?
	<doc>
	Return the next row if available. A row is represented
	as an object, which fields have been converted to the
	corresponding Neko value (int, float or string). For
	Date and DateTime you can specify your own conversion
	function using [result_set_conv_date]. By default they're
	returned as plain strings. Additionally, the TINYINT(1) will
	be converted to either true or false if equal to 0.
	</doc>
**/
static value result_next( value o ) {
	result *r;
	unsigned long *lengths = NULL;
	MYSQL_ROW row;
	val_check_kind(o,k_result);
	r = RESULT(o);
	row = mysql_fetch_row(r->r);
	if( row == NULL )
		return val_null;
	{
		int i;
		value cur = alloc_object(NULL);
		r->current = row;
		for(i=0;i<r->nfields;i++)
			if( row[i] != NULL ) {
				value v;
				switch( r->fields_convs[i] ) {
				case CONV_INT:
					v = alloc_int(atoi(row[i]));
					break;
				case CONV_STRING:
					v = alloc_string(row[i]);
					if( r->conv_string != NULL )
						v = val_call1(r->conv_string,v);
					break;
				case CONV_BOOL:
					v = alloc_bool( *row[i] != '0' );
					break;
				case CONV_FLOAT:
					v = alloc_float(atof(row[i]));
					break;
				case CONV_BINARY:
					if( lengths == NULL ) {
						lengths = mysql_fetch_lengths(r->r);
						if( lengths == NULL )
							val_throw(alloc_string("mysql_fetch_lengths"));
					}
					v = copy_string(row[i],lengths[i]);
					if( r->conv_bytes != NULL )
						v = val_call1(r->conv_bytes,v);
					break;
				case CONV_DATE:
					if( r->conv_date == NULL )
						v = alloc_string(row[i]);
					else {
						struct tm t;
						sscanf(row[i],"%4d-%2d-%2d",&t.tm_year,&t.tm_mon,&t.tm_mday);
						t.tm_hour = 0;
						t.tm_min = 0;
						t.tm_sec = 0;
						t.tm_isdst = -1;
						t.tm_year -= 1900;
						t.tm_mon--;
						v = val_call1(r->conv_date,alloc_int32((int)mktime(&t)));
					}
					break;
				case CONV_DATETIME:
					if( r->conv_date == NULL )
						v = alloc_string(row[i]);
					else {
						struct tm t;
						sscanf(row[i],"%4d-%2d-%2d %2d:%2d:%2d",&t.tm_year,&t.tm_mon,&t.tm_mday,&t.tm_hour,&t.tm_min,&t.tm_sec);
						t.tm_isdst = -1;
						t.tm_year -= 1900;
						t.tm_mon--;
						v = val_call1(r->conv_date,alloc_int32((int)mktime(&t)));
					}
					break;
				default:
					v = val_null;
					break;
				}
				alloc_field(cur,r->fields_ids[i],v);
			}
		return cur;
	}
}
コード例 #29
0
ファイル: neko-freetype.c プロジェクト: dturing/xinf
void importGlyphPoints( FT_Vector *points, int n, value callbacks, field lineTo, field curveTo, bool cubic ) {
    value arg[4];
    int i;
	if( n==0 ) {
        val_ocall2( callbacks, lineTo, 
                    alloc_int( points[0].x ), alloc_int( points[0].y ) );
	} else if( n==1 ) {
        arg[0] = alloc_int( points[0].x );
        arg[1] = alloc_int( points[0].y );
        arg[2] = alloc_int( points[1].x );
        arg[3] = alloc_int( points[1].y );
        val_ocallN( callbacks, curveTo, arg, 4 );
	} else if( n>=2	) {
		if( cubic ) {
			// printf(stderr,"ERROR: cubic beziers in fonts are not yet implemented.\n");
		} else {
			int x1, y1, x2, y2, midx, midy;
			for( i=0; i<n-1; i++ ) { 
				x1 = points[i].x;
				y1 = points[i].y;
				x2 = points[i+1].x;
				y2 = points[i+1].y;
				midx = x1 + ((x2-x1)/2);
				midy = y1 + ((y2-y1)/2);
                
                arg[0] = alloc_int( x1 );
                arg[1] = alloc_int( y1 );
                arg[2] = alloc_int( midx );
                arg[3] = alloc_int( midy );
                val_ocallN( callbacks, curveTo, arg, 4 );
			}
            arg[0] = alloc_int( x2 );
            arg[1] = alloc_int( y2 );
            arg[2] = alloc_int( points[n].x );
            arg[3] = alloc_int( points[n].y );
            val_ocallN( callbacks, curveTo, arg, 4 );
		}
	} else {
	}
}
コード例 #30
0
ファイル: ZLib.cpp プロジェクト: cobrajs/hxcpp
/**
	deflate_bound : 'dstream -> n:int -> int
	<doc>Return the maximum buffer size needed to write [n] bytes</doc>
**/
static value deflate_bound( value s, value size ) {
	val_check_kind(s,k_stream_def);
	val_check(size,int);
	return alloc_int(deflateBound(val_stream(s),val_int(size)));
}