// ["?"]Keyword [["^"]Option["/"Translation]]
// [":"
// ["^"]Value ["/" Translation].
// ]
Statement* Parser::ParseStatement()
{
AutoDelete<Statement> statement(new Statement());
if (!ParseKeyword(statement.Get())) {
return NULL;
}
SkipWhitespaceSeparator();
if (!ParseOption(statement.Get())) {
return NULL;
}
SkipWhitespaceSeparator();
// [":" ... ]
if (GetCurrentChar() == ':') {
NextChar();
SkipWhitespaceSeparator();
if (!ParseValue(statement.Get())) {
return NULL;
}
}
SkipWhitespaceSeparator();
if (GetCurrentChar() == kEof || GetCurrentChar() == kLf || GetCurrentChar() == kCr) {
UpdateStatementType(statement.Get());
Statement* result = statement.Release();
return result;
} else {
Error("Newline expected at end of statement");
return NULL;
}
}
bool CAsmFile::parse()
{
CNodeManageFile::Read();
ToLine(m_pData, m_len);
delete m_pData;
m_pData = NULL;
bool bRet = true;
bRet &= ParseBlockCMT();
bRet &= ParseLineCMT();
bRet &= ParseKeyword();
return bRet;
}
bool ParseNaviMesh(Core::Buffer &buffer, void* object)
{
Attributes::INaviMesh* value = (Attributes::INaviMesh*)object;
Parser* parser = GetDefaultParser();
CHECK_START(buffer);
Core::String name;
while (1)
{
Core::String word = buffer.ReadWord();
KeywordCode code = ParseKeyword(word);
switch (code)
{
case WORD_CLOSE_BRACKET:
{
return true;
}
case WORD_WORLD_MATRIX:
{
Math::mat4 m;
parser->Parse<Math::mat4>(WORD_MATRIX4X4F, buffer, m);
value->SetTransform(m);
}
break;
case WORD_VERTEX_POSITION:
{
Math::vec3v v;
parser->Parse(WORD_VEC3FV, buffer, &v);
value->SetVertexPositions(v.data(), (std::uint32_t)v.size());
}
break;
case WORD_NORMALS:
{
Math::vec3v v;
parser->Parse(WORD_VEC3FV, buffer, v);
value->SetVertexNormals(v.data(), (std::uint32_t)v.size());
}
break;
case WORD_FACES:
{
Math::ivec3v f;
parser->Parse(WORD_VEC3IV, buffer, f);
value->SetTriangles(f.data(), (std::uint32_t)f.size());
}
break;
default:
throw Error::LoaderException(L"Unexpected keyword " + word);
}
}
return false;
}
static const char *ParseValue(ParseArgs& args, const char *data)
{
data = SkipWS(data);
switch (*data) {
case '"':
return ParseString(args, data);
case '0': case '1': case '2': case '3':
case '4': case '5': case '6': case '7':
case '8': case '9': case '-':
return ParseNumber(args, data);
case '{':
return ParseObject(args, data);
case '[':
return ParseArray(args, data);
case 't':
return ParseKeyword(args, data, "true", Type_Bool);
case 'f':
return ParseKeyword(args, data, "false", Type_Bool);
case 'n':
return ParseKeyword(args, data, "null", Type_Null);
default:
return NULL;
}
}
spFile* CJSourceParser::Parse( char* start, char* end )
{
// set up state variables
mCurVis = SP_VIS_PRIVATE;
spFile* pTopCtx = new spFile();
mpCurCtx = pTopCtx;
mIsVirtual = 0;
mIsTemplate = 0;
mNestingLevel = 0;
m_cur = start;
mpStart = start;
mpEnd = end;
_gSrcEnd = mpEnd; // let all the C-functions "smell" the end of file
_gSrcStart = start;
_gLineNo = 0;
clear_commets_queue();
// main parsing loop
do
{
if ( !get_next_token( m_cur ) )
// end of source reached
return pTopCtx;
if ( memcmp( m_cur, "ScriptSection( const string&",
strlen( "ScriptSection( const string&" )
) == 0
)
{
// int o = 0;
// ++o;
}
switch (*m_cur)
{
case '#' :
{
AddMacroNode( m_cur );
continue;
}
case ':' :
{
skip_token( m_cur );
continue;
}
case ';' :
{
skip_token( m_cur );
continue;
}
case ')' :
{
skip_token( m_cur );
continue;
}
case '=' :
{
skip_token( m_cur );
continue;
}
default: break;
}
// 'const' is a part of the return type, not a keyword here
if ( strncmp(m_cur, "const", 5) != 0 && is_keyword( m_cur ) )
{
// parses, token, if token identifies
// the container context (e.g. class/namespace)
// the corresponding context object is created
// and set as current context
ParseKeyword( m_cur );
continue;
}
if ( *m_cur >= _T('0') && *m_cur <= _T('9') )
{
skip_token( m_cur );
continue;
}
if ( *m_cur == _T('}') )
{
if ( mCurCtxType != SP_CTX_CLASS )
{
// FOR NOW:: disable the below assertion
// DBG:: unexpected closing-bracket found
//ASSERT(0);
skip_token( m_cur ); // just skip it
continue;
}
if ( mpCurCtx->GetType() == SP_CTX_CLASS )
{
int curOfs = ( (m_cur+1) - _gSrcStart );
mpCurCtx->mContextLength = ( curOfs - mpCurCtx->mSrcOffset );
}
--mNestingLevel;
// terminate operation/class/namespace context
// TBD:: check if it's really this type of context
wxASSERT( mpCurCtx );
mpCurCtx = mpCurCtx->GetOutterContext();
wxASSERT( mpCurCtx );
if ( mNestingLevel == 0 )
{
mCurCtxType = SP_CTX_FILE;
// not-nested class delclaration finished,
// rest template flag in any case
mIsTemplate = 0;
}
skip_token( m_cur );
continue;
}
bool isAMacro = false;
if ( is_function( m_cur, isAMacro ) )
{
if ( isAMacro )
{
skip_token( m_cur );
continue;
}
char* savedPos = m_cur;
int tmpLnNo;
store_line_no( tmpLnNo );
wxUnusedVar( tmpLnNo );
isAMacro = false;
if ( !ParseNameAndRetVal( m_cur, isAMacro ) )
{
if ( !isAMacro )
{
m_cur = savedPos;
SkipFunction( m_cur );
}
continue;
}
if ( !ParseArguments( m_cur ) )
{
// failure while parsing arguments,
// remove enclosing operation context
spContext* pFailed = mpCurCtx;
mpCurCtx = mpCurCtx->GetOutterContext();
mpCurCtx->RemoveChild( pFailed );
skip_to_eol( m_cur );
//m_cur = savedPos;
}
else
{
// otherwise, successfully close operation context:
clear_commets_queue();
SkipFunctionBody( m_cur );
mpCurCtx = mpCurCtx->GetOutterContext();
// DBG::
wxASSERT( mpCurCtx );
}
}
else // otherwise it's declaration of a variable;
{
// now, the cursor point to the end of statement (';' token)
if ( mCurCtxType != SP_CTX_CLASS )
{
// non-class members are ignored
skip_token( m_cur ); // skip the end of statement
continue;
}
ParseMemberVar( m_cur );
}
} while( 1 );
}
Core::Pointer<Core::IObject> ParseAnything(Core::Buffer& buffer)
{
Parser* parser = GetDefaultParser();
while (!buffer.IsEnd())
{
Core::String word = buffer.ReadWord();
KeywordCode code = ParseKeyword(word);
switch(code)
{
/*case WORD_MAPDESCTEXT:
{
std::unique_ptr<Attributes::Terrain> terrain(new Attributes::Terrain);
parser->Parse(WORD_MAPDESCTEXT, buffer, (void)terrain.get());
return terrain.release();
}*/
case WORD_TRANSFORMTEXT:
{
Core::String word = buffer.ReadWord();
if (word == L"transform") {
auto transform = System::CreateInstancePtr<Attributes::ITransform>(
Attributes::CLSID_Transform, Attributes::IID_ITransform);
parser->Parse(WORD_TRANSFORM, buffer, transform.get());
return transform;
}
}
case WORD_ARMATURE_SCHEMA_TEXT:
{
Core::String word = buffer.ReadWord();
auto schema = System::CreateInstancePtr<Attributes::IArmatureSchema>(
Attributes::CLSID_ArmatureSchema, Attributes::IID_IArmatureSchema);
parser->Parse(WORD_ARMATURE_SCHEMA, buffer, schema.get());
schema->SetName(word);
return schema;
}
case WORD_ARMATURETEXT:
{
Core::String word = buffer.ReadWord();
auto armature = System::CreateInstancePtr<Attributes::IArmature>(
Attributes::CLSID_Armature, Attributes::IID_IArmature);
parser->Parse(WORD_ARMATURE, buffer, armature.get());
return armature;
}
case WORD_ACTIONTEXT:
{
Core::String word = buffer.ReadWord();
auto animation = System::CreateInstancePtr<Attributes::IAnimation>(
Attributes::CLSID_Animation, Attributes::IID_IAnimation);
parser->Parse(WORD_ACTION, buffer, animation.get());
animation->SetName(word);
return animation;
}
case WORD_STATICMESHTEXT:
{
Core::String word = buffer.ReadWord();
auto mesh = System::CreateInstancePtr<Attributes::IGeometry>(
Attributes::CLSID_Geometry3D, Attributes::IID_IGeometry);
parser->Parse(WORD_STATIC_MESH, buffer, mesh.get());
mesh->SetName(word);
return mesh;
}
break;
case WORD_MATERIALTEXT:
{
Core::String word = buffer.ReadWord();
auto material = System::CreateInstancePtr<Attributes::IMaterial>(
Attributes::CLSID_Material, Attributes::IID_IMaterial);
parser->Parse(WORD_MATERIAL, buffer, material.get());
return material;
}
case WORD_NAVIMESHTEXT:
{
Core::String word = buffer.ReadWord();
auto navi_mesh = System::CreateInstancePtr<Attributes::INaviMesh>(
Attributes::CLSID_NaviMesh, Attributes::IID_INaviMesh);
parser->Parse(WORD_NAVI_MESH, buffer, navi_mesh.get());
return navi_mesh;
}
case WORD_PATHTEXT:
{
Core::String word = buffer.ReadWord();
auto path = System::CreateInstancePtr<Attributes::ICurvePath>(
Attributes::CLSID_CurvePath, Attributes::IID_ICurvePath);
parser->Parse(WORD_CURVE_PATH, buffer, path.get());
return path;
}
/*case WORD_RIVERTEXT:
{
Core::String word = buffer.ReadWord();
std::unique_ptr<Attributes::River> river(new Attributes::River);
ParseRiver(buffer, *river);
return river.release();
}*/
case WORD_SCENETEXT:
{
auto graph = System::CreateInstancePtr<SceneModule::IScene>(
SceneModule::CLSID_Scene, SceneModule::IID_IScene);
parser->Parse(WORD_SCENE_GRAPH, buffer, graph.get());
return graph;
}
/* case WORD_SUNTEXT:
{
Core::String word = buffer.ReadWord();
std::unique_ptr<Attributes::Sun> sun(new Attributes::Sun);
ParseSun(buffer, *sun);
return sun.release();
}*/
/*case WORD_TERRAINTEXT:
{
Core::String word = buffer.ReadWord();
Attributes::ITerrainMesh > mesh{ nullptr };
ParseTerrainMesh(buffer, *mesh);
return mesh.release();
}*/
case WORD_SKINMESH_TEXT:
{
Core::String word = buffer.ReadWord();
auto mesh = System::CreateInstancePtr<Attributes::IGeometry>(
Attributes::CLSID_Geometry3D, Attributes::IID_IGeometry);
parser->Parse(WORD_SKIN_MESH, buffer, mesh.get());
mesh->SetName(word);
return mesh;
}
case WORD_DIRLIGHTTEXT:
{
Core::String word = buffer.ReadWord();
auto light = System::CreateInstancePtr<Attributes::IDirectionalLight>(
Attributes::CLSID_Light, Attributes::IID_IDirectionalLight);
parser->Parse(WORD_DIRECTIONAL_LIGHT, buffer, light.get());
light->SetName(word);
return light;
}
case WORD_POINTLIGHTTEXT:
{
Core::String word = buffer.ReadWord();
auto light = System::CreateInstancePtr<Attributes::IPointLight>(
Attributes::CLSID_Light, Attributes::IID_IPointLight);
parser->Parse(WORD_POINT_LIGHT, buffer, light.get());
light->SetName(word);
return light;
}
case WORD_SPOTLIGHTTEXT:
{
Core::String word = buffer.ReadWord();
auto light = System::CreateInstancePtr<Attributes::ISpotLight>(
Attributes::CLSID_Light, Attributes::IID_ISpotLight);
parser->Parse(WORD_SPOT_LIGHT, buffer, light.get());
light->SetName(word);
return light;
}
case WORD_CAMERATEXT:
{
Core::String word = buffer.ReadWord();
if (ParseKeyword(word) == WORD_PERSPECTIVE_CAMERA) {
auto camera = System::CreateInstancePtr<Attributes::IPerspectiveCamera>(
Attributes::CLSID_PerspectiveCamera, Attributes::IID_IPerspectiveCamera);
parser->Parse(WORD_PERSPECTIVE_CAMERA, buffer, camera.get());
return camera;
}
return Core::Pointer < Core::IObject > {nullptr, Core::DestroyObject};
}
default:
throw Error::LoaderException(L"Unexpected keyword " + word);
}
}
throw Error::LoaderException(L"Can't parse something");
}
bool ParseMaterial(Core::Buffer& buffer, void* object)
{
Parser* parser = GetDefaultParser();
Attributes::IMaterial* mat = (Attributes::IMaterial*)(object);
CHECK_START(buffer);
Core::String name;
while (1)
{
Core::String word = buffer.ReadWord();
KeywordCode code = ParseKeyword(word);
switch (code)
{
case WORD_CLOSE_BRACKET:
return true;
case WORD_NAME:
{
Core::String value;
parser->Parse(WORD_STRING, buffer, &value);
mat->SetName(value);
}
break;
case WORD_ALPHA:
{
float value;
parser->Parse(WORD_FLOAT, buffer, &value);
mat->SetAlpha(value);
}
break;
case WORD_AMBIENT:
{
float value;
parser->Parse(WORD_FLOAT, buffer, value);
mat->SetAmbient(value);
}
break;
case WORD_DARKNESS:
{
float value;
parser->Parse(WORD_FLOAT, buffer, &value);
mat->SetDarkness(value);
}
break;
case WORD_DIFFUSE_COLOR:
{
Math::vec3 value;
parser->Parse(WORD_VEC3F, buffer, &value);
mat->SetDiffuseColor(Math::vec4(value, mat->GetAlpha()));
}
break;
case WORD_DIFFUSE_FRESNEL:
{
float value;
parser->Parse(WORD_FLOAT, buffer, &value);
mat->SetDiffuseFresnel(value);
}
break;
case WORD_DIFFUSE_FRESNEL_FACTOR:
{
float value;
parser->Parse(WORD_FLOAT, buffer, &value);
mat->SetDiffuseFresnelFactor(value);
}
break;
case WORD_DIFFUSE_INTENSITY:
{
float value;
parser->Parse(WORD_FLOAT, buffer, &value);
mat->SetDiffuseIntensity(value);
}
break;
case WORD_EMIT:
{
float value;
parser->Parse(WORD_FLOAT, buffer, &value);
mat->SetEmit(value);
}
break;
case WORD_MIRROR_COLOR:
{
Math::vec3 value;
parser->Parse(WORD_VEC3F, buffer, &value);
mat->SetMirrorColor(value);
}
break;
case WORD_ROUGHNESS:
{
float value;
parser->Parse(WORD_FLOAT, buffer, &value);
mat->SetRoughness(value);
}
break;
case WORD_SPECULAR_ALPHA:
{
float value;
parser->Parse(WORD_FLOAT, buffer, &value);
mat->SetSpecularAlpha(value);
}
break;
case WORD_SPECULAR_COLOR:
{
Math::vec3 value;
parser->Parse(WORD_VEC3F, buffer, &value);
mat->SetSpecularColor(Math::vec4(value, mat->GetSpecularAlpha()));
}
break;
case WORD_SPECULAR_HARDNESS:
{
float value;
parser->Parse(WORD_FLOAT, buffer, &value);
mat->SetSpecularFactor(value);
}
break;
case WORD_SPECULAR_INTENSITY:
{
float value;
parser->Parse(WORD_FLOAT, buffer, &value);
mat->SetSpecularIntensity(value);
}
break;
case WORD_SPECULAR_IOR:
{
float value;
parser->Parse(WORD_FLOAT, buffer, &value);
mat->SetSpecularIndexOfRefraction(value);
}
break;
case WORD_SPECULAR_SLOPE:
{
float value;
parser->Parse(WORD_FLOAT, buffer, &value);
mat->SetSpecularSlope(value);
}
break;
case WORD_TRANSLUCENCY:
{
float value;
parser->Parse(WORD_FLOAT, buffer, &value);
mat->SetTranslucency(value);
}
break;
case WORD_DIFFUSE_TEXTURE_SLOT:
{
auto slot = System::CreateInstancePtr<Attributes::IDiffuseTextureSlot>(
Attributes::CLSID_TextureSlot, Attributes::IID_IDiffuseTextureSlot);
parser->Parse(WORD_DIFFUSE_TEXTURE_SLOT, buffer, slot.get());
mat->SetDiffuseTextureSlot(slot);
}
break;
case WORD_NORMAL_TEXTURE_SLOT:
{
auto slot = System::CreateInstancePtr<Attributes::INormalTextureSlot>(
Attributes::CLSID_TextureSlot, Attributes::IID_INormalTextureSlot);
parser->Parse(WORD_NORMAL_TEXTURE_SLOT, buffer, slot.get());
mat->SetNormalTextureSlot(slot);
}
break;
case WORD_SPECULAR_TEXTURE_SLOT:
{
auto slot = System::CreateInstancePtr<Attributes::ISpecularIntensityTextureSlot>(
Attributes::CLSID_TextureSlot, Attributes::IID_ISpecularIntensityTextureSlot);
parser->Parse(WORD_SPECULAR_TEXTURE_SLOT, buffer, slot.get());
mat->SetSpecularTextureSlot(slot);
}
break;
default:
throw Error::LoaderException(L"Unexpected keyword " + word);
}
}
return false;
}
StdStrBuf C4RTFFile::GetPlainText()
{
// clear any previous crap
ClearState();
// start with a fresh state
pState = new PropertyState();
pState->eState = psNormal;
StdStrBuf sResult;
// nothing to do for empty RTFs
if (sRTF.getSize()<=0) return sResult;
// parse through all chars
try
{
char c; size_t iPos = 0;
while (iPos < sRTF.getSize())
{
c = ((const char *) sRTF.getData())[iPos++];
// binary parsing?
if (pState->eState == psBinary)
{
if (!--pState->iHexBinCnt) pState->eState = psNormal;
ParseChar(sResult, c);
continue;
}
// normal parsing: Handle state blocks
switch (c)
{
case '{': PushState(); break;
case '}': PopState(); break;
case '\\':
ParseKeyword(sResult, iPos);
break;
case 0x0d: case 0x0a: // ignored chars
break;
default:
// regular char parsing
if (pState->eState == psNormal)
// normal mode
ParseChar(sResult, c);
else if (pState->eState == psHex)
ParseHexChar(sResult, c);
else
throw new ParserError("Invalid State");
break;
}
// next char
}
// all states must be closed in the end
if (pState->pNext) throw new ParserError("Block not closed");
}
catch (ParserError *pe)
{
// invalid RTF file: Display error message instead
sResult = "Invalid RTF file: ";
sResult.Append(pe->ErrorText);
delete pe;
}
// cleanup
ClearState();
// return result
return sResult;
}
PUNK_ENGINE_LOCAL bool ParseTransform(Core::Buffer &buffer, void* object) {
Attributes::ITransform* transform = (Attributes::ITransform*)object;
Parser* parser = GetDefaultParser();
CHECK_START(buffer);
while (1)
{
if (buffer.IsEnd())
throw Error::LoaderException(L"Can't parse object");
Core::String word = buffer.ReadWord();
KeywordCode code = ParseKeyword(word);
switch (code)
{
case WORD_CLOSE_BRACKET:
return true;
case WORD_LOCATION:
{
Math::vec3 value;
parser->Parse<Math::vec3>(WORD_VEC3F, buffer, value);
transform->SetPosition(value);
}
break;
case WORD_ROTATION:
{
Math::quat value;
parser->Parse<Math::quat>(WORD_QUAT, buffer, value);
transform->SetRotation(value);
}
break;
case WORD_SCALE:
{
Math::vec3 value;
parser->Parse<Math::vec3>(WORD_VEC3F, buffer, value);
transform->SetScale(value);
}
break;
case WORD_ENTITY_NAME:
{
Core::String value;
parser->Parse<Core::String>(WORD_STRING, buffer, value);
}
break;
case WORD_BOUNDING_BOX:
{
}
break;
case WORD_ACTION_REF:
{
Core::String name;
parser->Parse<Core::String>(WORD_STRING, buffer, name);
Attributes::IAnimated* animated = nullptr;
transform->QueryInterface(Attributes::IID_IAnimated, (void**)&animated);
if (animated) {
animated->AddAnimation(name);
animated->Release();
}
}
break;
default:
throw Error::LoaderException(L"Unexpected keyword " + word);
}
}
}
