C++ VAL函数代码示例

void SampleModel::drawLeftHandJoint() {
	glPushMatrix();
	glTranslated(-UPPER_TORSO_RADIUS, 0.6, 0);
	glRotated(20, 0.0, 0.0, -1.0);
	glRotated(90, 0.0, 1.0, 0.0);
	glTranslated(0, 0, -0.2);
	if (VAL(TEXTURESKIN))
		drawTextureCylinder(0.4, 0.2, 0.2);
	else drawCylinder(0.4, 0.2, 0.2);
	glPopMatrix();

	glPushMatrix();
	glTranslated(-UPPER_TORSO_RADIUS - 0.2, 0.8, 0);
	if (VAL(TEXTURESKIN))
		drawTextureSphere(0.4);
	else drawSphere(0.4);
	glPopMatrix();
}

struct LocationRef create_LR_first( RStore *in_store, obj item )
{
  struct LocationRef lr;
  struct VMPageRecord *vmpr;
  struct FirstPageHdr *fph = FIRST_PAGE_HDR_OF(VAL(item));

  assert( OBJ_ISA_PTR(item) );

  assert( in_store == fph->area->owner );

  vmpr = fph->vmpr;

  lr.base_page_num = vmpr->ref.base_page_num;
  lr.nth_page = vmpr->ref.nth_page;
  lr.first = vmpr->ref.first;
  lr.offset = VAL(item) - (UINT_32)vmpr->mem_address;
  lr.indirect = 0;
  return lr;
}

static void UCL_UNUSED
print_list (ucl_node_t N)
{
  ucl_node_t	M = NULL;
  for (; N; N = M) {
    M = ucl_list_cdr(N);
    fprintf(stderr, "%d, ", VAL(N));
  }
  fprintf(stderr, "\n");
}

void Timer<ID>::init(void) {
  // Set Waveform Generator Mode to Normal
  // Set Prescaler to 0
  REG(timer<ID>::control) = 
    CFG(timer<ID>::control::wgm::normal) |
      CFG(timer<ID>::control::prescaler::template value<1>);
  
  // Set Counter to 0
  REG(timer<ID>::counter) = VAL(timer<ID>::counter, 0);
}

void *hash_set(hash_t tab, void *key, void *val) {
	unsigned h = MODHASH(tab, key);
	list_iter_t i = locate(tab, key, h);

	if (enditer(i)) {
		struct hash_node *ele = (struct hash_node*)malloc(sizeof *ele);
		ele->key = key;
		ele->val = val;
		ele->cont = tab;
		ele->hash = h;
		list_insert(list_container(i), i, ele);
		return 0;
	}
	else {
		void *old = VAL(i);
		VAL(i) = val;
		return old;
	}
}

/*
 * anysumto returns the index (0 <= i < n) of the card in hand that brings
 * the s up to t, or -1 if there is none
 */
int
anysumto(CARD hand[], int n, int s, int t)
{
	int i;

	for (i = 0; i < n; i++) {
		if (s + VAL(hand[i].rank) == t)
			return (i);
	}
	return (-1);
}

void SampleModel::drawEyeBandana() {
	setDiffuseColor(COLOR_RED);
	glPushMatrix();
	glTranslated(0, UPPER_TORSO_RADIUS + HEAD_RADIUS + 0.3, 0);
	drawTorus(0.3, 0.5);
	glPopMatrix();
	if (VAL(NINJATURTLE))
		setDiffuseColor(COLOR_GREEN);
	else
		setDiffuseColor(.940f, .816f, .811f);
}

void fhash_print(fenv_t *f, fobj_t *p)
{
    ASSERT(p->type == FOBJ_HASH);
    fhash_t *h = &p->u.hash;

    for (int i = 0; i < h->num_kv; i++) {
        fobj_print(f, KEY(h, i));
        printf(" = ");
        fobj_print(f, VAL(h, i));
    }
}

int problema6EleDiagoCor(matriz* mRes, const matriz* matOri, int a, int b){
	crea_mat(mRes,matOri->ren,1);
	int i;
	for (i = 0; i < matOri->ren; ++i)
	{
		VAL (mRes,i,0)=VAL(matOri,a,b);
		a+=1;
		b+=1;
		if (a>matOri->ren-1)
		{
			a-=matOri->ren;
			b-=matOri->ren;
		}
		if (b>matOri->col-1)
		{
			b-=matOri->col;
		}
	}
	return OK;
}

int main()
{
  _10: LET A$ = "";
  _40: LET B = 12;
  _20: INPUT "What is your name? ", A$;
  _50: INPUT "How old are you? ", B;
  _60: PRINT "Hello ", A$, " who is ", B, " years old";
  _70: LET C$ = STR(B);
  _80: LET D = VAL(C$);
  _90: PRINT "C$ = ", C$, " D = ", D;
}

