void Start()
{
_scanningFunction = GetComponent <ScanningFunction>();
_grabFunction = GetComponent <ImpulseBeamGrabFunction>();
_lightFunction = GetComponent <LightFunction>();
_scanningFunction.enabled = false;
_grabFunction.enabled = false;
_lightFunction.enabled = false;
GameContext.Instance.Player.OnToolStateChanged += Player_OnToolStateChanged;
GameContext.Instance.Player.OnLightStateChanged += Player_OnLightStateChanged;
}
private bool HandleEntityEnd(bool inLiteral)
{
SaveParsingBuffer();
IDtdEntityInfo oldEntity;
if (!_readerAdapter.PopEntity(out oldEntity, out _currentEntityId))
{
return false;
}
LoadParsingBuffer();
if (oldEntity == null)
{
// external subset popped
Debug.Assert(!ParsingInternalSubset || _freeFloatingDtd);
Debug.Assert(_currentEntityId == 0);
if (_scanningFunction == ScanningFunction.ParamEntitySpace)
{
_scanningFunction = _savedScanningFunction;
}
return false;
}
if (oldEntity.IsExternal)
{
_externalEntitiesDepth--;
}
if (!inLiteral && _scanningFunction != ScanningFunction.ParamEntitySpace)
{
_savedScanningFunction = _scanningFunction;
_scanningFunction = ScanningFunction.ParamEntitySpace;
}
return true;
}
private Token ScanCondSection3()
{
int ignoreSectionDepth = 0;
// skip ignored part
for (;;)
{
while (_xmlCharType.IsTextChar(_chars[_curPos]) && _chars[_curPos] != ']')
{
_curPos++;
}
switch (_chars[_curPos])
{
case '"':
case '\'':
case (char)0x9:
case '&':
_curPos++;
continue;
// eol
case (char)0xA:
_curPos++;
_readerAdapter.OnNewLine(_curPos);
continue;
case (char)0xD:
if (_chars[_curPos + 1] == (char)0xA)
{
_curPos += 2;
}
else if (_curPos + 1 < _charsUsed || _readerAdapter.IsEof)
{
_curPos++;
}
else
{
goto ReadData;
}
_readerAdapter.OnNewLine(_curPos);
continue;
case '<':
if (_charsUsed - _curPos < 3)
{
goto ReadData;
}
if (_chars[_curPos + 1] != '!' || _chars[_curPos + 2] != '[')
{
_curPos++;
continue;
}
ignoreSectionDepth++;
_curPos += 3;
continue;
case ']':
if (_charsUsed - _curPos < 3)
{
goto ReadData;
}
if (_chars[_curPos + 1] != ']' || _chars[_curPos + 2] != '>')
{
_curPos++;
continue;
}
if (ignoreSectionDepth > 0)
{
ignoreSectionDepth--;
_curPos += 3;
continue;
}
else
{
_curPos += 3;
_scanningFunction = ScanningFunction.SubsetContent;
return Token.CondSectionEnd;
}
default:
// end of buffer
if (_curPos == _charsUsed)
{
goto ReadData;
}
// surrogate chars
else
{
char ch = _chars[_curPos];
if (XmlCharType.IsHighSurrogate(ch))
{
if (_curPos + 1 == _charsUsed)
{
goto ReadData;
}
_curPos++;
if (XmlCharType.IsLowSurrogate(_chars[_curPos]))
{
_curPos++;
continue;
}
}
ThrowInvalidChar(_chars, _charsUsed, _curPos);
return Token.None;
}
}
ReadData:
// read new characters into the buffer
if (_readerAdapter.IsEof || ReadData() == 0)
{
if (HandleEntityEnd(false))
{
continue;
}
Throw(_curPos, SR.Xml_UnclosedConditionalSection);
}
_tokenStartPos = _curPos;
}
}
private Token ScanCondSection1()
{
if (_chars[_curPos] != 'I')
{
Throw(_curPos, SR.Xml_ExpectIgnoreOrInclude);
}
_curPos++;
for (;;)
{
if (_charsUsed - _curPos < 5)
{
goto ReadData;
}
switch (_chars[_curPos])
{
case 'N':
if (_charsUsed - _curPos < 6)
{
goto ReadData;
}
if (_chars[_curPos + 1] != 'C' || _chars[_curPos + 2] != 'L' ||
_chars[_curPos + 3] != 'U' || _chars[_curPos + 4] != 'D' ||
_chars[_curPos + 5] != 'E' || _xmlCharType.IsNameSingleChar(_chars[_curPos + 6])
#if XML10_FIFTH_EDITION
|| xmlCharType.IsNCNameHighSurrogateChar( chars[curPos+6] )
#endif
)
{
goto default;
}
_nextScaningFunction = ScanningFunction.SubsetContent;
_scanningFunction = ScanningFunction.CondSection2;
_curPos += 6;
return Token.INCLUDE;
case 'G':
if (_chars[_curPos + 1] != 'N' || _chars[_curPos + 2] != 'O' ||
_chars[_curPos + 3] != 'R' || _chars[_curPos + 4] != 'E' ||
_xmlCharType.IsNameSingleChar(_chars[_curPos + 5])
#if XML10_FIFTH_EDITION
||xmlCharType.IsNCNameHighSurrogateChar( chars[curPos+5] )
#endif
)
{
goto default;
}
_nextScaningFunction = ScanningFunction.CondSection3;
_scanningFunction = ScanningFunction.CondSection2;
_curPos += 5;
return Token.IGNORE;
default:
Throw(_curPos - 1, SR.Xml_ExpectIgnoreOrInclude);
return Token.None;
}
ReadData:
if (ReadData() == 0)
{
Throw(_curPos, SR.Xml_IncompleteDtdContent);
}
}
}
private Token ScanPublicId1()
{
if (_chars[_curPos] != '"' && _chars[_curPos] != '\'')
{
ThrowUnexpectedToken(_curPos, "\"", "'");
}
ScanLiteral(LiteralType.SystemOrPublicID);
_scanningFunction = ScanningFunction.PublicId2;
return Token.Literal;
}
private Token ScanEntity2()
{
switch (_chars[_curPos])
{
case 'P':
if (!EatPublicKeyword())
{
Throw(_curPos, SR.Xml_ExpectExternalOrClose);
}
_nextScaningFunction = ScanningFunction.Entity3;
_scanningFunction = ScanningFunction.PublicId1;
return Token.PUBLIC;
case 'S':
if (!EatSystemKeyword())
{
Throw(_curPos, SR.Xml_ExpectExternalOrClose);
}
_nextScaningFunction = ScanningFunction.Entity3;
_scanningFunction = ScanningFunction.SystemId;
return Token.SYSTEM;
case '"':
case '\'':
ScanLiteral(LiteralType.EntityReplText);
_scanningFunction = ScanningFunction.ClosingTag;
return Token.Literal;
default:
Throw(_curPos, SR.Xml_ExpectExternalIdOrEntityValue);
return Token.None;
}
}
private Token ScanNotation1()
{
switch (_chars[_curPos])
{
case 'P':
if (!EatPublicKeyword())
{
Throw(_curPos, SR.Xml_ExpectExternalOrClose);
}
_nextScaningFunction = ScanningFunction.ClosingTag;
_scanningFunction = ScanningFunction.PublicId1;
return Token.PUBLIC;
case 'S':
if (!EatSystemKeyword())
{
Throw(_curPos, SR.Xml_ExpectExternalOrClose);
}
_nextScaningFunction = ScanningFunction.ClosingTag;
_scanningFunction = ScanningFunction.SystemId;
return Token.SYSTEM;
default:
Throw(_curPos, SR.Xml_ExpectExternalOrPublicId);
return Token.None;
}
}
private Token ScanAttlist6()
{
for (;;)
{
switch (_chars[_curPos])
{
case '"':
case '\'':
ScanLiteral(LiteralType.AttributeValue);
_scanningFunction = ScanningFunction.Attlist1;
return Token.Literal;
case '#':
if (_charsUsed - _curPos < 6)
goto ReadData;
switch (_chars[_curPos + 1])
{
case 'R':
if (_charsUsed - _curPos < 9)
goto ReadData;
if (_chars[_curPos + 2] != 'E' || _chars[_curPos + 3] != 'Q' ||
_chars[_curPos + 4] != 'U' || _chars[_curPos + 5] != 'I' ||
_chars[_curPos + 6] != 'R' || _chars[_curPos + 7] != 'E' ||
_chars[_curPos + 8] != 'D')
{
Throw(_curPos, SR.Xml_ExpectAttType);
}
_curPos += 9;
_scanningFunction = ScanningFunction.Attlist1;
return Token.REQUIRED;
case 'I':
if (_charsUsed - _curPos < 8)
goto ReadData;
if (_chars[_curPos + 2] != 'M' || _chars[_curPos + 3] != 'P' ||
_chars[_curPos + 4] != 'L' || _chars[_curPos + 5] != 'I' ||
_chars[_curPos + 6] != 'E' || _chars[_curPos + 7] != 'D')
{
Throw(_curPos, SR.Xml_ExpectAttType);
}
_curPos += 8;
_scanningFunction = ScanningFunction.Attlist1;
return Token.IMPLIED;
case 'F':
if (_chars[_curPos + 2] != 'I' || _chars[_curPos + 3] != 'X' ||
_chars[_curPos + 4] != 'E' || _chars[_curPos + 5] != 'D')
{
Throw(_curPos, SR.Xml_ExpectAttType);
}
_curPos += 6;
_scanningFunction = ScanningFunction.Attlist7;
return Token.FIXED;
default:
Throw(_curPos, SR.Xml_ExpectAttType);
break;
}
break;
default:
Throw(_curPos, SR.Xml_ExpectAttType);
break;
}
ReadData:
if (ReadData() == 0)
{
Throw(_curPos, SR.Xml_IncompleteDtdContent);
}
}
}
private Token ScanElement2()
{
if (_chars[_curPos] == '#')
{
while (_charsUsed - _curPos < 7)
{
if (ReadData() == 0)
{
Throw(_curPos, SR.Xml_IncompleteDtdContent);
}
}
if (_chars[_curPos + 1] == 'P' && _chars[_curPos + 2] == 'C' &&
_chars[_curPos + 3] == 'D' && _chars[_curPos + 4] == 'A' &&
_chars[_curPos + 5] == 'T' && _chars[_curPos + 6] == 'A')
{
_curPos += 7;
_scanningFunction = ScanningFunction.Element6;
return Token.PCDATA;
}
else
{
Throw(_curPos + 1, SR.Xml_ExpectPcData);
}
}
_scanningFunction = ScanningFunction.Element3;
return Token.None;
}
private Token ScanElement1()
{
for (;;)
{
switch (_chars[_curPos])
{
case '(':
_scanningFunction = ScanningFunction.Element2;
_curPos++;
return Token.LeftParen;
case 'E':
if (_charsUsed - _curPos < 5)
{
goto ReadData;
}
if (_chars[_curPos + 1] == 'M' && _chars[_curPos + 2] == 'P' &&
_chars[_curPos + 3] == 'T' && _chars[_curPos + 4] == 'Y')
{
_curPos += 5;
_scanningFunction = ScanningFunction.ClosingTag;
return Token.EMPTY;
}
goto default;
case 'A':
if (_charsUsed - _curPos < 3)
{
goto ReadData;
}
if (_chars[_curPos + 1] == 'N' && _chars[_curPos + 2] == 'Y')
{
_curPos += 3;
_scanningFunction = ScanningFunction.ClosingTag;
return Token.ANY;
}
goto default;
default:
Throw(_curPos, SR.Xml_InvalidContentModel);
break;
}
ReadData:
if (ReadData() == 0)
{
Throw(_curPos, SR.Xml_IncompleteDtdContent);
}
}
}
private Token ScanClosingTag()
{
if (_chars[_curPos] != '>')
{
ThrowUnexpectedToken(_curPos, ">");
}
_curPos++;
_scanningFunction = ScanningFunction.SubsetContent;
return Token.GreaterThan;
}
private Token ScanDoctype2()
{
switch (_chars[_curPos])
{
case '[':
_curPos++;
_scanningFunction = ScanningFunction.SubsetContent;
return Token.LeftBracket;
case '>':
_curPos++;
_scanningFunction = ScanningFunction.SubsetContent;
return Token.GreaterThan;
default:
Throw(_curPos, SR.Xml_ExpectSubOrClose);
return Token.None;
}
}
private Token ScanDoctype1()
{
switch (_chars[_curPos])
{
case 'P':
if (!EatPublicKeyword())
{
Throw(_curPos, SR.Xml_ExpectExternalOrClose);
}
_nextScaningFunction = ScanningFunction.Doctype2;
_scanningFunction = ScanningFunction.PublicId1;
return Token.PUBLIC;
case 'S':
if (!EatSystemKeyword())
{
Throw(_curPos, SR.Xml_ExpectExternalOrClose);
}
_nextScaningFunction = ScanningFunction.Doctype2;
_scanningFunction = ScanningFunction.SystemId;
return Token.SYSTEM;
case '[':
_curPos++;
_scanningFunction = ScanningFunction.SubsetContent;
return Token.LeftBracket;
case '>':
_curPos++;
_scanningFunction = ScanningFunction.SubsetContent;
return Token.GreaterThan;
default:
Throw(_curPos, SR.Xml_ExpectExternalOrClose);
return Token.None;
}
}
private Token ScanNmtokenExpected()
{
ScanNmtoken();
_scanningFunction = _nextScaningFunction;
return Token.Nmtoken;
}
private Token ScanQNameExpected()
{
ScanQName();
_scanningFunction = _nextScaningFunction;
return Token.QName;
}
private Token ScanAttlist5()
{
switch (_chars[_curPos])
{
case ')':
_curPos++;
_scanningFunction = ScanningFunction.Attlist6;
return Token.RightParen;
case '|':
_curPos++;
_scanningFunction = ScanningFunction.Nmtoken;
_nextScaningFunction = ScanningFunction.Attlist5;
return Token.Or;
default:
ThrowUnexpectedToken(_curPos, ")", "|");
return Token.None;
}
}
private Token ScanElement3()
{
switch (_chars[_curPos])
{
case '(':
_curPos++;
return Token.LeftParen;
case '>':
_curPos++;
_scanningFunction = ScanningFunction.SubsetContent;
return Token.GreaterThan;
default:
ScanQName();
_scanningFunction = ScanningFunction.Element4;
return Token.QName;
}
}
private Token ScanAttlist7()
{
switch (_chars[_curPos])
{
case '"':
case '\'':
ScanLiteral(LiteralType.AttributeValue);
_scanningFunction = ScanningFunction.Attlist1;
return Token.Literal;
default:
ThrowUnexpectedToken(_curPos, "\"", "'");
return Token.None;
}
}
private Token ScanElement4()
{
_scanningFunction = ScanningFunction.Element5;
Token t;
switch (_chars[_curPos])
{
case '*':
t = Token.Star;
break;
case '?':
t = Token.QMark;
break;
case '+':
t = Token.Plus;
break;
default:
return Token.None;
}
if (_whitespaceSeen)
{
Throw(_curPos, SR.Xml_ExpectNoWhitespace);
}
_curPos++;
return t;
}
private Token ScanEntity1()
{
if (_chars[_curPos] == '%')
{
_curPos++;
_nextScaningFunction = ScanningFunction.Entity2;
_scanningFunction = ScanningFunction.Name;
return Token.Percent;
}
else
{
ScanName();
_scanningFunction = ScanningFunction.Entity2;
return Token.Name;
}
}
private Token ScanElement5()
{
switch (_chars[_curPos])
{
case ',':
_curPos++;
_scanningFunction = ScanningFunction.Element3;
return Token.Comma;
case '|':
_curPos++;
_scanningFunction = ScanningFunction.Element3;
return Token.Or;
case ')':
_curPos++;
_scanningFunction = ScanningFunction.Element4;
return Token.RightParen;
case '>':
_curPos++;
_scanningFunction = ScanningFunction.SubsetContent;
return Token.GreaterThan;
default:
Throw(_curPos, SR.Xml_ExpectOp);
return Token.None;
}
}
private Token ScanEntity3()
{
if (_chars[_curPos] == 'N')
{
while (_charsUsed - _curPos < 5)
{
if (ReadData() == 0)
{
goto End;
}
}
if (_chars[_curPos + 1] == 'D' && _chars[_curPos + 2] == 'A' &&
_chars[_curPos + 3] == 'T' && _chars[_curPos + 4] == 'A')
{
_curPos += 5;
_scanningFunction = ScanningFunction.Name;
_nextScaningFunction = ScanningFunction.ClosingTag;
return Token.NData;
}
}
End:
_scanningFunction = ScanningFunction.ClosingTag;
return Token.None;
}
private Token ScanElement6()
{
switch (_chars[_curPos])
{
case ')':
_curPos++;
_scanningFunction = ScanningFunction.Element7;
return Token.RightParen;
case '|':
_curPos++;
_nextScaningFunction = ScanningFunction.Element6;
_scanningFunction = ScanningFunction.QName;
return Token.Or;
default:
ThrowUnexpectedToken(_curPos, ")", "|");
return Token.None;
}
}
private Token ScanPublicId2()
{
if (_chars[_curPos] != '"' && _chars[_curPos] != '\'')
{
_scanningFunction = _nextScaningFunction;
return Token.None;
}
ScanLiteral(LiteralType.SystemOrPublicID);
_scanningFunction = _nextScaningFunction;
return Token.Literal;
}
private Token ScanElement7()
{
_scanningFunction = ScanningFunction.ClosingTag;
if (_chars[_curPos] == '*' && !_whitespaceSeen)
{
_curPos++;
return Token.Star;
}
return Token.None;
}
private Token ScanCondSection2()
{
if (_chars[_curPos] != '[')
{
ThrowUnexpectedToken(_curPos, "[");
}
_curPos++;
_scanningFunction = _nextScaningFunction;
return Token.LeftBracket;
}
private Token ScanAttlist1()
{
switch (_chars[_curPos])
{
case '>':
_curPos++;
_scanningFunction = ScanningFunction.SubsetContent;
return Token.GreaterThan;
default:
if (!_whitespaceSeen)
{
Throw(_curPos, SR.Xml_ExpectingWhiteSpace, ParseUnexpectedToken(_curPos));
}
ScanQName();
_scanningFunction = ScanningFunction.Attlist2;
return Token.QName;
}
}
private bool HandleEntityReference(XmlQualifiedName entityName, bool paramEntity, bool inLiteral, bool inAttribute)
{
Debug.Assert(_chars[_curPos - 1] == ';');
SaveParsingBuffer();
if (paramEntity && ParsingInternalSubset && !ParsingTopLevelMarkup)
{
Throw(_curPos - entityName.Name.Length - 1, SR.Xml_InvalidParEntityRef);
}
SchemaEntity entity = VerifyEntityReference(entityName, paramEntity, true, inAttribute);
if (entity == null)
{
return false;
}
if (entity.ParsingInProgress)
{
Throw(_curPos - entityName.Name.Length - 1, paramEntity ? SR.Xml_RecursiveParEntity : SR.Xml_RecursiveGenEntity, entityName.Name);
}
int newEntityId;
if (entity.IsExternal)
{
if (!_readerAdapter.PushEntity(entity, out newEntityId))
{
return false;
}
_externalEntitiesDepth++;
}
else
{
if (entity.Text.Length == 0)
{
return false;
}
if (!_readerAdapter.PushEntity(entity, out newEntityId))
{
return false;
}
}
_currentEntityId = newEntityId;
if (paramEntity && !inLiteral && _scanningFunction != ScanningFunction.ParamEntitySpace)
{
_savedScanningFunction = _scanningFunction;
_scanningFunction = ScanningFunction.ParamEntitySpace;
}
LoadParsingBuffer();
return true;
}
private Token ScanAttlist2()
{
for (;;)
{
switch (_chars[_curPos])
{
case '(':
_curPos++;
_scanningFunction = ScanningFunction.Nmtoken;
_nextScaningFunction = ScanningFunction.Attlist5;
return Token.LeftParen;
case 'C':
if (_charsUsed - _curPos < 5)
goto ReadData;
if (_chars[_curPos + 1] != 'D' || _chars[_curPos + 2] != 'A' ||
_chars[_curPos + 3] != 'T' || _chars[_curPos + 4] != 'A')
{
Throw(_curPos, SR.Xml_InvalidAttributeType1);
}
_curPos += 5;
_scanningFunction = ScanningFunction.Attlist6;
return Token.CDATA;
case 'E':
if (_charsUsed - _curPos < 9)
goto ReadData;
_scanningFunction = ScanningFunction.Attlist6;
if (_chars[_curPos + 1] != 'N' || _chars[_curPos + 2] != 'T' ||
_chars[_curPos + 3] != 'I' || _chars[_curPos + 4] != 'T')
{
Throw(_curPos, SR.Xml_InvalidAttributeType);
}
switch (_chars[_curPos + 5])
{
case 'I':
if (_chars[_curPos + 6] != 'E' || _chars[_curPos + 7] != 'S')
{
Throw(_curPos, SR.Xml_InvalidAttributeType);
}
_curPos += 8;
return Token.ENTITIES;
case 'Y':
_curPos += 6;
return Token.ENTITY;
default:
Throw(_curPos, SR.Xml_InvalidAttributeType);
break;
}
break;
case 'I':
if (_charsUsed - _curPos < 6)
goto ReadData;
_scanningFunction = ScanningFunction.Attlist6;
if (_chars[_curPos + 1] != 'D')
{
Throw(_curPos, SR.Xml_InvalidAttributeType);
}
if (_chars[_curPos + 2] != 'R')
{
_curPos += 2;
return Token.ID;
}
if (_chars[_curPos + 3] != 'E' || _chars[_curPos + 4] != 'F')
{
Throw(_curPos, SR.Xml_InvalidAttributeType);
}
if (_chars[_curPos + 5] != 'S')
{
_curPos += 5;
return Token.IDREF;
}
else
{
_curPos += 6;
return Token.IDREFS;
}
case 'N':
if (_charsUsed - _curPos < 8 && !_readerAdapter.IsEof)
{
goto ReadData;
}
switch (_chars[_curPos + 1])
{
case 'O':
if (_chars[_curPos + 2] != 'T' || _chars[_curPos + 3] != 'A' ||
_chars[_curPos + 4] != 'T' || _chars[_curPos + 5] != 'I' ||
_chars[_curPos + 6] != 'O' || _chars[_curPos + 7] != 'N')
{
Throw(_curPos, SR.Xml_InvalidAttributeType);
}
_curPos += 8;
_scanningFunction = ScanningFunction.Attlist3;
return Token.NOTATION;
case 'M':
if (_chars[_curPos + 2] != 'T' || _chars[_curPos + 3] != 'O' ||
_chars[_curPos + 4] != 'K' || _chars[_curPos + 5] != 'E' ||
_chars[_curPos + 6] != 'N')
{
Throw(_curPos, SR.Xml_InvalidAttributeType);
}
_scanningFunction = ScanningFunction.Attlist6;
if (_chars[_curPos + 7] == 'S')
{
_curPos += 8;
return Token.NMTOKENS;
}
else
{
_curPos += 7;
return Token.NMTOKEN;
}
default:
Throw(_curPos, SR.Xml_InvalidAttributeType);
break;
}
break;
default:
Throw(_curPos, SR.Xml_InvalidAttributeType);
break;
}
ReadData:
if (ReadData() == 0)
{
Throw(_curPos, SR.Xml_IncompleteDtdContent);
}
}
}
private void ParseInDocumentDtd(bool saveInternalSubset)
{
LoadParsingBuffer();
_scanningFunction = ScanningFunction.QName;
_nextScaningFunction = ScanningFunction.Doctype1;
// doctype name
if (GetToken(false) != Token.QName)
{
OnUnexpectedError();
}
_schemaInfo.DocTypeName = GetNameQualified(true);
// SYSTEM or PUBLIC id
Token token = GetToken(false);
if (token == Token.SYSTEM || token == Token.PUBLIC)
{
ParseExternalId(token, Token.DOCTYPE, out _publicId, out _systemId);
token = GetToken(false);
}
switch (token)
{
case Token.LeftBracket:
if (saveInternalSubset)
{
SaveParsingBuffer(); // this will cause saving the internal subset right from the point after '['
_internalSubsetValueSb = new StringBuilder();
}
ParseInternalSubset();
break;
case Token.GreaterThan:
break;
default:
OnUnexpectedError();
break;
}
SaveParsingBuffer();
if (_systemId != null && _systemId.Length > 0)
{
ParseExternalSubset();
}
}
private Token ScanAttlist3()
{
if (_chars[_curPos] == '(')
{
_curPos++;
_scanningFunction = ScanningFunction.Name;
_nextScaningFunction = ScanningFunction.Attlist4;
return Token.LeftParen;
}
else
{
ThrowUnexpectedToken(_curPos, "(");
return Token.None;
}
}
