/*
* Copyright (C) 2005 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <utils/Debug.h>
#include <utils/misc.h>
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
namespace android {
// ---------------------------------------------------------------------
static const char indentStr[] =
" "
" ";
const char* stringForIndent(int32_t indentLevel)
{
ssize_t off = sizeof(indentStr)-1-(indentLevel*2);
return indentStr + (off < 0 ? 0 : off);
}
// ---------------------------------------------------------------------
static void defaultPrintFunc(void* cookie, const char* txt)
{
printf("%s", txt);
}
// ---------------------------------------------------------------------
static inline int isident(int c)
{
return isalnum(c) || c == '_';
}
static inline bool isasciitype(char c)
{
if( c >= ' ' && c < 127 && c != '\'' && c != '\\' ) return true;
return false;
}
static inline char makehexdigit(uint32_t val)
{
return "0123456789abcdef"[val&0xF];
}
static char* appendhexnum(uint32_t val, char* out)
{
for( int32_t i=28; i>=0; i-=4 ) {
*out++ = makehexdigit( val>>i );
}
*out = 0;
return out;
}
static inline char makeupperhexdigit(uint32_t val)
{
return "0123456789ABCDEF"[val&0xF];
}
static char* appendupperhexnum(uint32_t val, char* out)
{
for( int32_t i=28; i>=0; i-=4 ) {
*out++ = makeupperhexdigit( val>>i );
}
*out = 0;
return out;
}
static char* appendcharornum(char c, char* out, bool skipzero = true)
{
if (skipzero && c == 0) return out;
if (isasciitype(c)) {
*out++ = c;
return out;
}
*out++ = '\\';
*out++ = 'x';
*out++ = makehexdigit(c>>4);
*out++ = makehexdigit(c);
return out;
}
static char* typetostring(uint32_t type, char* out,
bool fullContext = true,
bool strict = false)
{
char* pos = out;
char c[4];
c[0] = (char)((type>>24)&0xFF);
c[1] = (char)((type>>16)&0xFF);
c[2] = (char)((type>>8)&0xFF);
c[3] = (char)(type&0xFF);
bool valid;
if( !strict ) {
// now even less strict!
// valid = isasciitype(c[3]);
valid = true;
int32_t i = 0;
bool zero = true;
while (valid && i<3) {
if (c[i] == 0) {
if (!zero) valid = false;
} else {
zero = false;
//if (!isasciitype(c[i])) valid = false;
}
i++;
}
// if all zeros, not a valid type code.
if (zero) valid = false;
} else {
valid = isident(c[3]) ? true : false;
int32_t i = 0;
bool zero = true;
while (valid && i<3) {
if (c[i] == 0) {
if (!zero) valid = false;
} else {
zero = false;
if (!isident(c[i])) valid = false;
}
i++;
}
}
if( valid && (!fullContext || c[0] != '0' || c[1] != 'x') ) {
if( fullContext ) *pos++ = '\'';
pos = appendcharornum(c[0], pos);
pos = appendcharornum(c[1], pos);
pos = appendcharornum(c[2], pos);
pos = appendcharornum(c[3], pos);
if( fullContext ) *pos++ = '\'';
*pos = 0;
return pos;
}
if( fullContext ) {
*pos++ = '0';
*pos++ = 'x';
}
return appendhexnum(type, pos);
}
void printTypeCode(uint32_t typeCode, debugPrintFunc func, void* cookie)
{
char buffer[32];
char* end = typetostring(typeCode, buffer);
*end = 0;
func ? (*func)(cookie, buffer) : defaultPrintFunc(cookie, buffer);
}
void printHexData(int32_t indent, const void *buf, size_t length,
size_t bytesPerLine, int32_t singleLineBytesCutoff,
size_t alignment, bool cStyle,
debugPrintFunc func, void* cookie)
{
if (alignment == 0) {
if (bytesPerLine >= 16) alignment = 4;
else if (bytesPerLine >= 8) alignment = 2;
else alignment = 1;
}
if (func == NULL) func = defaultPrintFunc;
size_t offset;
unsigned char *pos = (unsigned char *)buf;
if (pos == NULL) {
if (singleLineBytesCutoff < 0) func(cookie, "\n");
func(cookie, "(NULL)");
return;
}
if (length == 0) {
if (singleLineBytesCutoff < 0) func(cookie, "\n");
func(cookie, "(empty)");
return;
}
if ((int32_t)length < 0) {
if (singleLineBytesCutoff < 0) func(cookie, "\n");
char buf[64];
sprintf(buf, "(bad length: %d)", length);
func(cookie, buf);
return;
}
char buffer[256];
static const size_t maxBytesPerLine = (sizeof(buffer)-1-11-4)/(3+1);
if (bytesPerLine > maxBytesPerLine) bytesPerLine = maxBytesPerLine;
const bool oneLine = (int32_t)length <= singleLineBytesCutoff;
bool newLine = false;
if (cStyle) {
indent++;
func(cookie, "{\n");
newLine = true;
} else if (!oneLine) {
func(cookie, "\n");
newLine = true;
}
for (offset = 0; ; offset += bytesPerLine, pos += bytesPerLine) {
long remain = length;
char* c = buffer;
if (!oneLine && !cStyle) {
sprintf(c, "0x%08x: ", (int)offset);
c += 12;
}
size_t index;
size_t word;
for (word = 0; word < bytesPerLine; ) {
#ifdef HAVE_LITTLE_ENDIAN
const size_t startIndex = word+(alignment-(alignment?1:0));
const ssize_t dir = -1;
#else
const size_t startIndex = word;
const ssize_t dir = 1;
#endif
for (index = 0; index < alignment || (alignment == 0 && index < bytesPerLine); index++) {
if (!cStyle) {
if (index == 0 && word > 0 && alignment > 0) {
*c++ = ' ';
}
if (remain-- > 0) {
const unsigned char val = *(pos+startIndex+(index*dir));
*c++ = makehexdigit(val>>4);
*c++ = makehexdigit(val);
} else if (!oneLine) {
*c++ = ' ';
*c++ = ' ';
}
} else {
if (remain > 0) {
if (index == 0 && word > 0) {
*c++ = ',';
*c++ = ' ';
}
if (index == 0) {
*c++ = '0';
*c++ = 'x';
}
const unsigned char val = *(pos+startIndex+(index*dir));
*c++ = makehexdigit(val>>4);
*c++ = makehexdigit(val);
remain--;
}
}
}
word += index;
}
if (!cStyle) {
remain = length;
*c++ = ' ';
*c++ = '\'';
for (index = 0; index < bytesPerLine; index++) {
if (remain-- > 0) {
const unsigned char val = pos[index];
*c++ = (val >= ' ' && val < 127) ? val : '.';
} else if (!oneLine) {
*c++ = ' ';
}
}
*c++ = '\'';
if (length > bytesPerLine) *c++ = '\n';
} else {
if (remain > 0) *c++ = ',';
*c++ = '\n';
}
if (newLine && indent) func(cookie, stringForIndent(indent));
*c = 0;
func(cookie, buffer);
newLine = true;
if (length <= bytesPerLine) break;
length -= bytesPerLine;
}
if (cStyle) {
if (indent > 0) func(cookie, stringForIndent(indent-1));
func(cookie, "};");
}
}
}; // namespace android