bool FScanner::CheckValue(bool allowfloat)
{
auto savedstate = SavePos();
bool res = ScanValue(allowfloat);
if (!res) RestorePos(savedstate);
return res;
}
void ParseConfig(FILE* Handle) {
condType CondType;
char CondVar[MAX_NAME], CondValue[MAX_NAME];
char Token[MAX_NAME];
while(!feof(Handle)) {
fscanf(Handle, "%s", Token);
if(feof(Handle)) return;
CondType=condNULL;
CondVar[0]='\0';
CondValue[0]='\0';
if(!strcmp(Token, "Remember")) {
fscanf(Handle, "%s", Token);
strcpy(RememberedVars.Elements[RememberedVars.Count++].Name, Token);
} else {
if(!strcmp(Token, "If")) {
fscanf(Handle, "%s", Token);
if(!strcmp(Token, "Eq")) {
fscanf(Handle, "%s", CondVar);
ScanValue(Handle, CondValue);
fscanf(Handle, "%s", Token);
CondType=condEQUAL;
} else if(!strcmp(Token, "NotEq")) {
fscanf(Handle, "%s", CondVar);
ScanValue(Handle, CondValue);
fscanf(Handle, "%s", Token);
CondType=condDIFFERENT;
} else if(Token[0]=='!') {
strcpy(CondVar, &Token[1]);
fscanf(Handle, "%s", Token);
CondType=condFALSE;
} else {
strcpy(CondVar, Token);
fscanf(Handle, "%s", Token);
CondType=condTRUE;
}
}
if(!strcmp(Token, "Ignore")) {
fscanf(Handle, "%s", Token);
AddCondition(CondType, CondVar, CondValue, Token);
} else {
fprintf(stderr, "Wrong command '%s'\n", Token);
exit(1);
}
}
}
}
//-----------------------------------------------------------------
static HRESULT ScanAttribute( const CH * pchStart, const CH * pchEnd, HATT * pAtt)
{
if(pchStart == NULL)
return E_INVALIDARG;
const CH * pch;
int cch;
const CH * pchScan = pchStart;
HRESULT hr;
if (pAtt) memset(pAtt, 0, sizeof(HATT));
SKIPWHITE_FAIL
switch (*pchScan)
{
case _CH('>'): return S_FALSE; // end of tag -- no attribute
case _CH('/'):
// End of empty element (e.g. "<foo ... />"). No more attributes.
return S_FALSE;
case _CH('-'): // comment
if (pAtt)
return ScanComment(pchScan, pchEnd, &pAtt->pchValue, &pAtt->cchValue);
else
return ScanComment(pchScan, pchEnd, 0, 0);
break;
}
// scan Name
hr = ScanName(pchScan, pchEnd, &pch, &cch);
if (FAILED(hr)) return hr;
if (pAtt)
{
pAtt->pchName = pch;
pAtt->cchName = cch;
}
pchScan = pch + cch;
SKIPWHITE_FAIL
if (*pchScan != _CH('='))
return hr;
pchScan++;
SKIPWHITE_FAIL
hr = ScanValue(pchScan, pchEnd, &pch, &cch);
if (SUCCEEDED(hr) && pAtt)
{
pAtt->pchValue = pch;
pAtt->cchValue = cch;
}
return hr;
}
void ParseFrame(FILE* Handle, frame* Frame) {
char Token[MAX_NAME];
char VarName[MAX_NAME];
char VarValue[MAX_NAME];
do fscanf(Handle, "%s", Token);
while(!feof(Handle) && strcmp(Token, "Frame"));
if(feof(Handle)) exit(1);
fscanf(Handle, "%ld", &(Frame->Number));
fscanf(Handle, "%s", Token);
if(strcmp(Token, "Begin")) fprintf(stderr, "No 'Begin' at frame %ld\n", Frame->Number);
fscanf(Handle, "%s", Token);
Frame->Vars.Count=0;
while(strcmp(Token, "End") && !feof(Handle)) {
int i;
strcpy(VarName, Token);
ScanValue(Handle, VarValue);
AddVariable(Frame, VarName, VarValue);
fscanf(Handle, "%s", Token);
}
}
void Scanner::ScanNextToken() {
if (m_endedStream) {
return;
}
if (!m_startedStream) {
return StartStream();
}
// get rid of whitespace, etc. (in between tokens it should be irrelevent)
ScanToNextToken();
// maybe need to end some blocks
PopIndentToHere();
// *****
// And now branch based on the next few characters!
// *****
// end of stream
if (!INPUT) {
return EndStream();
}
if (INPUT.column() == 0 && INPUT.peek() == Keys::Directive) {
return ScanDirective();
}
// document token
if (INPUT.column() == 0 && Exp::DocStart().Matches(INPUT)) {
return ScanDocStart();
}
if (INPUT.column() == 0 && Exp::DocEnd().Matches(INPUT)) {
return ScanDocEnd();
}
// flow start/end/entry
if (INPUT.peek() == Keys::FlowSeqStart ||
INPUT.peek() == Keys::FlowMapStart) {
return ScanFlowStart();
}
if (INPUT.peek() == Keys::FlowSeqEnd || INPUT.peek() == Keys::FlowMapEnd) {
return ScanFlowEnd();
}
if (INPUT.peek() == Keys::FlowEntry) {
return ScanFlowEntry();
}
// block/map stuff
if (Exp::BlockEntry().Matches(INPUT)) {
return ScanBlockEntry();
}
if ((InBlockContext() ? Exp::Key() : Exp::KeyInFlow()).Matches(INPUT)) {
return ScanKey();
}
if (GetValueRegex().Matches(INPUT)) {
return ScanValue();
}
// alias/anchor
if (INPUT.peek() == Keys::Alias || INPUT.peek() == Keys::Anchor) {
return ScanAnchorOrAlias();
}
// tag
if (INPUT.peek() == Keys::Tag) {
return ScanTag();
}
// special scalars
if (InBlockContext() && (INPUT.peek() == Keys::LiteralScalar ||
INPUT.peek() == Keys::FoldedScalar)) {
return ScanBlockScalar();
}
if (INPUT.peek() == '\'' || INPUT.peek() == '\"') {
return ScanQuotedScalar();
}
// plain scalars
if ((InBlockContext() ? Exp::PlainScalar() : Exp::PlainScalarInFlow())
.Matches(INPUT)) {
return ScanPlainScalar();
}
// don't know what it is!
throw ParserException(INPUT.mark(), ErrorMsg::UNKNOWN_TOKEN);
}
/* BobCollectGarbage - garbage collect a heap */
void BobCollectGarbage(BobInterpreter *c)
{
BobProtectedPtrs *ppb;
unsigned char *scan;
BobMemorySpace *ms;
BobDispatch *d;
BobValue obj;
BobStreamPutS("[GC",c->standardError);
/* reverse the memory spaces */
ms = c->oldSpace;
c->oldSpace = c->newSpace;
c->newSpace = ms;
ms->free = ms->base;
/* copy the root objects */
c->nilValue = BobCopyValue(c,c->nilValue);
c->trueValue = BobCopyValue(c,c->trueValue);
c->falseValue = BobCopyValue(c,c->falseValue);
c->symbols = BobCopyValue(c,c->symbols);
c->objectValue = BobCopyValue(c,c->objectValue);
/* copy basic types */
c->methodObject = BobCopyValue(c,c->methodObject);
c->vectorObject = BobCopyValue(c,c->vectorObject);
c->symbolObject = BobCopyValue(c,c->symbolObject);
c->stringObject = BobCopyValue(c,c->stringObject);
c->integerObject = BobCopyValue(c,c->integerObject);
#ifdef BOB_INCLUDE_FLOAT_SUPPORT
c->floatObject = BobCopyValue(c,c->floatObject);
#endif
/* copy the type list */
for (d = c->types; d != NULL; d = d->next) {
if (d->object)
d->object = BobCopyValue(c,d->object);
}
/* copy protected pointers */
for (ppb = c->protectedPtrs; ppb != NULL; ppb = ppb->next) {
BobValue **pp = ppb->pointers;
int count = ppb->count;
for (; --count >= 0; ++pp)
**pp = BobCopyValue(c,**pp);
}
/* copy the stack */
BobCopyStack(c);
/* copy the current code object */
if (c->code)
c->code = BobCopyValue(c,c->code);
/* copy the registers */
c->val = BobCopyValue(c,c->val);
c->env = BobCopyValue(c,c->env);
/* copy any user objects */
if (c->protectHandler)
(*c->protectHandler)(c,c->protectData);
/* scan and copy until all accessible objects have been copied */
scan = c->newSpace->base;
while (scan < c->newSpace->free) {
obj = (BobValue)scan;
#if 0
BobStreamPutS("Scanning ",c->standardOutput);
BobPrint(c,obj,c->standardOutput);
BobStreamPutC('\n',c->standardOutput);
#endif
scan += ValueSize(obj);
ScanValue(c,obj);
}
/* fixup cbase and pc */
if (c->code) {
long pcoff = c->pc - c->cbase;
c->cbase = BobStringAddress(BobCompiledCodeBytecodes(c->code));
c->pc = c->cbase + pcoff;
}
/* count the garbage collections */
++c->gcCount;
{
char buf[128];
sprintf(buf,
" - %lu bytes free out of %lu, collections %lu]\n",
(unsigned long)(c->newSpace->top - c->newSpace->free),
(unsigned long)(c->newSpace->top - c->newSpace->base),
(unsigned long)c->gcCount);
BobStreamPutS(buf,c->standardError);
}
/* destroy any unreachable cobjects */
BobDestroyUnreachableCObjects(c);
}
//-----------------------------------------------------------------
static void ScanItem (const CH * pchStart, const CH * pchEnd, HTOK * pk)
{
if(pchStart == NULL || pk == NULL)
{
VSASSERT(false,"");
return;
}
HRESULT hr;
pk->id = hi_Unknown;
pk->pch = (CH*)pchStart;
pk->cch = 0;
pk->bEnd = false;
if (pchStart >= pchEnd)
{
pk->id = hi_Eof;
return;
}
const CH * pchScan = pchStart;
switch (*pchScan)
{
// case _CH(0):
// pk->id = hi_Eof;
// break;
//
// case _CH('\n'):
// case _CH('\r'):
// pchScan = AdvanceLineBreak((CH*)pchScan);
// pk->id = hi_Eol;
// break;
case _CH('<'):
{
const CH * pchName;
int cch;
pchScan++;
pk->id = hi_Error;
switch (*pchScan)
{
case _CH('!'):
pk->id = hi_Error;
pchScan++;
while (_CH('>') != *pchScan)
{
const CH * pch;
int cch;
SKIPWHITE_RET
if (IsAAlpha(*pchScan))
hr = ScanName(pchScan, pchEnd, &pch, &cch);
else
{
switch(*pchScan)
{
case CH('\''):
case CH('"'):
hr = ScanValue(pchScan, pchEnd, &pch, &cch);
break;
case CH('-'):
hr = ScanComment(pchScan, pchEnd, &pch, &cch);
break;
default:
hr = S_OK;
pch = pchScan;
cch = 1;
break;
}
}
pchScan = pch + cch;
if (FAILED(hr) || (pchScan >= pchEnd))
return;
}
pk->id = hi_TagSpecial;
break;
case _CH('%'): // ASP 'tag'
pk->id = hi_TagSpecial;
do {
do {
pchScan++;
} while ((pchScan < pchEnd) && (_CH('>') != *pchScan));
} while ((pchScan < pchEnd) && (*(pchScan-1) != _CH('%')));
break;
case _CH('/'):
pk->bEnd = true;
pchScan++;
break;
case _CH('?'): //
pk->id = hi_TagSpecial;
pchScan++;
while ((pchScan < pchEnd) && (_CH('>') != *pchScan))
pchScan++;
break;
}
if (pk->id != hi_TagSpecial)
{
pk->id = hi_Error;
SKIPWHITE_RET
if (!IsAAlpha(*pchScan))
return;
pchName = pchScan;
while ((pchScan < pchEnd) && IsAAlNum(*pchScan))
pchScan++;
if (pchScan >= pchEnd)
return;
cch = (int)(pchScan - pchName);
if (cch <= cchMaxTag && cch > 0)
{
CH * pszName = (CH*)_alloca((cch+1)*CBCH );
strcchcopy(pszName, cch+1, pchName);
pk->id = LookupElement(pszName);
}
else
return;
if (!pk->bEnd)
{
// scan attributes and comments
for(;;)
{
HATT hatt;
HRESULT hr = ScanAttribute(pchScan, pchEnd, &hatt);
if (FAILED(hr))
{
pk->id = hi_Error;
return;
}
if (S_FALSE == hr)
break;
pchScan = hatt.pchValue ? hatt.pchValue + hatt.cchValue : hatt.pchName + hatt.cchName;
}
}
}
// Skip over whitespace and, if this is an empty element, the closing '/' (e.g. "<foo ... />")
while ((pchScan < pchEnd) && ((*pchScan <= 32) || (*pchScan == _CH('/'))))
pchScan++;
if ((pchScan >= pchEnd) || (_CH('>') != *pchScan))
pk->id = hi_Error;
pchScan++;
}
break;
// case _CH('&'):
// pk->id = hi_Entity;
// if (!ScanEntity(pchScan, &pk->ch, &pchScan))
// goto L_Text;
// break;
default:
//L_Text:
pk->id = hi_Text;
for (bool f = true; f && (pchScan < pchEnd); )
{
switch (*pchScan)
{
// case _CH(0):
// case _CH('\n'):
// case _CH('\r'):
// case _CH('&'):
case _CH('<'):
f = false;
break;
default:
pchScan++;
break;
}
}
break;
}
void FScanner::MustGetValue(bool allowfloat)
{
if (!ScanValue(allowfloat)) ScriptError(allowfloat ? "Numeric constant expected" : "Integer constant expected");
}
// ScanNextToken
// . The main scanning function; here we branch out and
// scan whatever the next token should be.
void Scanner::ScanNextToken()
{
if(m_endedStream)
return;
if(!m_startedStream)
return StartStream();
// get rid of whitespace, etc. (in between tokens it should be irrelevent)
ScanToNextToken();
// check the latest simple key
VerifySimpleKey();
// maybe need to end some blocks
PopIndentTo(INPUT.column);
// *****
// And now branch based on the next few characters!
// *****
// end of stream
if(INPUT.peek() == EOF)
return EndStream();
if(INPUT.column == 0 && INPUT.peek() == Keys::Directive)
return ScanDirective();
// document token
if(INPUT.column == 0 && Exp::DocStart.Matches(INPUT))
return ScanDocStart();
if(INPUT.column == 0 && Exp::DocEnd.Matches(INPUT))
return ScanDocEnd();
// flow start/end/entry
if(INPUT.peek() == Keys::FlowSeqStart || INPUT.peek() == Keys::FlowMapStart)
return ScanFlowStart();
if(INPUT.peek() == Keys::FlowSeqEnd || INPUT.peek() == Keys::FlowMapEnd)
return ScanFlowEnd();
if(INPUT.peek() == Keys::FlowEntry)
return ScanFlowEntry();
// block/map stuff
if(Exp::BlockEntry.Matches(INPUT))
return ScanBlockEntry();
if((m_flowLevel == 0 ? Exp::Key : Exp::KeyInFlow).Matches(INPUT))
return ScanKey();
if((m_flowLevel == 0 ? Exp::Value : Exp::ValueInFlow).Matches(INPUT))
return ScanValue();
// alias/anchor
if(INPUT.peek() == Keys::Alias || INPUT.peek() == Keys::Anchor)
return ScanAnchorOrAlias();
// tag
if(INPUT.peek() == Keys::Tag)
return ScanTag();
// special scalars
if(m_flowLevel == 0 && (INPUT.peek() == Keys::LiteralScalar || INPUT.peek() == Keys::FoldedScalar))
return ScanBlockScalar();
if(INPUT.peek() == '\'' || INPUT.peek() == '\"')
return ScanQuotedScalar();
// plain scalars
if((m_flowLevel == 0 ? Exp::PlainScalar : Exp::PlainScalarInFlow).Matches(INPUT))
return ScanPlainScalar();
// don't know what it is!
throw ParserException(INPUT.line, INPUT.column, ErrorMsg::UNKNOWN_TOKEN);
}