static void print(mtype *arr)
{
	int i;
	for (i = 0; i < n; ++i) {
		int j;
		for (j = 0; j < n; ++j) {
			printf("%.8Lf ", VAL(arr, i, j));
		}
		printf("\n");
	}
}

int problema10Ajedrez(matriz* mRes, const matriz* matOri, int a, int b){
	crea_mat(mRes,1,matOri->col);
	int i;
	for (i = 0; i < matOri->col; ++i)
	{
		VAL (mRes,0,i)=VAL(matOri,a,b);
		a+=2;
		b+=1;
		if (a>matOri->ren-1)
		{
			a-=matOri->ren;

		}
		if (b>matOri->col-1)
		{
			b-=matOri->col;
		}
	}
	return OK;
}

/* create_block_tree:
 * Construct block tree by peeling nodes from block list in state.
 * When done, return root. The block list is empty
 * FIX: use largest block as root
 */
block_t *createBlocktree(Agraph_t * g, circ_state * state)
{
    block_t *bp;
    block_t *next;
    block_t *root;
    int min;
    /* int        ordercnt; */

    find_blocks(g, state);

    bp = state->bl.first;	/* if root chosen, will be first */
    /* Otherwise, just pick first as root */
    root = bp;

    /* Find node with minimum VAL value to find parent block */
    /* FIX: Should be some way to avoid search below.               */
    /* ordercnt = state->orderCount;  */
    for (bp = bp->next; bp; bp = next) {
	Agnode_t *n;
	Agnode_t *parent;
	Agnode_t *child;
	Agraph_t *subg = bp->sub_graph;

	child = n = agfstnode(subg);
	min = VAL(n);
	parent = PARENT(n);
	for (n = agnxtnode(subg, n); n; n = agnxtnode(subg, n)) {
	    if (VAL(n) < min) {
		child = n;
		min = VAL(n);
		parent = PARENT(n);
	    }
	}
	SET_PARENT(parent);
	CHILD(bp) = child;
	next = bp->next;	/* save next since list insertion destroys it */
	appendBlock(&(BLOCK(parent)->children), bp);
    }
    initBlocklist(&state->bl);	/* zero out list */
    return root;
}

// We are going to override (is that the right word?) the draw()
// method of ModelerView to draw out RobotArm
void RobotArm::draw()
{
	/* pick up the slider values */

	float theta = VAL( BASE_ROTATION );
	float phi = VAL( LOWER_TILT );
	float psi = VAL( UPPER_TILT );
	float cr = VAL( CLAW_ROTATION );
	float h1 = VAL( BASE_LENGTH );
	float h2 = VAL( LOWER_LENGTH );
	float h3 = VAL( UPPER_LENGTH );
	float pc = VAL( PARTICLE_COUNT );


    // This call takes care of a lot of the nasty projection 
    // matrix stuff
	ModelerView::draw();
	static GLfloat lmodel_ambient[] = { 0.4, 0.4, 0.4, 1.0 };
	Mat4f temp = getModelViewMatrix();

	// define the model

	ground(-0.2);
	
	if (true) {
		Ariou();
	} else {
		base(0.8);

	    glTranslatef( 0.0, 0.8, 0.0 );			// move to the top of the base
	    glRotatef( theta, 0.0, 1.0, 0.0 );		// turn the whole assembly around the y-axis. 
		rotation_base(h1);						// draw the rotation base

	    glTranslatef( 0.0, h1, 0.0 );			// move to the top of the base
	    glRotatef( phi, 0.0, 0.0, 1.0 );		// rotate around the z-axis for the lower arm
		glTranslatef( -0.1, 0.0, 0.4 );
		lower_arm(h2);							// draw the lower arm

	    glTranslatef( 0.0, h2, 0.0 );			// move to the top of the lower arm
	    glRotatef( psi, 0.0, 0.0, 1.0 );		// rotate  around z-axis for the upper arm
		upper_arm(h3);							// draw the upper arm

		glTranslatef( 0.0, h3, 0.0 );
		glRotatef(cr, 0.0, 0.0, 1.0);
		claw(1.0);
		SpawnParticles(temp);
	}

	//*** DON'T FORGET TO PUT THIS IN YOUR OWN CODE **/
	endDraw();
}

/*
 * return the number of cards in h having the given rank value
 */
int
numofval(CARD h[], int n, int v)
{
	int i, j;

	j = 0;
	for (i = 0; i < n; i++) {
		if (VAL(h[i].rank) == v)
			++j;
	}
	return (j);
}