int TRI_AppendInteger2StringBuffer (TRI_string_buffer_t * self, uint32_t attr) {
int res;
res = Reserve(self, 2);
if (res != TRI_ERROR_NO_ERROR) {
return res;
}
AppendChar(self, (attr / 10U) % 10 + '0');
AppendChar(self, attr % 10 + '0');
return TRI_ERROR_NO_ERROR;
}
/*
* Do a command with autosense using the original SCSI manager.
*/
OSErr
DoOriginalSCSICommand(
DeviceIdent scsiDevice,
const SCSI_CommandPtr theSCSICommand,
unsigned short cmdBlockLength,
Ptr dataBuffer,
ByteCount dataLength,
UInt32 scsiFlags,
ByteCount *actualTransferCount,
SCSI_Sense_Data *sensePtr
)
{
OSErr status;
UInt8 scsiStatusByte;
SCSI_Command scsiStatusCommand;
status = OriginalSCSI(
scsiDevice,
theSCSICommand,
cmdBlockLength,
dataBuffer,
dataLength,
scsiFlags,
actualTransferCount,
&scsiStatusByte
);
if (status == scsiNonZeroStatus
&& scsiStatusByte == kScsiStatusCheckCondition
&& sensePtr != NULL) {
CLEAR(scsiStatusCommand);
CLEAR(*sensePtr);
scsiStatusCommand.scsi6.opcode = kScsiCmdRequestSense;
scsiStatusCommand.scsi[1] |= (scsiDevice.LUN & 0x03) << 5;
scsiStatusCommand.scsi6.len = sizeof *sensePtr;
status = OriginalSCSI(
scsiDevice,
&scsiStatusCommand,
sizeof scsiStatusCommand.scsi6,
(Ptr) sensePtr,
sizeof *sensePtr,
scsiDirectionIn,
NULL,
&scsiStatusByte
);
if (status != noErr && status != scsiDataRunError) {
#ifdef notdef
if (gDebugOnError && scsiStatusByte != kScsiStatusCheckCondition) {
Str255 work;
pstrcpy(work, "\pAutosense failed ");
AppendSigned(work, status);
AppendChar(work, ' ');
AppendHexLeadingZeros(work, scsiStatusByte, 2);
DebugStr(work);
}
#endif
sensePtr->errorCode = 0;
status = scsiAutosenseFailed;
}
// Helper functions to combine paths
static MyString MakePath(const MyString &root, const MyString &file)
{
MyString res = root;
if (!EndsWithChar(res, W('\\')))
AppendChar(res, W('\\'));
AppendStr(res, file);
return res;
}
void CPDF_Font::AppendChar(CFX_ByteString& str, uint32_t charcode) const {
char buf[4];
int len = AppendChar(buf, charcode);
if (len == 1) {
str += buf[0];
} else {
str += CFX_ByteString(buf, len);
}
}
void BitmapString::SetText(const char* text)
{
Clear();
const char* p = text;
while (*p != '\0')
{
AppendChar(*p);
++p;
}
}
int TRI_AppendCharStringBuffer (TRI_string_buffer_t * self, char chr) {
int res;
res = Reserve(self, 1);
if (res != TRI_ERROR_NO_ERROR) {
return res;
}
AppendChar(self, chr);
return TRI_ERROR_NO_ERROR;
}
int TRI_AppendTimeStringBuffer (TRI_string_buffer_t * self, int32_t attr) {
int hour;
int minute;
int second;
int res;
hour = attr / 3600;
minute = (attr / 60) % 60;
second = attr % 60;
res = Reserve(self, 9);
if (res != TRI_ERROR_NO_ERROR) {
return res;
}
TRI_AppendInteger2StringBuffer(self, (uint32_t) hour);
AppendChar(self, ':');
TRI_AppendInteger2StringBuffer(self, (uint32_t) minute);
AppendChar(self, ':');
TRI_AppendInteger2StringBuffer(self, (uint32_t) second);
return TRI_ERROR_NO_ERROR;
}
int TRI_AppendUrlEncodedStringStringBuffer (TRI_string_buffer_t * self,
char const * src) {
static char hexChars[16] = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
size_t len = strlen(src);
int res;
char const* end;
res = Reserve(self, len * 3);
if (res != TRI_ERROR_NO_ERROR) {
return res;
}
end = src + len;
for (; src < end; ++src) {
if ('0' <= *src && *src <= '9') {
AppendChar(self, *src);
}
else if ('a' <= *src && *src <= 'z') {
AppendChar(self, *src);
}
else if ('A' <= *src && *src <= 'Z') {
AppendChar(self, *src);
}
else if (*src == '-' || *src == '_' || *src == '.' || *src == '~') {
AppendChar(self, *src);
}
else {
uint8_t n = (uint8_t)(*src);
uint8_t n1 = n >> 4;
uint8_t n2 = n & 0x0F;
AppendChar(self, '%');
AppendChar(self, hexChars[n1]);
AppendChar(self, hexChars[n2]);
}
}
return TRI_ERROR_NO_ERROR;
}
int TRI_AppendCsvDoubleStringBuffer (TRI_string_buffer_t * self, double d) {
int res;
res = TRI_AppendDoubleStringBuffer(self, d);
if (res != TRI_ERROR_NO_ERROR) {
return res;
}
res = Reserve(self, 1);
if (res != TRI_ERROR_NO_ERROR) {
return res;
}
AppendChar(self, ';');
return TRI_ERROR_NO_ERROR;
}
int TRI_AppendCsvUInt64StringBuffer (TRI_string_buffer_t * self, uint64_t i) {
int res;
res = TRI_AppendUInt64StringBuffer(self, i);
if (res != TRI_ERROR_NO_ERROR) {
return res;
}
res = Reserve(self, 1);
if (res != TRI_ERROR_NO_ERROR) {
return res;
}
AppendChar(self, ';');
return TRI_ERROR_NO_ERROR;
}
FDE_CSSSYNTAXSTATUS CFDE_CSSSyntaxParser::DoSyntaxParse() {
while (m_eStatus >= FDE_CSSSYNTAXSTATUS_None) {
if (m_TextPlane.IsEOF()) {
if (m_pStream == NULL) {
if (m_eMode == FDE_CSSSYNTAXMODE_PropertyValue &&
m_TextData.GetLength() > 0) {
SaveTextData();
return m_eStatus = FDE_CSSSYNTAXSTATUS_PropertyValue;
}
return m_eStatus = FDE_CSSSYNTAXSTATUS_EOS;
}
FX_BOOL bEOS;
int32_t iLen = m_TextPlane.LoadFromStream(m_pStream, m_iStreamPos,
m_iPlaneSize, bEOS);
m_iStreamPos = m_pStream->GetPosition();
if (iLen < 1) {
if (m_eMode == FDE_CSSSYNTAXMODE_PropertyValue &&
m_TextData.GetLength() > 0) {
SaveTextData();
return m_eStatus = FDE_CSSSYNTAXSTATUS_PropertyValue;
}
return m_eStatus = FDE_CSSSYNTAXSTATUS_EOS;
}
}
FX_WCHAR wch;
while (!m_TextPlane.IsEOF()) {
wch = m_TextPlane.GetChar();
switch (m_eMode) {
case FDE_CSSSYNTAXMODE_RuleSet:
switch (wch) {
case '@':
m_TextPlane.MoveNext();
SwitchMode(FDE_CSSSYNTAXMODE_AtRule);
break;
case '}':
m_TextPlane.MoveNext();
if (RestoreMode()) {
return FDE_CSSSYNTAXSTATUS_DeclClose;
} else {
return m_eStatus = FDE_CSSSYNTAXSTATUS_Error;
}
break;
case '/':
if (m_TextPlane.GetNextChar() == '*') {
m_ModeStack.Push(m_eMode);
SwitchMode(FDE_CSSSYNTAXMODE_Comment);
break;
}
default:
if (wch <= ' ') {
m_TextPlane.MoveNext();
} else if (FDE_IsSelectorStart(wch)) {
SwitchMode(FDE_CSSSYNTAXMODE_Selector);
return FDE_CSSSYNTAXSTATUS_StyleRule;
} else {
return m_eStatus = FDE_CSSSYNTAXSTATUS_Error;
}
break;
}
break;
case FDE_CSSSYNTAXMODE_Selector:
switch (wch) {
case ',':
m_TextPlane.MoveNext();
SwitchMode(FDE_CSSSYNTAXMODE_Selector);
if (m_iTextDatLen > 0) {
return FDE_CSSSYNTAXSTATUS_Selector;
}
break;
case '{':
if (m_TextData.GetLength() > 0) {
SaveTextData();
return FDE_CSSSYNTAXSTATUS_Selector;
} else {
m_TextPlane.MoveNext();
m_ModeStack.Push(FDE_CSSSYNTAXMODE_RuleSet);
SwitchMode(FDE_CSSSYNTAXMODE_PropertyName);
return FDE_CSSSYNTAXSTATUS_DeclOpen;
}
break;
case '/':
if (m_TextPlane.GetNextChar() == '*') {
if (SwitchToComment() > 0) {
return FDE_CSSSYNTAXSTATUS_Selector;
}
break;
}
default:
AppendChar(wch);
break;
}
break;
case FDE_CSSSYNTAXMODE_PropertyName:
switch (wch) {
case ':':
m_TextPlane.MoveNext();
SwitchMode(FDE_CSSSYNTAXMODE_PropertyValue);
return FDE_CSSSYNTAXSTATUS_PropertyName;
case '}':
m_TextPlane.MoveNext();
if (RestoreMode()) {
return FDE_CSSSYNTAXSTATUS_DeclClose;
} else {
return m_eStatus = FDE_CSSSYNTAXSTATUS_Error;
}
break;
case '/':
if (m_TextPlane.GetNextChar() == '*') {
if (SwitchToComment() > 0) {
return FDE_CSSSYNTAXSTATUS_PropertyName;
}
break;
}
default:
AppendChar(wch);
break;
}
break;
case FDE_CSSSYNTAXMODE_PropertyValue:
switch (wch) {
case ';':
m_TextPlane.MoveNext();
case '}':
SwitchMode(FDE_CSSSYNTAXMODE_PropertyName);
return FDE_CSSSYNTAXSTATUS_PropertyValue;
case '/':
if (m_TextPlane.GetNextChar() == '*') {
if (SwitchToComment() > 0) {
return FDE_CSSSYNTAXSTATUS_PropertyValue;
}
break;
}
default:
AppendChar(wch);
break;
}
break;
case FDE_CSSSYNTAXMODE_Comment:
if (wch == '/' && m_TextData.GetLength() > 0 &&
m_TextData.GetAt(m_TextData.GetLength() - 1) == '*') {
RestoreMode();
} else {
m_TextData.AppendChar(wch);
}
m_TextPlane.MoveNext();
break;
case FDE_CSSSYNTAXMODE_MediaType:
switch (wch) {
case ',':
m_TextPlane.MoveNext();
SwitchMode(FDE_CSSSYNTAXMODE_MediaType);
if (m_iTextDatLen > 0) {
return FDE_CSSSYNTAXSTATUS_MediaType;
}
break;
case '{': {
FDE_CSSSYNTAXMODE* pMode = m_ModeStack.GetTopElement();
if (pMode == NULL || *pMode != FDE_CSSSYNTAXMODE_MediaRule) {
return m_eStatus = FDE_CSSSYNTAXSTATUS_Error;
}
if (m_TextData.GetLength() > 0) {
SaveTextData();
return FDE_CSSSYNTAXSTATUS_MediaType;
} else {
m_TextPlane.MoveNext();
*pMode = FDE_CSSSYNTAXMODE_RuleSet;
SwitchMode(FDE_CSSSYNTAXMODE_RuleSet);
return FDE_CSSSYNTAXSTATUS_DeclOpen;
}
} break;
case ';': {
FDE_CSSSYNTAXMODE* pMode = m_ModeStack.GetTopElement();
if (pMode == NULL || *pMode != FDE_CSSSYNTAXMODE_Import) {
return m_eStatus = FDE_CSSSYNTAXSTATUS_Error;
}
if (m_TextData.GetLength() > 0) {
SaveTextData();
if (IsImportEnabled()) {
return FDE_CSSSYNTAXSTATUS_MediaType;
}
} else {
FX_BOOL bEnabled = IsImportEnabled();
m_TextPlane.MoveNext();
m_ModeStack.Pop();
SwitchMode(FDE_CSSSYNTAXMODE_RuleSet);
if (bEnabled) {
DisableImport();
return FDE_CSSSYNTAXSTATUS_ImportClose;
}
}
} break;
case '/':
if (m_TextPlane.GetNextChar() == '*') {
if (SwitchToComment() > 0) {
return FDE_CSSSYNTAXSTATUS_MediaType;
}
break;
}
default:
AppendChar(wch);
break;
}
break;
case FDE_CSSSYNTAXMODE_URI: {
FDE_CSSSYNTAXMODE* pMode = m_ModeStack.GetTopElement();
if (pMode == NULL || *pMode != FDE_CSSSYNTAXMODE_Import) {
return m_eStatus = FDE_CSSSYNTAXSTATUS_Error;
}
if (wch <= ' ' || wch == ';') {
int32_t iURIStart, iURILength = m_TextData.GetLength();
if (iURILength > 0 &&
FDE_ParseCSSURI(m_TextData.GetBuffer(), iURILength, iURIStart,
iURILength)) {
m_TextData.Subtract(iURIStart, iURILength);
SwitchMode(FDE_CSSSYNTAXMODE_MediaType);
if (IsImportEnabled()) {
return FDE_CSSSYNTAXSTATUS_URI;
} else {
break;
}
}
}
AppendChar(wch);
} break;
case FDE_CSSSYNTAXMODE_AtRule:
if (wch > ' ') {
AppendChar(wch);
} else {
int32_t iLen = m_TextData.GetLength();
const FX_WCHAR* psz = m_TextData.GetBuffer();
if (FXSYS_wcsncmp(L"charset", psz, iLen) == 0) {
SwitchMode(FDE_CSSSYNTAXMODE_Charset);
} else if (FXSYS_wcsncmp(L"import", psz, iLen) == 0) {
m_ModeStack.Push(FDE_CSSSYNTAXMODE_Import);
SwitchMode(FDE_CSSSYNTAXMODE_URI);
if (IsImportEnabled()) {
return FDE_CSSSYNTAXSTATUS_ImportRule;
} else {
break;
}
} else if (FXSYS_wcsncmp(L"media", psz, iLen) == 0) {
m_ModeStack.Push(FDE_CSSSYNTAXMODE_MediaRule);
SwitchMode(FDE_CSSSYNTAXMODE_MediaType);
return FDE_CSSSYNTAXSTATUS_MediaRule;
} else if (FXSYS_wcsncmp(L"font-face", psz, iLen) == 0) {
SwitchMode(FDE_CSSSYNTAXMODE_Selector);
return FDE_CSSSYNTAXSTATUS_FontFaceRule;
} else if (FXSYS_wcsncmp(L"page", psz, iLen) == 0) {
SwitchMode(FDE_CSSSYNTAXMODE_Selector);
return FDE_CSSSYNTAXSTATUS_PageRule;
} else {
SwitchMode(FDE_CSSSYNTAXMODE_UnknownRule);
}
}
break;
case FDE_CSSSYNTAXMODE_Charset:
if (wch == ';') {
m_TextPlane.MoveNext();
SwitchMode(FDE_CSSSYNTAXMODE_RuleSet);
if (IsCharsetEnabled()) {
DisableCharset();
if (m_iTextDatLen > 0) {
if (m_pStream != NULL) {
FX_WORD wCodePage = FX_GetCodePageFormStringW(
m_TextData.GetBuffer(), m_iTextDatLen);
if (wCodePage < 0xFFFF &&
m_pStream->GetCodePage() != wCodePage) {
m_pStream->SetCodePage(wCodePage);
}
}
return FDE_CSSSYNTAXSTATUS_Charset;
}
}
} else {
AppendChar(wch);
}
break;
case FDE_CSSSYNTAXMODE_UnknownRule:
if (wch == ';') {
SwitchMode(FDE_CSSSYNTAXMODE_RuleSet);
}
m_TextPlane.MoveNext();
break;
default:
FXSYS_assert(FALSE);
break;
}
}
}
return m_eStatus;
}
int TRI_AppendDoubleStringBuffer (TRI_string_buffer_t * self, double attr) {
int res;
// IEEE754 NaN values have an interesting property that we can exploit...
// if the architecture does not use IEEE754 values then this shouldn't do
// any harm either
if (attr != attr) {
return TRI_AppendStringStringBuffer(self, "NaN");
}
if (attr == HUGE_VAL) {
return TRI_AppendStringStringBuffer(self, "inf");
}
if (attr == -HUGE_VAL) {
return TRI_AppendStringStringBuffer(self, "-inf");
}
res = Reserve(self, 1);
if (res != TRI_ERROR_NO_ERROR) {
return res;
}
if (attr < 0.0) {
AppendChar(self, '-');
attr = -attr;
}
else if (attr == 0.0) {
AppendChar(self, '0');
return TRI_ERROR_NO_ERROR;
}
if (((double)((uint32_t) attr)) == attr) {
return TRI_AppendUInt32StringBuffer(self, (uint32_t) attr);
}
else if (attr < (double) 429496U) {
uint32_t smll;
smll = (uint32_t)(attr * 10000.0);
if (((double) smll) == attr * 10000.0) {
uint32_t ep;
TRI_AppendUInt32StringBuffer(self, smll / 10000);
ep = smll % 10000;
if (ep != 0) {
size_t pos;
char a1;
char a2;
char a3;
char a4;
pos = 0;
res = Reserve(self, 6);
if (res != TRI_ERROR_NO_ERROR) {
return res;
}
AppendChar(self, '.');
if ((ep / 1000L) % 10 != 0) pos = 1;
a1 = (char) ((ep / 1000L) % 10 + '0');
if ((ep / 100L) % 10 != 0) pos = 2;
a2 = (char) ((ep / 100L) % 10 + '0');
if ((ep / 10L) % 10 != 0) pos = 3;
a3 = (char) ((ep / 10L) % 10 + '0');
if (ep % 10 != 0) pos = 4;
a4 = (char) (ep % 10 + '0');
AppendChar(self, a1);
if (pos > 1) { AppendChar(self, a2); }
if (pos > 2) { AppendChar(self, a3); }
if (pos > 3) { AppendChar(self, a4); }
}
return TRI_ERROR_NO_ERROR;
}
}
// we do not habe a small integral number nor small decimal number with only a few decimal digits
// there at most 16 significant digits, first find out if we have an integer value
if (10000000000000000.0 < attr) {
size_t n;
n = 0;
while (10000000000000000.0 < attr) {
attr /= 10.0;
++n;
}
res = TRI_AppendUInt64StringBuffer(self, (uint64_t) attr);
if (res != TRI_ERROR_NO_ERROR) {
return res;
}
res = Reserve(self, n);
if (res != TRI_ERROR_NO_ERROR) {
return res;
}
for (; 0 < n; --n) {
AppendChar(self, '0');
}
return TRI_ERROR_NO_ERROR;
}
// very small, i. e. less than 1
else if (attr < 1.0) {
size_t n;
n = 0;
while (attr < 1.0) {
attr *= 10.0;
++n;
// should not happen, so it must be almost 0
if (n > 400) {
return TRI_AppendUInt32StringBuffer(self, 0);
}
}
res = Reserve(self, n + 2);
if (res != TRI_ERROR_NO_ERROR) {
return res;
}
AppendChar(self, '0');
AppendChar(self, '.');
for (--n; 0 < n; --n) {
AppendChar(self, '0');
}
attr = 10000000000000000.0 * attr;
return TRI_AppendUInt64StringBuffer(self, (uint64_t) attr);
}
// somewhere in between
else {
uint64_t m;
double d;
size_t n;
m = (uint64_t) attr;
d = attr - m;
n = 0;
TRI_AppendUInt64StringBuffer(self, m);
while (d < 1.0) {
d *= 10.0;
++n;
// should not happen, so it must be almost 0
if (n > 400) {
return TRI_ERROR_NO_ERROR;
}
}
res = Reserve(self, n + 1);
if (res != TRI_ERROR_NO_ERROR) {
return res;
}
AppendChar(self, '.');
for (--n; 0 < n; --n) {
AppendChar(self, '0');
}
d = 10000000000000000.0 * d;
return TRI_AppendUInt64StringBuffer(self, (uint64_t) d);
}
}
