void CField::GetSource(xString *src)
{
if (!m_Value.IsEmpty()) {
DWORD MaxLine = ((CBibedtApp*)AfxGetApp())->m_Options->m_LineLength - 1;
_TUCHAR c;
xString* val = xsNewInitS(EncodeValue(m_Value));
xsTerminate(val);
xsCatS(src, _T(" "));
xsCatS(src, m_Name);
xsCatS(src, _T("={"));
DWORD pos = 4 + m_Name.GetLength();
int length = xsLen(val);
xsGrow(src, length);
for (int i = 0; i < length; i++) {
c = xsChar(val, i);
pos++;
if (pos >= MaxLine && c == ' ' && i < length) {
xsCatS(src, _T("\r\n "));
pos = 4;
} else
xsPut(src, c);
}
xsDelete(val);
xsPut(src, _T('}'));
xsTerminate(src);
}
}
/**
* \brief Returns the source.
*
* \return The source as CString.
*/
CString CBibList::GetSource()
{
xString* src = xsNew();
GetSource(src);
CString res = CString(xsValue(src));
xsDelete(src);
return res;
}
void CField::SaveToFile(CFile *file)
{
if (!m_Value.IsEmpty()) {
xString* str = xsNew();
GetSource(str);
file->Write(xsValue(str), xsLen(str));
xsDelete(str);
}
}
CString CField::GetSource()
{
if (!m_Value.IsEmpty()) {
xString* src = xsNew();
GetSource(src);
CString res = CString(xsValue(src));
xsDelete(src);
return res;
} else
return _T("");
}
void KprDebugMachineCallbackView(KprDebugMachine machine, char* function, int view)
{
KprDebug self = machine->debug;
xsMachine* the = self->the;
if (xsTypeOf(self->behavior) == xsUndefinedType) goto bail;
{
xsTry {
xsVar(0) = xsAccess(self->behavior);
if (xsFindResult(xsVar(0), xsID(function))) {
xsVar(1) = xsGet(xsVar(0), xsID(machine->address));
xsDelete(xsVar(0), xsID(machine->address));
(void)xsCallFunction3(xsResult, xsVar(0), xsString(machine->address), xsInteger(view), xsVar(1));
}
}
xsCatch {
}
}
bail:
return;
}
void KprDebugMachineLockView(KprDebugMachine self, int theView)
{
KprDebug debug = self->debug;
xsMachine* the = debug->the;
// FskDebugStr("%s: %d", __FUNCTION__, theView);
if (xsTypeOf(debug->behavior) == xsUndefinedType) goto bail;
{
xsTry {
xsVar(0) = xsAccess(debug->behavior);
if (xsHasOwn(xsVar(0), xsID(self->address)))
xsDelete(xsVar(0), xsID(self->address));
xsVar(1) = xsNewInstanceOf(xsArrayPrototype);
xsNewHostProperty(xsVar(0), xsID(self->address), xsVar(1), xsDefault, xsDontScript);
}
xsCatch {
}
}
bail:
return;
}
void xs_infoset_scan(xsMachine* the)
{
int c = xsToInteger(xsArgc);
Scanner scanner;
Scanner* self;
xsVars(COUNT);
xsTry {
self = &scanner;
c_memset(self, 0, sizeof(Scanner));
if (c < 1)
xsSyntaxError("no buffer");
self->expat = XML_ParserCreate(NULL);
xsThrowIfNULL(self->expat);
XML_SetUserData(self->expat, self);
XML_SetElementHandler(self->expat, scanStartTag, scanStopTag);
XML_SetCdataSectionHandler(self->expat, scanStartCdata, scanStopCdata);
XML_SetCharacterDataHandler(self->expat, scanCharacter);
XML_SetCommentHandler(self->expat, scanComment);
XML_SetProcessingInstructionHandler(self->expat, scanProcessingInstruction);
XML_SetUnknownEncodingHandler(self->expat, scanUnknownEncoding, NULL);
XML_SetSkippedEntityHandler(self->expat, scanEntity);
self->result = 1;
self->textBuffer = c_malloc(8192);
xsThrowIfNULL(self->textBuffer);
self->textSize = 8192;
self->the = the;
xsVar(ATTRIBUTE_PROTOTYPE) = xsGet(xsThis, xsID_attribute);
xsVar(CDATA_PROTOTYPE) = xsGet(xsThis, xsID_cdata);
xsVar(COMMENT_PROTOTYPE) = xsGet(xsThis, xsID_comment);
xsVar(DOCUMENT_PROTOTYPE) = xsGet(xsThis, xsID_document);
xsVar(ELEMENT_PROTOTYPE) = xsGet(xsThis, xsID_element);
xsVar(NO_NAMESPACE) = xsString("");
xsVar(NO_PREFIX) = xsString("");
xsVar(PATH) = (c > 1) ? xsArg(1) : xsUndefined;
xsVar(PI_PROTOTYPE) = xsGet(xsThis, xsID_pi);
xsVar(XML_NAMESPACE) = xsGet(xsThis, xsID_xmlnsNamespace);
xsVar(XML_PREFIX) = xsGet(xsThis, xsID_xmlnsPrefix);
xsResult = xsNewInstanceOf(xsVar(DOCUMENT_PROTOTYPE));
xsSet(xsResult, xsID_encoding, xsString("UTF-8"));
xsSet(xsResult, xsID_version, xsString("1.0"));
xsVar(CHILDREN) = xsNewInstanceOf(xsArrayPrototype);
xsArrayCacheBegin(xsVar(CHILDREN));
xsSet(xsResult, xsID_children, xsVar(CHILDREN));
xsSet(xsResult, xsID_parent, xsNull);
xsSet(xsResult, xsID_xmlnsAttributes, xsNull);
if (xsIsInstanceOf(xsArg(0), xsChunkPrototype)) {
xsStringValue buffer = xsGetHostData(xsArg(0));
xsIntegerValue size = xsToInteger(xsGet(xsArg(0), xsID_length));
self->result = XML_Parse(self->expat, (const char *)buffer, size, 1);
}
else if (xsTypeOf(xsArg(0)) == xsStringType) {
xsStringValue string = xsToString(xsArg(0));
xsIntegerValue stringOffset = 0;
xsIntegerValue stringSize = c_strlen(string);
while (self->result && (stringOffset < stringSize)) {
xsIntegerValue size = stringSize - stringOffset;
xsStringValue buffer = (char *)XML_GetBuffer(self->expat, 1024);
xsThrowIfNULL(buffer);
if (size > 1024)
size = 1024;
c_memcpy(buffer, string + stringOffset, size);
self->result = XML_ParseBuffer(self->expat, size, (size < 1024) ? 1 : 0);
stringOffset += size;
string = xsToString(xsArg(0)); // @@ gc
}
}
else {
xsStreamGetter* streamGetter = xsGetHostData(xsArg(0));
while (self->result) {
xsIntegerValue i;
xsStringValue p, buffer = (char *)XML_GetBuffer(self->expat, 1024);
xsThrowIfNULL(buffer);
for (i = 0, p = buffer; i < 1024; i++, p++) {
int c = (*(streamGetter->getter))(streamGetter->stream);
if (c == C_EOF)
break;
*p = (char)c;
}
self->result = XML_ParseBuffer(self->expat, i, (i < 1024) ? 1 : 0);
if (i < 1024)
break;
}
}
xsDelete(xsResult, xsID_xmlnsAttributes);
xsDelete(xsResult, xsID_parent);
xsArrayCacheEnd(xsVar(CHILDREN));
if (!self->result) {
xsVar(LINE) = xsInteger(XML_GetCurrentLineNumber(self->expat));
xsVar(VALUE) = xsString((char*)XML_ErrorString(XML_GetErrorCode(self->expat)));
if (xsHas(xsThis, xsID_reportError))
xsCall3_noResult(xsThis, xsID_reportError, xsVar(PATH), xsVar(LINE), xsVar(VALUE));
xsThrow(xsNewInstanceOf(xsSyntaxErrorPrototype));
}
c_free(self->textBuffer);
self->textBuffer = NULL;
XML_ParserFree(self->expat);
self->expat = NULL;
}
xsCatch {
if (self->textBuffer)
c_free(self->textBuffer);
if (self->expat)
XML_ParserFree(self->expat);
}
}
void CField::LoadFromFile(CBibReader *file)
{
xString* tmp = xsNew();
_TUCHAR c;
int openpar = 0;
BOOL quote = FALSE;
BOOL squote = FALSE;
BOOL escape = FALSE;
while (file->Read(&c, sizeof(_TUCHAR))) {
switch (c) {
case 9:
case _T(' '):
if ((openpar || quote) && !xsIsEmpty(tmp) && xsRightChar(tmp) != _T(' ')) {
// always use spaces
xsPut(tmp, _T(' '));
}
escape = FALSE;
break;
case _T('='):
if (openpar || quote)
// inside value
xsPut(tmp, c);
else {
// outside value
xsTerminate(tmp);
m_Name = CString(xsValue(tmp));
xsClear(tmp);
}
escape = FALSE;
break;
case _T('\\'):
escape = !escape;
xsPut(tmp, c);
break;
case _T('"'):
if (!escape)
quote = !quote;
xsPut(tmp, c);
escape = FALSE;
break;
case _T('\''):
if (!escape)
squote = !squote;
xsPut(tmp, c);
escape = FALSE;
break;
case _T('{'):
if (openpar || quote)
xsPut(tmp, c);
openpar++;
escape = FALSE;
break;
case _T('}'):
if (openpar)
openpar--;
else {
// the last field
file->Seek(-1, CFile::current);
goto leave;
}
if (openpar || quote)
xsPut(tmp, c);
if (!openpar && !quote) {
xsTerminate(tmp);
m_Value = DecodeValue(CString(xsValue(tmp)));
xsClear(tmp);
}
escape = FALSE;
break;
case _T(','):
if (!openpar && !quote) {
if (m_Value.IsEmpty()) {
xsTerminate(tmp);
m_Value = DecodeValue(CString(xsValue(tmp)));
}
goto leave;
} else
xsPut(tmp, c);
escape = FALSE;
break;
case 10:
case 13:
escape = FALSE;
break;
default:
xsPut(tmp, c);
escape = FALSE;
break;
}
}
leave:
xsDelete(tmp);
}
/**
* \brief The actual parsing procedure.
* \param reader A pointer to a CBibReader object with the contents of the .aux file.
*/
void CAuxParser::ParseFile(CBibReader* reader)
{
_TUCHAR c;
xString* cmd = xsNew();
xString* key = xsNew();
CString str;
BOOL escape = FALSE;
BOOL iscite = FALSE;
BOOL isinput = FALSE;
BOOL incmd = FALSE;
BOOL bibdata = FALSE;
BOOL bibstyle = FALSE;
BOOL citation = FALSE;
while (reader->Read(&c, sizeof(_TUCHAR))) {
switch (c) {
case _T('\\'):
if (!escape)
incmd = TRUE;
escape = !escape;
xsClear(cmd);
break;
case _T('{'):
xsTerminate(cmd);
switch (GetCmdType(cmd)) {
case CT_BIBCITE:
iscite = TRUE;
break;
case CT_INPUT:
isinput = TRUE;
break;
case CT_BIBDATA:
bibdata = TRUE;
break;
case CT_BIBSTYLE:
bibstyle = TRUE;
break;
case CT_CITATION:
citation = TRUE;
break;
}
incmd = FALSE;
xsClear(cmd);
break;
case _T('}'):
if (iscite) {
xsTerminate(key);
m_Keys.AddTail(CString(xsValue(key)));
str.Format(AfxLoadString(IDS_STRING_FOUNDKEY), xsValue(key));
AddLog(str);
xsClear(key);
iscite = FALSE;
} else if (citation) {
xsTerminate(key);
if (xsCompareS(key, _T("*")) == 0) {
m_AllItems = TRUE;
str.Format(AfxLoadString(IDS_STRING_FOUNDKEY), xsValue(key));
AddLog(str);
}
xsClear(key);
citation = FALSE;
} else if (isinput) {
// Recursively parse inputed files and search for \citation{*}
CAuxParser* parser = new CAuxParser(m_Owner);
xsTerminate(key);
parser->m_AuxFile = CString(xsValue(key));
parser->Parse(m_LogProc);
m_Keys.AddTail(&parser->m_Keys);
m_AllItems |= parser->m_AllItems;
m_Warnings += parser->m_Warnings;
m_Errors += parser->m_Errors;
delete parser;
xsClear(key);
isinput = FALSE;
} else if (bibdata) {
xsTerminate(key);
m_BibData = CString(xsValue(key));
str.Format(AfxLoadString(IDS_STRING_BIBDATA), xsValue(key));
AddLog(str);
xsClear(key);
bibdata = FALSE;
} else if (bibstyle) {
xsTerminate(key);
m_BibStyle = CString(xsValue(key));
str.Format(AfxLoadString(IDS_STRING_BIBSTYLE), xsValue(key));
AddLog(str);
xsClear(key);
bibstyle = FALSE;
}
incmd = FALSE;
break;
case _T('\r'):
case _T('\n'):
case _T('\t'):
case _T(' '):
break;
default:
if (iscite || isinput || bibdata || bibstyle || citation)
xsPut(key, c);
else
xsPut(cmd, c);
}
}
xsDelete(cmd);
xsDelete(key);
}
