コード例 #1
0
ファイル: vars.c プロジェクト: darwin/pacwars2
///////////////////////////////////////////////////////////////////////////
////scvalSameType//////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
bool scvalSameType(_value * val1, _value * val2)
{
	int v1, v2;

	v1 = scvalGetValType(val1);
	v2 = scvalGetValType(val2);
	if (v1 == v2)
		return true;
	if (v1 != v2) {
		if (
			(v1 == valINT && v2 == valPOINTER) ||
			(v2 == valINT && v1 == valPOINTER)) return true;
// if (scvalIsImmidiate(val1))
		{
			switch (v2) {
			case valSHORT:
			case valCHAR:
			case valINT:
				scvalConvToInt(val1);
				return true;
			case valFLOAT:
				scvalConvToFloat(val1);
				return true;
			case valFIXED:
				scvalConvToFixed(val1);
				return true;
			case valDOUBLE:
				scvalConvToDouble(val1);
				return true;
			}
		}
		deb2("Types between `%s' and `%s'\n", sciValTypeStr(v1),
			 sciValTypeStr(v2));
		return false;
	}
//  serr( "Incompatible type between `%s' and `%s'",sciValTypeStr(v1),sciValTypeStr(v2));
	return true;
}
コード例 #2
0
ファイル: mopsohv.cpp プロジェクト: ishaman/CProyects
void evaluate() /* Evaluar las particulas de la poblacion */
{
	unsigned int i, j;
	for(i = 0; i < popsize; i++)
	{
		for(j = 0; j < maxfun; j++)
		{
		    //
			switch(function + j)
			{

				case 100:	/* Kita's primer objetivo */
					popFit[i][j] = kita_f1(i);
					break;
				case 101:	/* Kita's segundo objetivo */
					popFit[i][j] = kita_f2(i);
					break;
				case 200:	/* Kursawe's primer objetivo */
					popFit[i][j] = kursawe_f1(i);
					break;
				case 201:	/* Kursawe's segundo objetivo */
					popFit[i][j] = kursawe_f2(i);
					break;
				case 300:	/* Deb's primer objetivo */
					popFit[i][j] = deb_f1(i);
					break;
				case 301:	/* Deb's segundo objetivo */
					popFit[i][j] = deb_f2(i);
					break;
				case 350:
				//printf("%d %d\n",i,function);
                    deb2(i);
                    break;
				case 400:
                    deb3(i);
                    break;
                case 450:
                    fonseca2(i);
                    break;
				case 500:	/* DTLZ6's primer objetivo */
					popFit[i][j] = DTLZ6_f1(i);
					break;
				case 501:	/* DTLZ6's segundo objetivo */
					popFit[i][j] = DTLZ6_f2(i);
					break;
				case 502:	/* DTLZ1's tercer objetivo */
					popFit[i][j] = DTLZ6_f3(i);
					break;
                case 600:	/* zdt1 primer objetivo*/
					ZDT1(i);
					break;
                case 605:	/* zdt2 primer objetivo*/
					ZDT2(i);
					break;
                case 610:	/* zdt3 primer objetivo*/
					ZDT3(i);
					break;
                case 615:	/* zdt4 primer objetivo*/
                    ZDT4(i);
					break;
                case 620:	/* zdt6 segundo objetivo*/
					ZDT6(i);
					break;
                case 700:
                    DTLZ1(i);
                    break;
                case 705:
                    DTLZ2(i);
                    break;
                case 710:
                    DTLZ3(i);
                    break;
                case 715:
                    DTLZ4(i);
                    break;
                case 720:
                    DTLZ5(i);
                    break;
                case 725:
                    DTLZ6(i);
                    break;
                case 730:
                    DTLZ7(i);
                    break;
	/** Agregar mas aqui **/
			} /* end of switch */
		}
	}
}
コード例 #3
0
ファイル: initial.c プロジェクト: darwin/pacwars2
///////////////////////////////////////////////////////////////////////////
////scsReadDirectInitialization///////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
//returns 0, if all was read and nothing (but push init_end) remains to be
//done, else returns number of bytes to be copied
static int scsReadDirectInitialization(scSymbol * deli, scType * type,
									   bool packed, pmem * dest,
									   int type_size, scSymbol * sym)
{
	_value val;
/* write to inits or consts*/
#if DEBUGLEVEL==0
	deb2(": %s%s", sciValTypeStr(sctypGetValType(type)),
		 packed ? " as packed" : "");
	deb1(" (%db)", type_size);
	if (deli)					//inside a function - initialize on the stack
	{
		deb0(" on the stack\n");
	} else {
		deb0(" on the heap\n");
	}
#endif
	if (type->params && type->params[0]) {

/*******************************************Pointer - OK*/

		if (type->params[0] == '*' /*||(type->params[0]=='['&&type->params[1]==']') */ ) {	//x* t;
			scType inner_type = *type;
			inner_type.params++;
			sctypSimplifyType(&inner_type);
#if DEBUGLEVEL==0
			deb0("* Pointer");
			//Advance;
			deb1(" %s ", ST->lexema);
#endif
			scAssert(scsReadDirectInitialization, type_size == 4);
			scget_back(ST);
/*as STRING*/
			if (ST->lexema[0] == '"') {
				if (sctypGetValType(&inner_type) != valCHAR)
					serr(scErr_Declaration,
						 "Illegal array initialization with string");
				if (deli) {
					_value val1, val2;
					char *s = ST->lexema + 1;
					s[strlen(s) - 1] = 0;
//        j=4;
#if DEBUGLEVEL==0
					deb1("Storing %s\n", s);
#endif
					if (sym) {
						init_start = act.consts.pos;	//inits will be earlier by 4 bytes.
						s = scStrdup(s);
						scvalConstantString(&val2, s);
//           pushstr_pmem(&act.consts,s);
						Gen_Opcode(opvcpuPUSH, &val2, NULL);
					} else {
						pushstr_pmem(&init_end, s);
						push_pmem(&act.consts, 4, s);	//copy to consts anything as pointer
						Gen_Opcode(opvcpuMOV,
								   scvalSetRegister(&val1, valINT, 0),
								   scvalSetRegister(&val2, valINT, regES));
						Gen_Opcode(opvcpuADD,
								   scvalSetRegister(&val1, valINT, 0),
								   scvalSetINT(&val2, init_start));
						scvalSetINT(&val1, init_pos);
						val1.adr.flags = adrBP;
						val1.adr.address = init_pos;
						Gen_Opcode(opvcpuMOV, &val1,
								   scvalSetRegister(&val2, valINT, 0));
					}

					init_start += strlen(s) + 1;
					if (sym) {
						Advance;
						Advance;
						return 0;
					}			//all done
				} else {
					int x = -2, y = init_start + act.inits.pos;
					char *s = ST->lexema + 1;
//        j=4;
					s[strlen(s) - 1] = 0;
#if DEBUGLEVEL==0
					deb1("Storing %s\n", s);
					deb3("(%d,%d,%d)", y, x, act.consts.pos);
#endif
					push_pmem(&act.inits, 4, &y);	//can be anything
					push_pmem(&init_end, 4, &y);	//destination position
					push_pmem(&init_end, 4, &x);	//size=-2:ES
					//copy to consts segment
					push_pmem(&init_end, 4, &act.consts.pos);
#if DEBUGLEVEL==0
					deb1("after %d,", init_end.pos);
#endif
					pushstr_pmem(&act.consts, s);
				}
				Advance;
				Advance;
				return 4;
			} else if (lexeq("{")) {
				serr(scErr_Declaration,
					 "Don't use {} in initialization of pointer.");
			} else
/*as VARIABLE*/
			{					//exit to primitive read
			}
		}						//Pointer*
		else
/*******************************************Table*/

		if (type->params[0] == '[') {	//x t[xx];
			scType tp = *type;
			int tabsize, initsize = 0, inner_type_size;
#if DEBUGLEVEL==0
			deb0("Table");
#endif
			tp.params++;
			tabsize = strtoul(tp.params, &tp.params, 10);
			scAssert(Read_Init_Type[], *tp.params == ']');
			tp.params++;
			sctypSimplifyType(&tp);
			inner_type_size = sctypSizeOf(&tp);
#if DEBUGLEVEL==0
			deb2("[%d] of %d bytes;\n", tabsize, inner_type_size);
#endif
			//Advance;
			if (ST->lexema[0] == '"') {
				char *data;
/*as STRING*/
				if (sctypGetValType(&tp) != valCHAR)
					serr(scErr_Declaration,
						 "Illegal array initialization with string");
#if DEBUGLEVEL==0
				deb1("char[%d] init\n", tabsize);
#endif
				data = scStrdup(ST->lexema + 1);
				data[strlen(data) - 1] = 0;	//erase "
				pushstr_pmem(dest, data);
/*      {char temp[100];
       int i=tabsize-strlen(data)-1;
       while(i)
        if (i>100)
         {push_pmem(dest,100,temp);i-=100;}
         else
         {push_pmem(dest,i,temp);i=0;}
      }*/
				initsize = strlen(data) + 1;
				/*initialize all the data, if packed */
				if (packed && initsize < type_size) {
					char c = 0;
					int i;
					for (i = initsize; i < type_size; i++)
						push_pmem(dest, 1, &c);
					initsize = type_size;
				}
				scFree(data);
				Advance;
				return initsize;
			} else if (lexeq("{")) {
				int i = 0, j;
				for (; i < tabsize; i++) {
					Advance;
					j =
						scsReadDirectInitialization(deli, &tp, true, dest,
													inner_type_size, NULL);
					init_pos += inner_type_size;

					scAssert(scsReadDirectInitialization[], j);	//same here
					initsize += j;
					if (i < tabsize - 1) {
						if (!lexeq(","))
							serr2(scErr_Parse, parse_error, ST->lexema);
					}
				}
				if (lexeq(",")) {
					Advance;
				}
				if (!lexeq("}"))
					serr2(scErr_Parse, parse_error, ST->lexema);
				Advance;
				return initsize;
			} else				//VARIABLE
			{
				serr2(scErr_Parse, parse_error, ST->lexema);
			}
		}						//Table[]
	}