// ["?"]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); } } }