79 bignumber: function(len){

80 var t="";

81 while(len--){

82 t += this.n(9);

83 }

237

238 wprintf( L" %s", arg );

239 while(len-- > 0 && pos < argc) wprintf( L" %s", argv[ ++pos ].c_str() );

240 wprintf( L"\n" );

241 }

114 SPI0CN &= ~(1 << _SPIF);

115

116 while(len--) {

117 SPI0DAT = 0x00;

118 while(!(SPI0CN & (1 << _SPIF)));

132 SPI0CN &= ~(1 << _SPIF);

133

134 while(len--) {

135 SPI0DAT = *_data++;

136 while(!(SPI0CN & (1 << _SPIF)));

380 {

381 NATIVE_PROFILE_CLR_CORE();

382 while(len--)

383 {

384 CLR_RT_HEAPBLOCK_RELOCATE(lst);

166 len = length;

167

168 while(len-- > 0)

169 {

170 buffer[pos++] = iobuffer[head++];

420 int len = length;

421

422 while(len-- > 0)

423 {

424 newBuffer[pos++] = iobuffer[head++];

114 QString str = QString::fromLatin1(chars, len);

115 QChar *uc = str.data();

116 while(len--) {

117 switch(uc->unicode()) {

118 case 0xa4:

87 }

88

89 while(len--) {

90 valueToFilter+= element.attr(filterAttributes[len]) || '';

91

265 STRING_SWAP(char *s1, char *s2, size_t len)

266 {

267 while(len--) {

268 const char t = *s1;

269 *s1++ = *s2;

294 UNICODE_COPY(npy_ucs4 *s1, npy_ucs4 *s2, size_t len)

295 {

296 while(len--) {

297 *s1++ = *s2++;

298 }

303 UNICODE_SWAP(npy_ucs4 *s1, npy_ucs4 *s2, size_t len)

304 {

305 while(len--) {

306 const npy_ucs4 t = *s1;

307 *s1++ = *s2;

77 };

78

79 while(len--){

80 var latlng = this.latlngs[len].latlng;

81 if(!currentBounds.contains(latlng)) { continue; }

102 while(!(SPSR & (1 << SPIF)));

103

104 while(len--)

105 {

106 SPDR = 0x00;

141 while(!(SPSR & (1 << SPIF)));

142

143 while(len--)

144 {

145 SPDR = *data++;

200 void lcd_write(char *s, uint8_t len)

201 {

202 while(len-- != 0)

203 lcd_write_char(*s++);

204 }

220 float total = 0.0;

221

222 while(len-- > 0)

223 if(a->item[len].type == T_NUMBER)

224 total += SQUARE((float) a->item[len].u.number);

256 }

257

258 while(len-- > 0) {

259 if(b->item[len].type == T_NUMBER) {

260 if(a->item[len].type == T_NUMBER)

125 if(tabSize == 0)

126 {

127 while(len-- > 0)

128 buf.append(' ');

129 }

40 len /= sizeof(ALshort); /* len is in bytes */

41

42 while(len--) {

43 sample = *dst + *src;

44

78

79 si = 0;

80 while(len--) {

81 sample = *dst;

82

136

137 #ifndef MMX_SUPPORT

138 while(len--) {

139 sample = *dst;

140

212 CLR_UINT16* p;

213

214 p = pTmp; while(len--) *p++ = ch;

215

216 TINYCLR_CHECK_HRESULT(CLR_RT_HeapBlock_String::CreateInstance( stack.Arg0(), pTmp, tmpArray->m_numOfElements ));

139 len = Math.min(len, $.passy.requirements.length.max);

140

141 while(len--) {

142 type = len % chars.length;

143 index = Math.floor(Math.random() * chars[type].length);

69 void fputl(const char *s, size_t len, FILE *stream)

70 {

71 while(len-- > 0)

72 {

73 fputc(*s++, stream);

46 len /= sizeof(ALshort); /* len is in bytes */

47

48 while(len--) {

49 sample = 0;

50

108

109

110 while(len--) {

111 sample = *srcs0[0];

112 sample += *srcs0[1];

145

146

147 while(len--) {

148 sample = *srcs0[0];

149 sample += *srcs0[1];

158 } else {

159 // fill the region with the given byte

160 while(len--) {

161 rom[offset++] = b;

162 }

344 sSWAP(char *s1, char *s2, size_t len)

345 {

346 while(len--) {

347 const char t = *s1;

348 *s1++ = *s2;

104 while(!(SPSR & (1 << SPIF)));

105

106 while(len--) {

107 SPDR = 0x00;

108 while(!(SPSR & (1 << SPIF)));

120 while(!(SPSR & (1 << SPIF)));

121

122 while(len--) {

123 SPDR = *data++;

124 while(!(SPSR & (1 << SPIF)));

82 if(s->out != nullptr) {

83 if(s->outcnt + len > s->outlen) return 1;

84 while(len--) s->out[s->outcnt++] = s->in[s->incnt++];

85 } else {

86 s->outcnt += len;

196 if(s->out != nullptr) {

197 if(s->outcnt + len > s->outlen) return 1;

198 while(len--) {

199 s->out[s->outcnt] =

200 #ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOO_FAR

674 totlen -= len;

675 aPtr = o1Arrays[lc];

676 while(len--) *aPtr++ = *mergePtr++;

677 }

678 }

725 o1ArrayLens[256] += len;

726 CurArray = o1Arrays[lc];

727 while(len--) *mergePtr++ = *CurArray++;

728 }

729 }

87 }

88

89 while(len--) {

90 iter = *bpt;

91 iter *= scaled_sa;

107 ; Write into address starting from rf_buf.buffer[4]

108 MOV R1, #LOW(rf_buf+05H)

109 ; while(len--)

110 WHILE_LOOP?2:

111 MOV A, R0

133

134 j = 0;

135 while(len--) {

136 #if (CONFIG_CODEC == MAS3587F) || (CONFIG_CODEC == MAS3539F)

137 buf[i++] = 0;

168 len/=4;

169 array_t *arr = allocate_array(len);

170 while(len--)

171 arr->item[len].u.number = trans[len];

172 free_svalue(sp, "str_to_arr");

186 char *trans;

187 in[len] = 0;

188 while(len--)

189 in[len] = sp->u.arr->item[len].u.number;

190

104 RGBA *span = (RGBA *)_span;

105 fixed = hstyle && vstyle;

106 while(len--) {

107 int x_hr;

108 int y_hr;

38 {

39 len = _selections.length;

40 while(len--)

41 {

42 gameObject = _selections[len] as GameObjectVO;

48 {

49 len = _selections.length;

50 while(len--)

51 {

52 gameObject = _selections[len] as GameObjectVO;

116 var newSelections:ArrayCollection = new ArrayCollection();

117 var len:int = indices.length;

118 while(len--)

119 {

120 var index:int = indices[len];

147

148 len = buflen;

149 while(len--)buffer[len] = 0;

150

151 f_l.f = num;

107

108 case PACKET_TYPE_PUTS:

109 while(len--)

110 console_putc(*buf++);

111 console_newline();

130 len -= 2; /* x,y */

131 buf += 2;

132 while(len--)

133 lcd_txData(*buf++);

134 lcd_cs(0);

60 void MspFlashClass::read(unsigned char *flash, unsigned char *dest, int len)

61 {

62 while(len--)

63 *(dest++) = *(flash++);

64 }

72 FCTL3 = FWKEY; // Clear LOCK

73 FCTL1 = FWKEY+WRT; // Enable write

74 while(len--) // Copy data

75 *(flash++) = *(src++);

76 FCTL1 = FWKEY; //Done. Clear WRT

79 FCTL3 = FWKEY; // Clear Lock bit

80 FCTL1 = FWKEY+WRT; // Set Erase bit

81 while(len--) // Copy data

82 *(flash++) = *(src++);

83 FCTL1 = FWKEY; // Done. Clear WRT

106 // remove any server responding slower than acceptable

107 var len = finalCandidates.length;

108 while(len--) {

109 if(finalCandidates[len].runtimeStats['pingMs'] > acceptable) {

110 finalCandidates.splice(len, 1);

297 cbuf_putc(ost,'"');

298

299 while(len--) {

300 switch (*s) {

301 case '"':

215 }

216

217 while(len--)

218 {

219 I2C_SendByte(*buf++);

271 err += I2C_WaitAck();

272

273 while(len--)

274 {

275 *buf++ = I2C_GetByte();

126 len = Math.min(len, $.passy.requirements.length.max);

127

128 while(len--) {

129 type = len % chars.length;

130 index = Math.floor(Math.random() * chars[type].length);

90

91 VALUE *ptr = RARRAY_PTR(object);

92 while(len--)

93 {

94 rb_ary_push(new_obj, clone_object(*ptr, tracker));

297

298 unsigned char cp;

299 while(len--) {

300 switch(state) {

301 case AMP:

79 int len = this.Length;

80

81 while(len-- > 0)

82 {

83 if(m_image[m_startPosition+len] != other.m_image[other.m_startPosition+len])

92 if(s->out != 0) {

93 if(s->outcnt + len > s->outlen) return 1;

94 while(len--) s->out[s->outcnt++] = s->in[s->incnt++];

95 } else {

96 s->outcnt += len;

206 if(s->out != 0) {

207 if(s->outcnt + len > s->outlen) return 1;

208 while(len--) {

209 s->out[s->outcnt] =

210 #ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOO_FAR

103 tmp_dptr=(unsigned long *)dest;

104 len>>=3;

105 while(len--!=0)

106 {

107 gost40_loop(back_code, back_code, gost40_key);

115 {

116 bc_offset=(unsigned char *)back_code;

117 while(len--!=0)

118 {

119 if(last_bytes==0)

143 tmp_dptr=(unsigned long *)dest;

144 len>>=3;

145 while(len--!=0)

146 {

147 gost40_loop(back_code, back_code, gost40_key);

32 char *b = _b;

33

34 while(len-- > 0) {

35 if(*a++ != *b++) return 1;

36 }

124 char sbuf[3];

125

126 while(len--){

127 itoa(*buf++, sbuf, 16);

128 if (sbuf[1] == 0) uart_putc(' ');

106 signed char c;

107

108 while(len--)

109 {

110 if ((c = UpperCase(*p) - UpperCase(*q)) != 0) return c;

137 void memucpy(char * tgt, char * src, short int len)

138 {

139 while(len--) *(tgt++) = UpperCase(*(src++));

140 }

141

148 register char c;

149

150 while(len--)

151 {

152 if (((c = UpperCase(*p) - UpperCase(*q)) != 0)

88 // Perform the algorithm on each character in the string, using the lookup table values.

89

90 while(len--)

91 {

92 unsigned char c = *buffer++;

117 // Perform the algorithm on each character in the string, using the lookup table values.

118

119 while(len--)

120 ulCRC = (ulCRC >> 8) ^ crc32_table[(ulCRC & 0xFF) ^ *buffer++];

121 // Exclusive OR the result with the beginning value.

108 intercept: function(arrayOfProperties) {

109 var len = arrayOfProperties.length;

110 while(len--) {

111 var aKey = arrayOfProperties[len];

112 this.interceptedProperties.setObjectForKey(this.attachedEntity[aKey], aKey);

525 };

526

527 while(len-- > -10) {

528 System.out.println("len=" + len);

529 quickSort(predicts, labels, 0, len, cmp);

286 #endif

287 {

288 while(len-- > 0)(*f__putn)(*p++);

289 return(0);

290 }

35 s += 2;

36 putchar('\"');

37 while(len-- > 0) {

38 int c = (*s++) & 0xFF;

39 switch(c) {

217 // bonefish: len was ignored

218 // while(*msg) {

219 while(len--) {

220 a += *msg << 4;

221 a += *msg >> 4;

88

89 var resultDescStr = '';

90 while(len--) {

91 var anEntityDescStr = allEntities[len],

92 anEntityDesc = anEntityDescStr.split(','),

35

36 // Hide the banners that shouldn't be visible

37 while(len--) {

38 if (len > this.options.count-1) {

39 this.lis[len].className = 'hide';

119

120 dprintf("%x: ", (unsigned) b);

121 while(len-- > 0) {

122 dprintf("%b ", *b++);

123 if(++count == 16) {

36

37 var len = subs.length;

38 while(len--){

39 var sub = subs[len];

40 // try {

333 bool I2cWriteBytes(void* I2cMasterHandle, uint8_t* Buf, uint8_t Len)

334 {

335 while(Len--)

336 {

337 if(!I2cWriteByte(I2cMasterHandle, *(Buf++)))

353 void I2cReadBytes(void* I2cMasterHandle, uint8_t* Buf, uint8_t Len)

354 {

355 while(Len--)

356 {

357 *(Buf++) = I2cReadByte(I2cMasterHandle);

89 });

90

91 while(len--) {

92 if ( vendors[len] + prop in div.style ) {

93 return true;

91 found = results;

92 } else {

93 while(len--){

94 item = results[len];

95 if(item.layerId === layer){

17

18 // loops through all the apps

19 while(len--) {

20 app= settings.INSTALLED_APPS[len];

21

40 ;

41

42 while(len--) {

43 templatePath= settings.TEMPLATE_PATHS;

44

51 inline bool cmp_wi(const wchar *s, const wchar *t, int len)

52 {

53 while(len--) {

54 if(ToUpper(*s++) != ToUpper(*t++))

55 return false;

166 if (signdx > 0)

167 {

168 while(len--)

169 {

170 *addrl &= ~bit;

181 else

182 {

183 while(len--)

184 {

185 *addrl &= ~bit;

269 if (signdx > 0)

270 {

271 while(len--)

272 {

273 *addrl |= bit;

96 - if((((int)buf) & 1) || (len & 1))

97 - {

98 - while(len-- > 0)

99 - *buf++ = *io;

100 +/**

176 - len >>= 1;

177 -

178 - while(len-- > 0)

179 - *ptr16++ = *io | (*io << 8);

180 + if (buf[i] != readb(chip->IO_ADDR_R))

418 }

419

420 while(len-- > 0) {

421 sb.append(ch);

422 }

30

31 // Hide the banners that shouldn't be visible

32 while(len--) {

33 if (len > count-1) {

34 lis[len].className = 'hide';

195 S32 len = str.length();

196 if(len == 0) return rv;

197 while(len--)

198 {

199 if( !LLStringOps::isAlnum((char)str[len]) )

213 S32 len = str.length();

214 if(len == 0) return rv;

215 while(len--)

216 {

217 if(!(LLStringOps::isAlnum((char)str[len]) || (' ' == str[len])))

232 S32 len = str.length();

233 if(len == 0) return rv;

234 while(len--)

235 {

236 llwchar wc = str[len];

104

105 var len:int = level.movies.length;

106 while(len--)

107 {

108 var movie:MovieVO = level.movies[len];

134 var imageFile:File;

135 var newImageFile:File;

136 while(len--)

137 {

138 var obj:Object = level.events[len];

77 void encrypt(const uint8 *plain_text, uint8 *cipher_text, uint32 len)

78 {

79 while(len-- > 0)

80 {

81 if(_pad_len == block_size)

93 void decrypt(const uint8 *cipher_text, uint8 *plain_text, uint32 len)

94 {

95 while(len-- > 0)

96 {

97 if(_pad_len == block_size)

218 s = strings + offset;

219 len >>= 1;

220 while(len--)

221 ps_name.Cat(Read16(s));

222 }

289 while(right--) {(*output)(pad,arg); ++v;}

290 if(sign && *sptr != '-') {(*output)('+',arg);len--;++v;}

291 while(len--) {(*output)(*sptr++,arg);++v;}

292 while(left--) {(*output)(pad,arg);++v;}

293 }

22 if(!len || !v)

23 return s;

24 while(len--)

25 *p->pos++ = *str++;

26 return s;

428 s16 *stepB = fadeSB;

429

430 while(len--)

431 {

432 const u16 s = *src++;

145 u8_t *src0 = (u8_t*)src;

146

147 while(len--) {

148 *dest0++ = *src0++;

149 }

154 u8_t *dest0 = (u8_t*)dest;

155

156 while(len--) {

157 *dest0++ = (s8_t)c;

158 }

140 if (axis == X_AXIS) {

141 if (signdx > 0) {

142 while(len--) {

143 if (rop == RROP_BLACK)

144 *addrl &= ~bit;

157 }

158 } else {

159 while(len--) {

160 if (rop == RROP_BLACK)

161 *addrl &= ~bit;

176 } /* if X_AXIS */ else {

177 if (signdx > 0) {

178 while(len--) {

179 if (rop == RROP_BLACK)

180 *addrl &= ~bit;

41 (*ps) += Len;

42 **ps = '\0'; /* Make sure string is 0-terminated */

43 while(Len--) {

44 *(s + Len) = (char)('0' + (v & 1));

45 v >>= 1;

51 len = len/2;

52

53 while(len--){

54 *buf = bcmswap16(*buf);

55 buf++;

113 fixed = hstyle && vstyle;

114 if(hstyle + vstyle == 0 && fast) {

115 while(len--) {

116 GetIXY();

117 Point l(Int(ix), Int(iy));

127 return;

128 }

129 while(len--) {

130 GetIXY();

131 f32x4 fx, fy;

282 fixed = hstyle && vstyle;

283 if(hstyle + vstyle == 0 && fast) {

284 while(len--) {

285 Point l = interpolator.Get() >> 8;

286 if(l.x > 0 && l.x < maxx && l.y > 0 && l.y < maxy)

36 s32_t len = strlen((char*)s);

37

38 while(len--)

39 {

40 nr ^= ( ( (nr & 63) + nr2 ) * ( (u32_t)(u8_t)*s++) ) + (nr << 8);

36

37 len = all.length;

38 while(len--) {

39 pass = all[len](message);

40 if(pass === false) {

45 if(message instanceof SIPMessage.IncomingRequest) {

46 len = requests.length;

47 while(len--) {

48 pass = requests[len](message);

49 if(pass === false) {

55 else if(message instanceof SIPMessage.IncomingResponse) {

56 len = responses.length;

57 while(len--) {

58 pass = responses[len](message);

59 if(pass === false) {

51 int len = 7;

52

53 while(len--)

54 {

55 nrBits = bit_table[*pIn][0];

50 I8 ICACHE_FLASH_ATTR PROTO_Parse(PROTO_PARSER *parser, U8 *buf, U16 len)

51 {

52 while(len--)

53 PROTO_ParseByte(parser, *buf++);

54

111 //根据链表长度，释放len次

112 len = list->len;

113 while(len--) {

114 next = current->next;

115 // 如果列表有自带的 free 方法，那么先对节点值调用它

304 }

305

306 while(len-- != 0) { // Insert new strings

307

308 head[h1] = p;

394 outPtr[p++] = outPtr[s++];

395

396 while(len-- != 0)

397 outPtr[p++] = outPtr[s++];

398

463 break;

464

465 while(len-- != 0) {

466

467 outPtr[p++] = outPtr[s++];

231 return false;

232 }

233 while(len--){

234 if(!types[len]->is(sctty->types[len])){

235 return false;

42 uint8 *buf = (uint8 *) buffer;

43 uint32 result = 0;

44 while(len--)

45 result = ((result << 8) | (result >> 24)) ^ uint32(*buf++);

46 return result;

86

87 var len:int = localNetworkDiscovery.receivedObjects.length;

88 while(len--)

89 {

90 var om:ObjectMetadataVO = localNetworkDiscovery.receivedObjects.getItemAt(len) as ObjectMetadataVO;

104

105 var len:int = localNetworkDiscovery.receivedObjects.length;

106 while(len--)

107 {

108 var om:ObjectMetadataVO = localNetworkDiscovery.receivedObjects.getItemAt(len) as ObjectMetadataVO;

114

115 len = localNetworkDiscovery.sharedObjects.length;

116 while(len--)

117 {

118 var om:ObjectMetadataVO = localNetworkDiscovery.sharedObjects.getItemAt(len) as ObjectMetadataVO;

122 decode_uintX(in, 8, len);

123 resip::DataStream strm(mId);

124 while(len--){

125 c=in.get();

126 if(c==EOF)

445 decode_uintX(in_auto, 8, len);

446 resip::DataStream strm(mCompressed.mCompressedId);

447 while(len--){

448 c=in_auto.get();

449 if(c==EOF)

552 decode_uintX(in, 16, len);

553 resip::DataStream strm(mSignerIdentity);

554 while(len--){

555 c=in.get();

556 if(c==EOF)

127 w = window[win].win;

128

129 while(len-- > 0) {

130 ch = *data++;

131 /* new line CR, NL */

128 enc28j60_select();

129 enc28j60_tx(ENC28J60_SPI_RBM);

130 while(len--)

131 *(buf++) = enc28j60_rx();

132 enc28j60_release();

138 enc28j60_select();

139 enc28j60_tx(ENC28J60_SPI_WBM);

140 while(len--)

141 enc28j60_tx(*(buf++));

142 enc28j60_release();

124 internal unsafe static void ZeroMemory (byte* src, long len)

125 {

126 while(len-- > 0)

127 *(src + len) = 0;

128 }

152 var len = handlers.length;

153

154 while(len--) {

155 if(uuid === handlers[len]) {

156 handlers.splice(len, 1);

158 //// internal unsafe static void ZeroMemory( byte* src, long len )

159 //// {

160 //// while(len-- > 0)

161 //// {

162 //// *(src + len) = 0;

82 public void clearInput(ElementReference el) {

83 int len = el.getValue().length();

84 while(len-- >= 0) {

85 el.sendKeys( Keys.BACK_SPACE );

86 }

32 fprinthex(stdout, filepos, 8);

33 printf(": ");

34 while(len--) {

35 uint8_t c = *src++;

36 printf("%02X ", c);

31 interpolator.Begin(x, y, len);

32 RGBA *span = (RGBA *)_span;

33 while(len--) {

34 Point p = interpolator.Get();

35 int h;

144 w = *((USHORT *)ap);

145 len = (USHORT)ZLEN_SHORT(w);

146 while(len--) pTextCharOut('0');

147 putx((ULONG)*((USHORT *)ap));

148 ap += sizeof(int);

181 l = *((ULONG *)ap);

182 len = (USHORT)ZLEN_LONG(l);

183 while(len--) pTextCharOut('0');

184 putx(*((ULONG *)ap));

185 ap += sizeof(long);

59 */

60 synchronized public void write(char cbuf[], int off, int len) throws IOException {

61 while(len-- > 0) {

62 write(cbuf[off++]);

63 }

78 len = strlen(str);

79

80 while(len--) {

81 if(strchr(cs, str[len]))

82 return str + len;

123 return 0;

124

125 while(len--) {

126 if(!strchr(cs, str[len]))

127 return ++len;

46 (*ps) += Len;

47 **ps = '\0'; /* Make sure string is 0-terminated */

48 while(Len--) {

49 *(s + Len) = acHex[v & 15];

50 v >>= 4;

191

192 len = all.length;

193 while(len--) {

194 pass = all[len](message);

195 if(pass === false) {

200 if(message instanceof JsSIP.IncomingRequest) {

201 len = requests.length;

202 while(len--) {

203 pass = requests[len](message);

204 if(pass === false) {

210 else if(message instanceof JsSIP.IncomingResponse) {

211 len = responses.length;

212 while(len--) {

213 pass = responses[len](message);

214 if(pass === false) {

68 {

69 srand(fclk_get_second());

70 while(len--){

71 *buf++ = rand()%255;

72 }

117 len += ((uInt)get_byte(zipped))<<8;

118 /* len is garbage if EOF but the loop below will quit anyway */

119 while(len-- != 0 && get_byte(zipped) != EOF) ;

120 }

121 if((flags & ORIG_NAME) != 0) { /* skip the original file name */