211 {

212

213 while (isspace((u8)**string)) {

214 *string += 1;

215 }

257 {

258 if ((**string == ACPI_ASCII_ZERO) &&

259 (tolower((int)*(*string + 1)) == 'x')) {

260 *string += 2; /* Go past the leading 0x */

261 }

22

23 // These will be compiled as actual function calls.

24 int (*funcs[])(int) = {

25 isascii,

26 islower,

149

150 printf("\n");

151 printf("isspace(-45): %d\n", isspace(-45));

152 printf("isspace( 10): %d\n", isspace(10));

153 printf("isspace('a'): %d\n", isspace('a'));

154 printf("isspace('A'): %d\n", isspace('A'));

155 printf("isspace('5'): %d\n", isspace('5'));

156 printf("isspace('.'): %d\n", isspace('.'));

157 printf("isspace(183): %d\n", isspace(183));

158

159 printf("\n");

48 } while (c);

49

50 CRNLIB_ASSERT((q - pDst) <= (int)dst_len);

51

52 return pDst;

119 const char* p = pBuf;

120

121 while (*p && isspace(*p))

122 p++;

123

189 const char* p = pBuf;

190

191 while (*p && isspace(*p))

192 p++;

193

211 {

212

213 while (isspace((u8)**string)) {

214 *string += 1;

215 }

234

235 if ((**string == ACPI_ASCII_ZERO) &&

236 (tolower((int)*(*string + 1)) == 'x')) {

237 *string += 2; /* Go past the leading 0x */

238 return (TRUE);

118 sizeof(IcuCursor) + /* IcuCursor */

119 nChar * sizeof(UChar) + /* IcuCursor.aChar[] */

120 (nChar+1) * sizeof(int) /* IcuCursor.aOffset[] */

121 );

122 if( !pCsr ){

198 int iWhite = iStart;

199 U8_NEXT(pCsr->aChar, iWhite, pCsr->nChar, c);

200 if( u_isspace(c) ){

201 iStart = iWhite;

202 }else{

118 sizeof(IcuCursor) + /* IcuCursor */

119 nChar * sizeof(UChar) + /* IcuCursor.aChar[] */

120 (nChar+1) * sizeof(int) /* IcuCursor.aOffset[] */

121 );

122 if( !pCsr ){

198 int iWhite = iStart;

199 U16_NEXT(pCsr->aChar, iWhite, pCsr->nChar, c);

200 if( u_isspace(c) ){

201 iStart = iWhite;

202 }else{

124 printf("isxdigit('a'): %d\n", ((*__ctype_b_loc ())[(int) (('a'))] & (unsigned short int) _ISxdigit) != 0);

125 printf("isxdigit('A'): %d\n", ((*__ctype_b_loc ())[(int) (('A'))] & (unsigned short int) _ISxdigit) != 0);

126 printf("isxdigit('5'): %d\n", ((*__ctype_b_loc ())[(int) (('5'))] & (unsigned short int) _ISxdigit) != 0);

147

148 printf("\n");

149 printf("isspace(-45): %d\n", ((*__ctype_b_loc ())[(int) ((-45))] & (unsigned short int) _ISspace) != 0);

150 printf("isspace( 10): %d\n", ((*__ctype_b_loc ())[(int) ((10))] & (unsigned short int) _ISspace) != 0);

151 printf("isspace('a'): %d\n", ((*__ctype_b_loc ())[(int) (('a'))] & (unsigned short int) _ISspace) != 0);

152 printf("isspace('A'): %d\n", ((*__ctype_b_loc ())[(int) (('A'))] & (unsigned short int) _ISspace) != 0);

153 printf("isspace('5'): %d\n", ((*__ctype_b_loc ())[(int) (('5'))] & (unsigned short int) _ISspace) != 0);

154 printf("isspace('.'): %d\n", ((*__ctype_b_loc ())[(int) (('.'))] & (unsigned short int) _ISspace) != 0);

155 printf("isspace(183): %d\n", ((*__ctype_b_loc ())[(int) ((183))] & (unsigned short int) _ISspace) != 0);

156

157 printf("\n");

124 level += indent;

125 while ((c = Getc(str)) != EOF) {

126 if (!isspace(c)) {

127 Ungetc(c, str);

128 break;

190 }

191 } else {

192 if (!empty || !isspace(c)) {

193 Putc(c, ts);

194 empty = 0;

264 level += indent;

265 while ((c = Getc(str)) != EOF) {

266 if (!isspace(c)) {

267 Ungetc(c, str);

268 break;

30 int line_number;

31

32 static char *lex_gets (int);

33 static int lex_token (char *);

34 static void error_context (void);

197 return;

198 fprintf (stderr, "context: ");

199 for (p = lexptr - 1; (p > lexbuf) && (isspace (*p) == FALSE); p--)

200 ;

201 for (q = lexbuf; q < p; q++)

212 static char *skip_wscomments (char *p) {

213 do {

214 while (isspace (*p))

215 p++;

216 while (in_comment && p[0]) {

34

35 #define GET_SIMPLEPIXEL(objPtr) \

36 ((int) (objPtr)->internalRep.twoPtrValue.ptr1)

37

38 #define SET_COMPLEXPIXEL(objPtr, repPtr) \

168 }

169 if (d < 0) {

170 pixelPtr->returnValue = (int) (d - 0.5);

171 } else {

172 pixelPtr->returnValue = (int) (d + 0.5);

298 return TCL_ERROR;

299 }

300 while ((*rest != '\0') && isspace(UCHAR(*rest))) {

301 rest++;

302 }

224 }

225

226 else if ((location == 0) && ((c == _R_CONFE) || isspace(c))) {

227 int _ge = 0;

228 int _ga = 0;

239 }

240 _currentlycont = _lxml->cur - 1;

241 if (isspace(c)) {

242 if ((_ga = _getattributes(fp, parent, _lxml)) < 0) {

243 return (-1);

368

369 /* Allocate for the "check" */

370 tmp2 = (int *) realloc(_lxml->ck, (_lxml->cur + 1) * sizeof(int));

371 if (tmp2 == NULL) {

372 goto fail;

399 */

400 <<__Native,__IsFoldable>> static

401 public function isspace(mixed $cp): mixed;

402

403 /**

192 }

193

194 const base_uint operator++(int)

195 {

196 // postfix operator

209 }

210

211 const base_uint operator--(int)

212 {

213 // postfix operator

312

313 // skip leading spaces

314 while (isspace(*psz))

315 psz++;

316

168 instance Read XFont where

169 -- Internal.

170 readsPrec p str = [(cread (dropWhile isSpace str),[])]

171 where

172 cread s@('-':str) = toXFont (simpleSplit (== '-') str)

198 -- Internal.

199 readsPrec p b =

200 case dropWhile (isSpace) (map toLower b) of

201 'n':'o':'r':'m':'a':'l':xs -> [(NormalWeight,xs)]

202 'm':'e':'d':'i':'u':'m':xs -> [(Medium,xs)]

237 -- Internal.

238 readsPrec p b =

239 case dropWhile (isSpace) (map toLower b) of

240 'l':'u':'c':'i':'d':'a':xs -> [(Lucida,xs)]

241 't':'i':'m':'e':'s':xs -> [(Times,xs)]

20 *

21 * // Increase axis space

22 * $chart->xAxis->axisSpace = .2;

23 * </code>

24 *

96 }

97

98 $reducement = (int) ( $propertyValue - $propertyValue % 360 );

99 $this->properties['angle'] = (float) $propertyValue - $reducement;

100 break;

255 protected function calculateLabelLength( ezcGraphCoordinate $start, ezcGraphCoordinate $end, $xSpace, $ySpace, ezcGraphBoundings $axisBoundings )

256 {

257 $axisSpaceFactor = abs(

258 ( $this->direction->x == 0 ? 0 :

259 $this->direction->x * $ySpace / $axisBoundings->width ) +

66 {

67

68 while ( i < len && ::isspace( str[i] ) ) i++;

69 j = i;

70

71 while ( i < len && ! ::isspace( str[i]) ) i++;

72

73

79 result.push_back( str.substr( j, i - j ));

80

81 while ( i < len && ::isspace( str[i])) i++;

82 j = i;

83 }

138 {

139 if (argCount == 1 ||

140 IsSpaceChar(invocation.Arguments[1]))

141 {

142 var alignmentOp = invocation.Arguments[0].Value;

167 => invocation.Instance != null && !invocation.Instance.IsImplicit;

168

169 private static bool IsSpaceChar(IArgumentOperation argument)

170 => argument.Value.ConstantValue is { HasValue: true, Value: ' ' };

171 }

304 if (!IsAscii()) Standard_OutOfRange::Raise();

305 for ( i = 1 ; i <= Length() ; i ++) {

306 if (!IsSpace((Standard_Character)Value(i))) break;

307 }

308 if( i > 1 ) Remove(1,i-1);

440 if (! IsAscii()) Standard_OutOfRange::Raise();

441 for ( i = Length() ; i >= 1 ; i --) {

442 if (!IsSpace((Standard_Character)Value(i))) break;

443 }

444 if( i < Length() ) Remove(i+1,Length());

48 self.assertRaises(TypeError, self.marshal(b'abc').istitle, 42)

49

50 def test_isspace(self):

51 self.assertFalse(self.marshal(b'').isspace())

52 self.assertFalse(self.marshal(b'a').isspace())

53 self.assertTrue(self.marshal(b' ').isspace())

54 self.assertTrue(self.marshal(b'\t').isspace())

55 self.assertTrue(self.marshal(b'\r').isspace())

56 self.assertTrue(self.marshal(b'\n').isspace())

57 self.assertTrue(self.marshal(b' \t\r\n').isspace())

58 self.assertFalse(self.marshal(b' \t\r\na').isspace())

59 self.assertRaises(TypeError, self.marshal(b'abc').isspace, 42)

46 * @return Non-zero value if either isalpha or isdigit is true for c.

47 */

48 PJ_INLINE(int) pj_isalnum(unsigned char c) { return isalnum(c); }

49

50 /**

55 * alphabetic character.

56 */

57 PJ_INLINE(int) pj_isalpha(unsigned char c) { return isalpha(c); }

58

59 /**

82 * a space character (0x09 - 0x0D or 0x20).

83 */

84 PJ_INLINE(int) pj_isspace(unsigned char c) { return isspace(c); }

85

86 /**

35 a = fgetc(stdin);

36 if (f) {

37 if (a == EOF || isspace(a))

38 {

39 s[i] = '\0';

47 else

48 {

49 if (!(a == EOF || isspace(a)))

50 {

51 f = true;

68 if (f)

69 {

70 if (a == EOF || isspace(a))

71 {

72 s[i] = '\0';

427 const chr8_t* scanp = cptr;

428 while (*scanp && max) {

429 if (!separator && isspace(*scanp)) {

430 subs.push_back(DS::String::FromUtf8(cptr, scanp - cptr));

431 --max;

432 while (*scanp && isspace(*scanp))

433 ++scanp;

434 cptr = scanp;

507

508 char* startp = strbuf;

509 while (isspace(*startp))

510 ++startp;

511 char* scanp;

340 int cnt;

341

342 for (cnt = 0 ; cnt < (int) pmLexRecord -> table -> numNotEOS ; cnt++)

343 {

344 if (pmChar == pmLexRecord -> table -> notEOS [cnt][0])

532 char myChar = pmLexRecord -> line [pmLexRecord -> pos];

533

534 if (!isspace(myChar) || (myChar == NL))

535 {

536 myToken [myPos] = EOS;

588 UINT cnt;

589

590 if (isspace (pmLexRecord -> line [pmLexRecord -> pos + 1]))

591 {

592 return 0;

84

85 /***** check for surplus non-whitespace */

86 while( isspace((int) *end) ) end+=1;

87 if( *end ) goto nothingFound;

88

155

156 /***** check for surplus non-whitespace */

157 while( isspace((int) *end) ) end+=1;

158 if( *end ) break;

159

196

197 /***** check for surplus non-whitespace */

198 while( isspace((int) *end) ) end+=1;

199 if( *end ) goto nothingFound;

200

30 if val != None:

31 val = val.strip()

32 if val != "" and not val.isspace():

33 if len(val)<2:

34 mem = val

54 if val != None:

55 val = val.strip()

56 if val != "" and not val.isspace():

57 rc+=val + " "

58 else:

61 if val != None:

62 val = val.strip()

63 if val != "" and not val.isspace():

64 rc+= val + " "

65 else:

73 boolean calcIndent = false;

74

75 while (Character.isSpaceChar(c) || (c == '\n')) {

76 if (calcIndent) {

77 indent++;

393 char c = getSymbol();

394

395 while (Character.isSpaceChar(c) || (c == '\n')) {

396 if (c == '\n') {

397 putBackSymbol(c);

410

411 char c = getSymbol();

412 while (Character.isSpaceChar(c) || (c == '\n')) {

413 if (c == '\n') {

414 break;

33 return tk_set(tk, start, (int)(end - start),

34 (int)(start - text), (int)(end - text), pos_inc);

35 }

36

156 {

157 int num_bytes;

158 if ((num_bytes = (int)mbrtowc(wchr, s, MB_CUR_MAX, state)) < 0) {

159 const char *t = s;

160 do {

513 *w = 0;

514 ts->t = t;

515 return w_tk_set(&(CTS(ts)->token), wbuf, (int)(start - ts->text),

516 (int)(t - ts->text), 1);

618 }

619

620 i = (int)(t - ts->t);

621 if (i > MAX_WORD_SIZE) {

622 i = MAX_WORD_SIZE - 1;

118

119 static int

120 str_ascii_isspace (const char *text)

121 {

122 return g_ascii_isspace ((gchar) text[0]);

272 remain = sizeof (result);

273

274 if ((int) length <= width)

275 {

276 switch (HIDE_FIT (just_mode))

741 result.cnext_noncomb_char = str_ascii_cnext_noncomb_char;

742 result.cprev_noncomb_char = str_ascii_cprev_noncomb_char;

743 result.char_isspace = str_ascii_isspace;

744 result.char_ispunct = str_ascii_ispunct;

745 result.char_isalnum = str_ascii_isalnum;

36 c = getNextChar(fp,&back);

37 //printf(" %c ",c);

38 if((int)c==EOF)return NULL;

39 else if(c=='-')

40 {

162 lexeme[i++] =c;

163 }

164 else if(isspace(c))

165 {

166 state = 45;

742 state = 45;

743 }

744 else if(isspace(c))

745 {

746 state = 45;

224

225 while(start < end && Character.isWhitespace(array[start])) {

226 if(Character.isSpaceChar(array[start]) || array[start] == '\t') {

227 start++;

228 } else if(stripNewLineFromStart) {

237

238 while(start < end && Character.isWhitespace(array[end - 1])) {

239 if(Character.isSpaceChar(array[end - 1]) || array[start] == '\t') {

240 end--;

241 } else {

20 *

21 * // Increase axis space

22 * $chart->xAxis->axisSpace = .2;

23 * </code>

24 *

96 }

97

98 $reducement = (int) ( $propertyValue - $propertyValue % 360 );

99 $this->properties['angle'] = (float) $propertyValue - $reducement;

100 break;

153 // Get axis space

154 $gridBoundings = null;

155 list( $xSpace, $ySpace ) = $this->getAxisSpace( $renderer, $boundings, $axis, $innerBoundings, $gridBoundings );

156

157 // Determine optimal angle if none specified

160 else

161 {

162 if (isspace( (int) *string ))

163 {

164 wasSpace = 1;

187 if (wasSpace)

188 {

189 if (!isspace( (int) *string ))

190 {

191 count++;

652 if (n == count)

653 {

654 while( *string && !isspace((int)*string) )

655 {

656 *sPtr++ = *string++;

70

71 // If the current character is not a space, we've found a token.

72 if( !isspace( *nextToken ) ) break;

73

74 // If the current space character is a newline,

82 // token.

83 char* result = nextToken;

84 while( nextToken != bufferEnd && !isspace( static_cast< unsigned char >( *nextToken ) ) )

85 ++nextToken;

86

104 // Continue to advance nextToken until we find the space

105 // terminating the token.

106 while( nextToken != bufferEnd && !isspace( *nextToken ) )

107 ++nextToken;

108

13 int i;

14

15 for (i = 0; i < (int)ARRAY_SIZE(color_names); i++) {

16 const char *str = color_names[i];

17 if (!strncasecmp(name, str, len) && !str[len])

64 int val, wordlen = 0;

65

66 while (len > 0 && !isspace(word[wordlen])) {

67 wordlen++;

68 len--;

70

71 ptr = word + wordlen;

72 while (len > 0 && isspace(*ptr)) {

73 ptr++;

74 len--;

21 *

22 * // Increase axis space

23 * $chart->xAxis->axisSpace = .2;

24 * </code>

25 *

96 }

97

98 $reducement = (int) ( $propertyValue - $propertyValue % 360 );

99 $this->properties['angle'] = (float) $propertyValue - $reducement;

100 break;

147 {

148 $gridBoundings = new ezcGraphBoundings(

149 $boundings->x0 + $renderer->xAxisSpace,

150 $boundings->y0 + $renderer->yAxisSpace,

151 $boundings->x1 - $renderer->xAxisSpace,

152 $boundings->y1 - $renderer->yAxisSpace

13 * @property float $nullPosition

14 * The position of the null value.

15 * @property float $axisSpace

16 * Percent of the chart space used to display axis labels and

17 * arrowheads instead of data values.

74 {

75 $this->properties['nullPosition'] = false;

76 $this->properties['axisSpace'] = .1;

77 $this->properties['majorGrid'] = false;

78 $this->properties['minorGrid'] = false;

130 $this->properties['nullPosition'] = (float) $propertyValue;

131 break;

132 case 'axisSpace':

133 if ( !is_numeric( $propertyValue ) ||

134 ( $propertyValue < 0 ) ||

95 *result = cast_num(strtoul(s, &endptr, 16));

96 if (*endptr == '\0') return 1; /* most common case */

97 while (isspace(cast(unsigned char, *endptr))) endptr++;

98 if (*endptr != '\0') return 0; /* invalid trailing characters? */

99 return 1;

486 if (usingSunWorkShop)

487 workshop_file_closed_lineno((char *)buf->b_ffname,

488 (int)buf->b_last_cursor.lnum);

489 #endif

490 vim_free(buf->b_ffname);

894 if (bnr == curbuf->b_fnum)

895 do_current = bnr;

896 else if (do_buffer(command, DOBUF_FIRST, FORWARD, (int)bnr,

897 forceit) == OK)

898 ++deleted;

120 const char *c = env;

121 while ((b != be) && *c && (argc < arge)) {

122 while (isspace(*c) && *c) ++c;

123 if (*c) {

124 argv[argc] = b;

125 ++argc;

126 }

127 while ((b != be) && *c && !isspace(*c)) {

128 *(b++) = *(c++);

129 }