void start_sound() { while(read_sound_int(&SOUNDSTATUS->mode) != MODE_PLAY) { memset4((void*)RING_BUF, 0, SAMPLES_TO_BYTES(RING_BUFFER_SAMPLES+1)); memset4((void*)RING_BUF+STEREO_OFFSET, 0, SAMPLES_TO_BYTES(RING_BUFFER_SAMPLES+1)); do_sound_command(CMD_SET_MODE(MODE_PLAY)); } }
void write_l (st_parameter_dt *dtp, const fnode *f, char *source, int len) { char *p; int wlen; GFC_INTEGER_LARGEST n; wlen = (f->format == FMT_G && f->u.w == 0) ? 1 : f->u.w; p = write_block (dtp, wlen); if (p == NULL) return; n = extract_int (source, len); if (unlikely (is_char4_unit (dtp))) { gfc_char4_t *p4 = (gfc_char4_t *) p; memset4 (p4, ' ', wlen -1); p4[wlen - 1] = (n) ? 'T' : 'F'; return; } memset (p, ' ', wlen -1); p[wlen - 1] = (n) ? 'T' : 'F'; }
void init_arm() { int i; *(volatile unsigned int *)(0xa05f6934) = 0x00000002; //TODO: Providing your own ARM code as an argument might be nice. *((volatile unsigned long *)(void *)0xa0702c00) |= 1; memset4((void*)0xa0800000, 0, 2*1024*1024); memcpy4((void*)0xa0800000, arm_sound_code, sizeof(arm_sound_code)); *((volatile unsigned long *)(void *)0xa0702c00) &= ~1; //FIXME: Some sort of sleep here would be cleaner... for(i=0; i<0x200000; i++); }
NoInline Bool IsPureBlack(LPVoid lpBitmapToCmp, UInt32 h, UInt32 stride, UInt32 stride_raw, UInt32 bpp) { PByte pbTempRow, pbTemp, pbInput; pbTempRow = (PByte)AllocStack(stride); if (bpp == 32) memset4(pbTempRow, RGBA(1, 1, 1, 255), stride); else if (bpp == 24) memset(pbTempRow, 1, stride); else return False; pbTemp = (PByte)lpBitmapToCmp; for (Int32 i = h; i; --i, pbTemp += stride_raw) if (memcmp(pbTemp, pbTempRow, stride)) return False; return True; }
static void write_decimal (st_parameter_dt *dtp, const fnode *f, const char *source, int len, const char *(*conv) (GFC_INTEGER_LARGEST, char *, size_t)) { GFC_INTEGER_LARGEST n = 0; int w, m, digits, nsign, nzero, nblank; char *p; const char *q; sign_t sign; char itoa_buf[GFC_BTOA_BUF_SIZE]; w = f->u.integer.w; m = f->format == FMT_G ? -1 : f->u.integer.m; n = extract_int (source, len); /* Special case: */ if (m == 0 && n == 0) { if (w == 0) w = 1; p = write_block (dtp, w); if (p == NULL) return; if (unlikely (is_char4_unit (dtp))) { gfc_char4_t *p4 = (gfc_char4_t *) p; memset4 (p4, ' ', w); } else memset (p, ' ', w); goto done; } sign = calculate_sign (dtp, n < 0); if (n < 0) n = -n; nsign = sign == S_NONE ? 0 : 1; /* conv calls itoa which sets the negative sign needed by write_integer. The sign '+' or '-' is set below based on sign calculated above, so we just point past the sign in the string before proceeding to avoid double signs in corner cases. (see PR38504) */ q = conv (n, itoa_buf, sizeof (itoa_buf)); if (*q == '-') q++; digits = strlen (q); /* Select a width if none was specified. The idea here is to always print something. */ if (w == 0) w = ((digits < m) ? m : digits) + nsign; p = write_block (dtp, w); if (p == NULL) return; nzero = 0; if (digits < m) nzero = m - digits; /* See if things will work. */ nblank = w - (nsign + nzero + digits); if (unlikely (is_char4_unit (dtp))) { gfc_char4_t * p4 = (gfc_char4_t *) p; if (nblank < 0) { memset4 (p4, '*', w); goto done; } memset4 (p4, ' ', nblank); p4 += nblank; switch (sign) { case S_PLUS: *p4++ = '+'; break; case S_MINUS: *p4++ = '-'; break; case S_NONE: break; } memset4 (p4, '0', nzero); p4 += nzero; memcpy4 (p4, q, digits); return; } if (nblank < 0) { star_fill (p, w); goto done; } memset (p, ' ', nblank); p += nblank; switch (sign) { case S_PLUS: *p++ = '+'; break; case S_MINUS: *p++ = '-'; break; case S_NONE: break; } memset (p, '0', nzero); p += nzero; memcpy (p, q, digits); done: return; }
static void write_default_char4 (st_parameter_dt *dtp, const gfc_char4_t *source, int src_len, int w_len) { char *p; int j, k = 0; gfc_char4_t c; uchar d; /* Take care of preceding blanks. */ if (w_len > src_len) { k = w_len - src_len; p = write_block (dtp, k); if (p == NULL) return; if (is_char4_unit (dtp)) { gfc_char4_t *p4 = (gfc_char4_t *) p; memset4 (p4, ' ', k); } else memset (p, ' ', k); } /* Get ready to handle delimiters if needed. */ switch (dtp->u.p.current_unit->delim_status) { case DELIM_APOSTROPHE: d = '\''; break; case DELIM_QUOTE: d = '"'; break; default: d = ' '; break; } /* Now process the remaining characters, one at a time. */ for (j = 0; j < src_len; j++) { c = source[j]; if (is_char4_unit (dtp)) { gfc_char4_t *q; /* Handle delimiters if any. */ if (c == d && d != ' ') { p = write_block (dtp, 2); if (p == NULL) return; q = (gfc_char4_t *) p; *q++ = c; } else { p = write_block (dtp, 1); if (p == NULL) return; q = (gfc_char4_t *) p; } *q = c; } else { /* Handle delimiters if any. */ if (c == d && d != ' ') { p = write_block (dtp, 2); if (p == NULL) return; *p++ = (uchar) c; } else { p = write_block (dtp, 1); if (p == NULL) return; } *p = c > 255 ? '?' : (uchar) c; } } }
static void write_boz (st_parameter_dt *dtp, const fnode *f, const char *q, int n) { int w, m, digits, nzero, nblank; char *p; w = f->u.integer.w; m = f->u.integer.m; /* Special case: */ if (m == 0 && n == 0) { if (w == 0) w = 1; p = write_block (dtp, w); if (p == NULL) return; if (unlikely (is_char4_unit (dtp))) { gfc_char4_t *p4 = (gfc_char4_t *) p; memset4 (p4, ' ', w); } else memset (p, ' ', w); goto done; } digits = strlen (q); /* Select a width if none was specified. The idea here is to always print something. */ if (w == 0) w = ((digits < m) ? m : digits); p = write_block (dtp, w); if (p == NULL) return; nzero = 0; if (digits < m) nzero = m - digits; /* See if things will work. */ nblank = w - (nzero + digits); if (unlikely (is_char4_unit (dtp))) { gfc_char4_t *p4 = (gfc_char4_t *) p; if (nblank < 0) { memset4 (p4, '*', w); return; } if (!dtp->u.p.no_leading_blank) { memset4 (p4, ' ', nblank); q += nblank; memset4 (p4, '0', nzero); q += nzero; memcpy4 (p4, q, digits); } else { memset4 (p4, '0', nzero); q += nzero; memcpy4 (p4, q, digits); q += digits; memset4 (p4, ' ', nblank); dtp->u.p.no_leading_blank = 0; } return; } if (nblank < 0) { star_fill (p, w); goto done; } if (!dtp->u.p.no_leading_blank) { memset (p, ' ', nblank); p += nblank; memset (p, '0', nzero); p += nzero; memcpy (p, q, digits); } else { memset (p, '0', nzero); p += nzero; memcpy (p, q, digits); p += digits; memset (p, ' ', nblank); dtp->u.p.no_leading_blank = 0; } done: return; }
void write_a (st_parameter_dt *dtp, const fnode *f, const char *source, int len) { int wlen; char *p; wlen = f->u.string.length < 0 || (f->format == FMT_G && f->u.string.length == 0) ? len : f->u.string.length; #ifdef HAVE_CRLF /* If this is formatted STREAM IO convert any embedded line feed characters to CR_LF on systems that use that sequence for newlines. See F2003 Standard sections 10.6.3 and 9.9 for further information. */ if (is_stream_io (dtp)) { const char crlf[] = "\r\n"; int i, q, bytes; q = bytes = 0; /* Write out any padding if needed. */ if (len < wlen) { p = write_block (dtp, wlen - len); if (p == NULL) return; memset (p, ' ', wlen - len); } /* Scan the source string looking for '\n' and convert it if found. */ for (i = 0; i < wlen; i++) { if (source[i] == '\n') { /* Write out the previously scanned characters in the string. */ if (bytes > 0) { p = write_block (dtp, bytes); if (p == NULL) return; memcpy (p, &source[q], bytes); q += bytes; bytes = 0; } /* Write out the CR_LF sequence. */ q++; p = write_block (dtp, 2); if (p == NULL) return; memcpy (p, crlf, 2); } else bytes++; } /* Write out any remaining bytes if no LF was found. */ if (bytes > 0) { p = write_block (dtp, bytes); if (p == NULL) return; memcpy (p, &source[q], bytes); } } else { #endif p = write_block (dtp, wlen); if (p == NULL) return; if (unlikely (is_char4_unit (dtp))) { gfc_char4_t *p4 = (gfc_char4_t *) p; if (wlen < len) memcpy4 (p4, source, wlen); else { memset4 (p4, ' ', wlen - len); memcpy4 (p4 + wlen - len, source, len); } return; } if (wlen < len) memcpy (p, source, wlen); else { memset (p, ' ', wlen - len); memcpy (p + wlen - len, source, len); } #ifdef HAVE_CRLF } #endif }