1 /*---------------------------------------------------------------------------*
2   Project:  NintendoWare
3   File:     SmInitialFileParser.h
4 
5   Copyright (C)2009-2010 Nintendo Co., Ltd./HAL Laboratory, Inc.  All rights reserved.
6 
7   These coded instructions, statements, and computer programs contain
8   proprietary information of Nintendo of America Inc. and/or Nintendo
9   Company Ltd., and are protected by Federal copyright law.  They may
10   not be disclosed to third parties or copied or duplicated in any form,
11   in whole or in part, without the prior written consent of Nintendo.
12 
13   $Revision: 18422 $
14  *---------------------------------------------------------------------------*/
15 
16 #ifndef SM_INITIAL_FILE_PARSER_H_
17 #define SM_INITIAL_FILE_PARSER_H_
18 
19 #include <ctype.h>
20 #include <stdlib.h>
21 
22 #include <nn/gx.h>
23 #include "../include/SmBase.h"
24 #include "../include/SmFile.h"
25 
26 
27 
28 //------------------------------------------------------------------------------
29 //! 4タイプの値を管理するパラメータクラスです。
30 class SmParam
31 {
32 public:
33     enum
34     {
35         SM_PARAM_TYPE_U32       = 0,
36         SM_PARAM_TYPE_S32       = 1,
37         SM_PARAM_TYPE_F32       = 2,
38         SM_PARAM_TYPE_STRING    = 3
39     };
40     typedef u32 SmParamType;
41 
42     //! コンストラクタです
SmParam()43     SmParam()
44     : m_Type( SM_PARAM_TYPE_U32 ),
45       m_u32Param( 0 )
46     {
47         m_String = "";
48     }
49 
50     //! パラメータタイプを取得します。
GetType()51     SmParamType GetType() const { return m_Type; }
52 
53     //! パラメータを取得します。
GetU32()54     u32 GetU32() const
55     {
56         switch( m_Type )
57         {
58         case SM_PARAM_TYPE_U32:
59             {
60                 return m_u32Param;
61             }
62         case SM_PARAM_TYPE_S32:
63             {
64                 return static_cast<u32>(m_s32Param);
65             }
66         case SM_PARAM_TYPE_F32:
67             {
68                 return static_cast<u32>(m_f32Param);
69             }
70         case SM_PARAM_TYPE_STRING:
71             {
72                 return static_cast<u32>(atoi(m_String.c_str()));
73             }
74 
75         }
76         return 0;
77     }
78 
GetS32()79     s32 GetS32() const
80     {
81         switch( m_Type )
82         {
83         case SM_PARAM_TYPE_U32:
84             {
85                 return static_cast<s32>(m_u32Param);
86             }
87         case SM_PARAM_TYPE_S32:
88             {
89                 return m_s32Param;
90             }
91         case SM_PARAM_TYPE_F32:
92             {
93                 return static_cast<s32>(m_f32Param);
94             }
95         case SM_PARAM_TYPE_STRING:
96             {
97                 return static_cast<s32>(atoi(m_String.c_str()));
98             }
99         }
100         return 0;
101     }
102 
GetF32()103     f32 GetF32() const
104     {
105         switch( m_Type )
106         {
107         case SM_PARAM_TYPE_U32:
108             {
109                 return static_cast<f32>(m_u32Param);
110             }
111         case SM_PARAM_TYPE_S32:
112             {
113                 return static_cast<f32>(m_s32Param);
114             }
115         case SM_PARAM_TYPE_F32:
116             {
117                 return m_f32Param;
118             }
119         case SM_PARAM_TYPE_STRING:
120             {
121                 return static_cast<f32>(atof(m_String.c_str()));
122             }
123         }
124         return 0;
125     }
126 
GetString()127     const char* GetString() const
128     {
129         switch( m_Type )
130         {
131         case SM_PARAM_TYPE_U32:
132         case SM_PARAM_TYPE_S32:
133         case SM_PARAM_TYPE_F32:
134             {
135 //                m_String.Format( "%d", m_u32Param );
136 //                return m_String.c_str();
137                 NW_FATAL_ERROR( "no support!" );
138             }
139 
140         case SM_PARAM_TYPE_STRING:
141             {
142                 return m_String.c_str();
143             }
144         }
145 
146         return NULL;
147     }
148 
149     //! パラメータを設定します。
SetParam(u32 param)150     void SetParam( u32 param )
151     {
152         m_Type      = SM_PARAM_TYPE_U32;
153         m_u32Param  = param;
154     }
155 
SetParam(s32 param)156     void SetParam( s32 param )
157     {
158         m_Type      = SM_PARAM_TYPE_S32;
159         m_s32Param  = param;
160     }
161 
SetParam(f32 param)162     void SetParam( f32 param )
163     {
164         m_Type      = SM_PARAM_TYPE_F32;
165         m_f32Param  = param;
166     }
167 
SetParam(const char * param)168     void SetParam( const char* param )
169     {
170         m_Type      = SM_PARAM_TYPE_STRING;
171         m_String    = param;
172     }
173 
174 private:
175     SmParamType m_Type;
176     union
177     {
178         u32 m_u32Param;
179         s32 m_s32Param;
180         f32 m_f32Param;
181     };
182     std::string m_String;
183 };
184 
185 
186 //---------------------------------------------------------------------------
187 //! 実行される１つのコマンドです。
188 class SmCmd : public SmBase
189 {
190 friend class SmInitialFileParser;
191 
192 private:
193     //! 名前と値を組み合わせたデータです。
194     struct SmData
195     {
196         std::string name;       // 名前
197         SmParam     param;      // 値
198     };
199 
200 public:
201     //! コンストラクタです。
SmCmd()202     SmCmd()
203     : m_Parent( NULL ),
204       m_Child( NULL ),
205       m_Next( NULL )
206     {
207         Init();
208     }
209 
210     //! データの初期化を行います。
Init()211     void Init()
212     {
213         m_Command = "NULL";
214 
215         for ( int i=0; i<16; ++i )
216         {
217             m_Data[i].name = "null";
218             m_Data[i].param.SetParam( 0 );
219         }
220     }
221 
222     //! エレメントを取得します。
GetCommand()223     const char* GetCommand() const
224     {
225         return m_Command.c_str();
226     }
227 
228     //! 名前を指定して値を取得します。
GetF32(const char * strName)229     f32 GetF32( const char* strName ) const
230     {
231         for ( int i=0; i<16; ++i )
232         {
233             const char* name = m_Data[i].name.c_str();
234             if ( strcmp( name, strName ) == 0 )
235             {
236                 return m_Data[i].param.GetF32();
237             }
238         }
239 
240         return 0.f;
241     }
242 
243 private:
244     SmCmd*          m_Parent;
245     SmCmd*          m_Child;
246     SmCmd*          m_Next;
247 
248     std::string     m_Command;     // <XXXX
249     SmData          m_Data[16];    // tx = 10  (16個固定)
250 };
251 
252 
253 //---------------------------------------------------------------------------
254 //! イニシャルファイルを解釈するクラスです。
255 class SmInitialFileParser : public  SmBase
256 {
257     typedef nw::ut::FixedSizeArray<SmCmd*, 64> SmCmdArray;
258 
259 public:
260     SmInitialFileParser();
261     ~SmInitialFileParser();
262 
263     //! 取得可能か問い合わせます。
264     bool    IsGettable();
265 
266     //! コマンドを取得します。
267     SmCmd   GetCmd();
268 
269     //! 初期化ファイルをロードします。
270     bool Load( const wchar_t* configFileName );
271 
272     //! コマンド数を取得します。
GetCmdNum()273     u32 GetCmdNum() const { return m_CmdArray.size(); }
274 
275     //! コマンドを取得します。
GetCmd(u32 no)276     const SmCmd* GetCmd( u32 no ) { return m_CmdArray[no]; }
277 
278 private:
279     //! コマンドツリーを生成します。
280     void _createCmdTree();
281 
282 private:
283     SmFile          m_File;
284 
285     char*           m_Top;
286     char*           m_Current;
287 
288     SmCmdArray      m_CmdArray;
289 };
290 
291 
292 
293 #endif // SM_INITIAL_FILE_PARSER_H_
294