aleajactaest/khanat-code-old
1
0
Fork 0
mirror of https://port.numenaute.org/aleajactaest/khanat-code-old.git synced 2024-11-25 16:26:18 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Changed: Replace some const char* by std::string

Browse source
This commit is contained in:
kervala 2016-12-18 13:45:07 +01:00
parent 77c4520ce3
commit 288b13dbfb
33 changed files with 366 additions and 361 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

12
code/nel/include/nel/georges/form.h
View file

@ -22,7 +22,7 @@
#include "form_elm.h" #include "form_elm.h"
#include "header.h" #include "header.h"
extern bool convertFormFile (const char *oldFileName, const char *newFileName); extern bool convertFormFile (const std::string &oldFileName, const std::string &newFileName);
namespace NLGEORGES namespace NLGEORGES
{ {
@ -35,7 +35,7 @@ class UFormElm;
class CForm : public UForm class CForm : public UForm
{ {
friend class CFormLoader; friend class CFormLoader;
friend bool convertFormFile (const char *oldFileName, const char *newFileName); friend bool convertFormFile (const std::string &oldFileName, const std::string &newFileName);
public: public:
enum { HeldElementCount = 4 }; enum { HeldElementCount = 4 };
@ -73,12 +73,12 @@ public:
// ** IO functions // ** IO functions
// Set the filename before saving the form // Set the filename before saving the form
void write (xmlDocPtr doc, const char *filename); void write (xmlDocPtr doc, const std::string &filename);
// ** Parent access // ** Parent access
// Insert parent before parent indexed "before". // Insert parent before parent indexed "before".
bool insertParent (uint before, const char *filename, CForm *parent); bool insertParent (uint before, const std::string &filename, CForm *parent);
// Remove a parent from parent list // Remove a parent from parent list
void removeParent (uint parent); void removeParent (uint parent);
@ -97,7 +97,7 @@ public:
const std::string &getFilename () const; const std::string &getFilename () const;
// Error handling // Error handling
void warning (bool exception, const char *function, const char *format, ... ) const; void warning (bool exception, const std::string &function, const char *format, ... ) const;
private: private:
@ -114,7 +114,7 @@ private:
// CFormLoader call it // CFormLoader call it
// Set the filename before reading the form // Set the filename before reading the form
void read (xmlNodePtr node, CFormLoader &loader, CFormDfn *dfn, const char *filename); void read (xmlNodePtr node, CFormLoader &loader, CFormDfn *dfn, const std::string &filename);
// Called by read // Called by read
void readParent (const char *parent, CFormLoader &loader); void readParent (const char *parent, CFormLoader &loader);

26
code/nel/include/nel/georges/form_dfn.h
View file

@ -24,7 +24,7 @@
#include "header.h" #include "header.h"
#include "type.h" #include "type.h"
bool convertDfnFile (const char *oldFileName, const char *newFileName); bool convertDfnFile (const std::string &oldFileName, const std::string &newFileName);
namespace NLGEORGES namespace NLGEORGES
{ {
@ -41,7 +41,7 @@ class CFormDfn : public UFormDfn
friend class CFormElm; friend class CFormElm;
friend class CFormLoader; friend class CFormLoader;
friend class CFormElmStruct; friend class CFormElmStruct;
friend bool convertDfnFile (const char *oldFileName, const char *newFileName); friend bool convertDfnFile (const std::string &oldFileName, const std::string &newFileName);
public: public:
// Default cstr // Default cstr
@ -60,7 +60,7 @@ public:
friend class CFormElm; friend class CFormElm;
friend class CFormDfn; friend class CFormDfn;
friend class CFormElmStruct; friend class CFormElmStruct;
friend bool convertDfnFile (const char *oldFileName, const char *newFileName); friend bool convertDfnFile (const std::string &oldFileName, const std::string &newFileName);
public: public:
CEntry () CEntry ()
@ -85,12 +85,12 @@ public:
TEntryType getType () const; TEntryType getType () const;
// Set as a type // Set as a type
void setType (CFormLoader &loader, const char *filename); void setType (CFormLoader &loader, const std::string &filename);
void setType (TEntryType type); void setType (TEntryType type);
// Set as a dfn // Set as a dfn
void setDfn (CFormLoader &loader, const char *filename); void setDfn (CFormLoader &loader, const std::string &filename);
// Set as a dfn pointer // Set as a dfn pointer
void setDfnPointer (); void setDfnPointer ();
@ -99,7 +99,7 @@ public:
const std::string &getName () const; const std::string &getName () const;
// Set element Name // Set element Name
void setName (const char *name); void setName (const std::string &name);
// Get the filename // Get the filename
const std::string &getFilename() const; const std::string &getFilename() const;
@ -108,16 +108,16 @@ public:
const std::string &getFilenameExt() const; const std::string &getFilenameExt() const;
// Set the filename // Set the filename
void setFilename (const char *def); void setFilename (const std::string &def);
// Set the filename extension // Set the filename extension
void setFilenameExt (const char *ext); void setFilenameExt (const std::string &ext);
// Get default value // Get default value
const std::string &getDefault () const; const std::string &getDefault () const;
// Set default value // Set default value
void setDefault (const char *def); void setDefault (const std::string &def);
// Set array flag // Set array flag
void setArrayFlag (bool flag); void setArrayFlag (bool flag);
@ -167,7 +167,7 @@ public:
void removeEntry( uint idx ); void removeEntry( uint idx );
// ** IO functions // ** IO functions
void write (xmlDocPtr root, const char *filename); void write (xmlDocPtr root, const std::string &filename);
// Count parent DFN // Count parent DFN
uint countParentDfn (uint32 round=0) const; uint countParentDfn (uint32 round=0) const;
@ -185,7 +185,7 @@ public:
void setNumParent (uint size); void setNumParent (uint size);
// Set a parent // Set a parent
void setParent (uint parent, CFormLoader &loader, const char *filename); void setParent (uint parent, CFormLoader &loader, const std::string &filename);
// Get a parent // Get a parent
CFormDfn *getParent (uint parent) const; CFormDfn *getParent (uint parent) const;
@ -232,7 +232,7 @@ public:
CFileHeader Header; CFileHeader Header;
// Error handling // Error handling
void warning (bool exception, const char *function, const char *format, ... ) const; void warning (bool exception, const std::string &function, const char *format, ... ) const;
private: private:
// The parents array // The parents array
@ -249,7 +249,7 @@ private:
private: private:
// Read method called by the form loader // Read method called by the form loader
void read (xmlNodePtr doc, CFormLoader &loader, bool forceLoad, const char *filename); void read (xmlNodePtr doc, CFormLoader &loader, bool forceLoad, const std::string &filename);
}; };
} // NLGEORGES } // NLGEORGES

150
code/nel/include/nel/georges/form_elm.h
View file

@ -62,30 +62,30 @@ public:
virtual void getFormName (std::string &result, const CFormElm *child=NULL) const = 0; virtual void getFormName (std::string &result, const CFormElm *child=NULL) const = 0;
// From UFormElm // From UFormElm
virtual bool getNodeByName (const UFormElm **result, const char *name, TWhereIsNode *where, bool verbose, uint32 round=0) const; virtual bool getNodeByName (const UFormElm **result, const std::string &name, TWhereIsNode *where, bool verbose, uint32 round=0) const;
virtual bool getNodeByName (UFormElm **result, const char *name, TWhereIsNode *where, bool verbose, uint32 round=0); virtual bool getNodeByName (UFormElm **result, const std::string &name, TWhereIsNode *where, bool verbose, uint32 round=0);
virtual bool getValueByName (std::string &result, const char *name, TEval evaluate, TWhereIsValue *where, uint32 round=0) const; virtual bool getValueByName (std::string &result, const std::string &name, TEval evaluate, TWhereIsValue *where, uint32 round=0) const;
virtual bool getValueByName (sint8 &result, const char *name, TEval evaluate, TWhereIsValue *where, uint32 round=0) const; virtual bool getValueByName (sint8 &result, const std::string &name, TEval evaluate, TWhereIsValue *where, uint32 round=0) const;
virtual bool getValueByName (uint8 &result, const char *name, TEval evaluate, TWhereIsValue *where, uint32 round=0) const; virtual bool getValueByName (uint8 &result, const std::string &name, TEval evaluate, TWhereIsValue *where, uint32 round=0) const;
virtual bool getValueByName (sint16 &result, const char *name, TEval evaluate, TWhereIsValue *where, uint32 round=0) const; virtual bool getValueByName (sint16 &result, const std::string &name, TEval evaluate, TWhereIsValue *where, uint32 round=0) const;
virtual bool getValueByName (uint16 &result, const char *name, TEval evaluate, TWhereIsValue *where, uint32 round=0) const; virtual bool getValueByName (uint16 &result, const std::string &name, TEval evaluate, TWhereIsValue *where, uint32 round=0) const;
virtual bool getValueByName (sint32 &result, const char *name, TEval evaluate, TWhereIsValue *where, uint32 round=0) const; virtual bool getValueByName (sint32 &result, const std::string &name, TEval evaluate, TWhereIsValue *where, uint32 round=0) const;
virtual bool getValueByName (uint32 &result, const char *name, TEval evaluate, TWhereIsValue *where, uint32 round=0) const; virtual bool getValueByName (uint32 &result, const std::string &name, TEval evaluate, TWhereIsValue *where, uint32 round=0) const;
virtual bool getValueByName (float &result, const char *name, TEval evaluate, TWhereIsValue *where, uint32 round=0) const; virtual bool getValueByName (float &result, const std::string &name, TEval evaluate, TWhereIsValue *where, uint32 round=0) const;
virtual bool getValueByName (double &result, const char *name, TEval evaluate, TWhereIsValue *where, uint32 round=0) const; virtual bool getValueByName (double &result, const std::string &name, TEval evaluate, TWhereIsValue *where, uint32 round=0) const;
virtual bool getValueByName (bool &result, const char *name, TEval evaluate, TWhereIsValue *where, uint32 round=0) const; virtual bool getValueByName (bool &result, const std::string &name, TEval evaluate, TWhereIsValue *where, uint32 round=0) const;
virtual bool getValueByName (NLMISC::CRGBA &result, const char *name, TEval evaluate, TWhereIsValue *where, uint32 round=0) const; virtual bool getValueByName (NLMISC::CRGBA &result, const std::string &name, TEval evaluate, TWhereIsValue *where, uint32 round=0) const;
virtual bool setValueByName (const char *value, const char *name, bool *created); virtual bool setValueByName (const std::string &value, const std::string &name, bool *created);
virtual bool setValueByName (sint8 value, const char *name, bool *created); virtual bool setValueByName (sint8 value, const std::string &name, bool *created);
virtual bool setValueByName (uint8 value, const char *name, bool *created); virtual bool setValueByName (uint8 value, const std::string &name, bool *created);
virtual bool setValueByName (sint16 value, const char *name, bool *created); virtual bool setValueByName (sint16 value, const std::string &name, bool *created);
virtual bool setValueByName (uint16 value, const char *name, bool *created); virtual bool setValueByName (uint16 value, const std::string &name, bool *created);
virtual bool setValueByName (sint32 value, const char *name, bool *created); virtual bool setValueByName (sint32 value, const std::string &name, bool *created);
virtual bool setValueByName (uint32 value, const char *name, bool *created); virtual bool setValueByName (uint32 value, const std::string &name, bool *created);
virtual bool setValueByName (float value, const char *name, bool *created); virtual bool setValueByName (float value, const std::string &name, bool *created);
virtual bool setValueByName (double value, const char *name, bool *created); virtual bool setValueByName (double value, const std::string &name, bool *created);
virtual bool setValueByName (bool value, const char *name, bool *created); virtual bool setValueByName (bool value, const std::string &name, bool *created);
virtual bool setValueByName (NLMISC::CRGBA value, const char *name, bool *created); virtual bool setValueByName (NLMISC::CRGBA value, const std::string &name, bool *created);
virtual UFormElm *getParent () const; virtual UFormElm *getParent () const;
virtual const CType *getType (); virtual const CType *getType ();
virtual bool isArray () const; virtual bool isArray () const;
@ -127,16 +127,16 @@ public:
// ** Convert functions // ** Convert functions
inline bool convertValue (sint8 &result, const char *value) const; inline bool convertValue (sint8 &result, const std::string &value) const;
inline bool convertValue (uint8 &result, const char *value) const; inline bool convertValue (uint8 &result, const std::string &value) const;
inline bool convertValue (sint16 &result, const char *value) const; inline bool convertValue (sint16 &result, const std::string &value) const;
inline bool convertValue (uint16 &result, const char *value) const; inline bool convertValue (uint16 &result, const std::string &value) const;
inline bool convertValue (sint32 &result, const char *value) const; inline bool convertValue (sint32 &result, const std::string &value) const;
inline bool convertValue (uint32 &result, const char *value) const; inline bool convertValue (uint32 &result, const std::string &value) const;
inline bool convertValue (float &result, const char *value) const; inline bool convertValue (float &result, const std::string &value) const;
inline bool convertValue (double &result, const char *value) const; inline bool convertValue (double &result, const std::string &value) const;
inline bool convertValue (bool &result, const char *value) const; inline bool convertValue (bool &result, const std::string &value) const;
inline bool convertValue (NLMISC::CRGBA &result, const char *value) const; inline bool convertValue (NLMISC::CRGBA &result, const std::string &value) const;
// ** Get dependencies // ** Get dependencies
virtual void getDependencies (std::set<std::string> &dependencies) const = 0; virtual void getDependencies (std::set<std::string> &dependencies) const = 0;
@ -144,7 +144,7 @@ public:
// ** Internal node access // ** Internal node access
// Create a node by name. If the node already exists, return it // Create a node by name. If the node already exists, return it
bool createNodeByName (const char *name, const CFormDfn **parentDfn, uint &indexDfn, bool createNodeByName (const std::string &, const CFormDfn **parentDfn, uint &indexDfn,
const CFormDfn **nodeDfn, const CType **nodeType, const CFormDfn **nodeDfn, const CType **nodeType,
CFormElm **node, UFormDfn::TEntryType &type, CFormElm **node, UFormDfn::TEntryType &type,
bool &array, bool &created); bool &array, bool &created);
@ -153,13 +153,13 @@ public:
* Delete a node by name. If the node already exists, return it * Delete a node by name. If the node already exists, return it
*Delete its parent if not used *Delete its parent if not used
*/ */
bool deleteNodeByName (const char *name, const CFormDfn **parentDfn, uint &indexDfn, bool deleteNodeByName (const std::string &name, const CFormDfn **parentDfn, uint &indexDfn,
const CFormDfn **nodeDfn, const CType **nodeType, const CFormDfn **nodeDfn, const CType **nodeType,
CFormElm **node, UFormDfn::TEntryType &type, CFormElm **node, UFormDfn::TEntryType &type,
bool &array); bool &array);
// Search for a node by name // Search for a node by name
bool getNodeByName (const char *name, const CFormDfn **parentDfn, uint &indexDfn, bool getNodeByName (const std::string &name, const CFormDfn **parentDfn, uint &indexDfn,
const CFormDfn **nodeDfn, const CType **nodeType, const CFormDfn **nodeDfn, const CType **nodeType,
CFormElm **node, UFormDfn::TEntryType &type, CFormElm **node, UFormDfn::TEntryType &type,
bool &array, bool &parentVDfnArray, bool verbose, uint32 round) const; bool &array, bool &parentVDfnArray, bool verbose, uint32 round) const;
@ -168,7 +168,7 @@ public:
* Insert an array node by name * Insert an array node by name
* The index asked must be < the size of the array. * The index asked must be < the size of the array.
*/ */
bool arrayInsertNodeByName (const char *name, const CFormDfn **parentDfn, uint &indexDfn, bool arrayInsertNodeByName (const std::string &name, const CFormDfn **parentDfn, uint &indexDfn,
const CFormDfn **nodeDfn, const CType **nodeType, const CFormDfn **nodeDfn, const CType **nodeType,
CFormElm **node, UFormDfn::TEntryType &type, CFormElm **node, UFormDfn::TEntryType &type,
bool &array, bool verbose, uint arrayIndex) const; bool &array, bool verbose, uint arrayIndex) const;
@ -177,7 +177,7 @@ public:
* Delete an array node by name * Delete an array node by name
* The index asked must be < the size of the array. * The index asked must be < the size of the array.
*/ */
bool arrayDeleteNodeByName (const char *name, const CFormDfn **parentDfn, uint &indexDfn, bool arrayDeleteNodeByName (const std::string &name, const CFormDfn **parentDfn, uint &indexDfn,
const CFormDfn **nodeDfn, const CType **nodeType, const CFormDfn **nodeDfn, const CType **nodeType,
CFormElm **node, UFormDfn::TEntryType &type, CFormElm **node, UFormDfn::TEntryType &type,
bool &array, bool verbose, uint arrayIndex) const; bool &array, bool verbose, uint arrayIndex) const;
@ -199,7 +199,7 @@ protected:
* Then, else (*parentDfn / indexDfn ) or *node must be defined. * Then, else (*parentDfn / indexDfn ) or *node must be defined.
* Other values are for result only. * Other values are for result only.
*/ */
static bool getInternalNodeByName (CForm *form, const char *name, const CFormDfn **parentDfn, uint &indexDfn, static bool getInternalNodeByName (CForm *form, const std::string &name, const CFormDfn **parentDfn, uint &indexDfn,
const CFormDfn **nodeDfn, const CType **nodeType, const CFormDfn **nodeDfn, const CType **nodeType,
CFormElm **node, UFormDfn::TEntryType &type, CFormElm **node, UFormDfn::TEntryType &type,
bool &array, TNodeAction action, bool &created, bool &parentVDfnArray, bool verbose, uint32 round); bool &array, TNodeAction action, bool &created, bool &parentVDfnArray, bool verbose, uint32 round);
@ -215,7 +215,7 @@ public:
static const char* tokenize (const char *name, std::string &str, uint &errorIndex, uint &code); static const char* tokenize (const char *name, std::string &str, uint &errorIndex, uint &code);
// ** IO functions // ** IO functions
virtual xmlNodePtr write (xmlNodePtr node, const CForm *form, const char *structName = NULL, bool forceWrite = false) const = 0; virtual xmlNodePtr write (xmlNodePtr node, const CForm *form, const std::string &structName = "", bool forceWrite = false) const = 0;
protected: protected:
@ -235,8 +235,8 @@ protected:
uint32 Round; uint32 Round;
// Error handling // Error handling
static void warning (bool exception, const char *formName, const char *formFileName, const char *function, const char *format, ... ); static void warning (bool exception, const std::string &formName, const std::string &formFileName, const std::string &function, const char *format, ... );
virtual void warning (bool exception, const char *function, const char *format, ... ) const; virtual void warning (bool exception, const std::string &function, const char *format, ... ) const;
private: private:
// Tokens // Tokens
@ -298,7 +298,7 @@ public:
// From CFormElm // From CFormElm
bool isUsed (const CForm *form) const; bool isUsed (const CForm *form) const;
xmlNodePtr write (xmlNodePtr node, const CForm *form, const char *structName, bool forceWrite = false) const; xmlNodePtr write (xmlNodePtr node, const CForm *form, const std::string &structName, bool forceWrite = false) const;
void unlink (CFormElm *child); void unlink (CFormElm *child);
void getFormName (std::string &result, const CFormElm *child) const; void getFormName (std::string &result, const CFormElm *child) const;
void getDependencies (std::set<std::string> &dependencies) const; void getDependencies (std::set<std::string> &dependencies) const;
@ -310,7 +310,7 @@ public:
std::vector<CFormElmStructElm> Elements; std::vector<CFormElmStructElm> Elements;
// Error handling // Error handling
virtual void warning (bool exception, const char *function, const char *format, ... ) const; virtual void warning (bool exception, const std::string &function, const char *format, ... ) const;
}; };
/** /**
@ -332,13 +332,13 @@ public:
// From CFormElm // From CFormElm
bool isUsed (const CForm *form) const; bool isUsed (const CForm *form) const;
xmlNodePtr write (xmlNodePtr node, const CForm *form, const char *structName, bool forceWrite = false) const; xmlNodePtr write (xmlNodePtr node, const CForm *form, const std::string &structName, bool forceWrite = false) const;
// Call by CFormLoader // Call by CFormLoader
void read (xmlNodePtr node, CFormLoader &loader, CForm *form); void read (xmlNodePtr node, CFormLoader &loader, CForm *form);
// Error handling // Error handling
virtual void warning (bool exception, const char *function, const char *format, ... ) const; virtual void warning (bool exception, const std::string &function, const char *format, ... ) const;
}; };
/** /**
@ -377,7 +377,7 @@ public:
bool getArrayValue (NLMISC::CRGBA &result, uint arrayIndex, TEval evaluate, TWhereIsValue *where) const; bool getArrayValue (NLMISC::CRGBA &result, uint arrayIndex, TEval evaluate, TWhereIsValue *where) const;
// From CFormElm // From CFormElm
xmlNodePtr write (xmlNodePtr node, const CForm *form, const char *structName, bool forceWrite = false) const; xmlNodePtr write (xmlNodePtr node, const CForm *form, const std::string &structName, bool forceWrite = false) const;
bool setParent (CFormElm *parent); bool setParent (CFormElm *parent);
void unlink (CFormElm *child); void unlink (CFormElm *child);
bool isUsed (const CForm *form) const; bool isUsed (const CForm *form) const;
@ -406,7 +406,7 @@ public:
std::vector<CElement> Elements; std::vector<CElement> Elements;
// Error handling // Error handling
virtual void warning (bool exception, const char *function, const char *format, ... ) const; virtual void warning (bool exception, const std::string &function, const char *format, ... ) const;
}; };
/** /**
@ -429,7 +429,7 @@ public:
const CType *Type; const CType *Type;
// From CFormElm // From CFormElm
xmlNodePtr write (xmlNodePtr node, const CForm *form, const char *structName, bool forceWrite = false) const; xmlNodePtr write (xmlNodePtr node, const CForm *form, const std::string &structName, bool forceWrite = false) const;
bool setParent (CFormElm *parent); bool setParent (CFormElm *parent);
void getFormName (std::string &result, const CFormElm *child) const; void getFormName (std::string &result, const CFormElm *child) const;
void getDependencies (std::set<std::string> &dependencies) const; void getDependencies (std::set<std::string> &dependencies) const;
@ -453,7 +453,7 @@ public:
bool getValue (NLMISC::CRGBA &result, TEval evaluate) const; bool getValue (NLMISC::CRGBA &result, TEval evaluate) const;
// Set the value, the elt been used // Set the value, the elt been used
void setValue (const char *value); void setValue (const std::string &value);
// Get the raw value. Does not care about any parent or default values // Get the raw value. Does not care about any parent or default values
void getValue (std::string &result) const; void getValue (std::string &result) const;
@ -463,14 +463,14 @@ private:
std::string Value; std::string Value;
// Error handling // Error handling
virtual void warning (bool exception, const char *function, const char *format, ... ) const; virtual void warning (bool exception, const std::string &function, const char *format, ... ) const;
}; };
// *************************************************************************** // ***************************************************************************
// CFormElm inlines // CFormElm inlines
// *************************************************************************** // ***************************************************************************
inline bool CFormElm::convertValue (sint8 &result, const char *value) const inline bool CFormElm::convertValue (sint8 &result, const std::string &value) const
{ {
float tmp; float tmp;
if (NLMISC::fromString(value, tmp)) if (NLMISC::fromString(value, tmp))
@ -482,14 +482,14 @@ inline bool CFormElm::convertValue (sint8 &result, const char *value) const
else else
{ {
// Error message // Error message
warning (false, "convertValue", "Can't convert the string \"%s\" in sint8.", value); warning (false, "convertValue", "Can't convert the string \"%s\" in sint8.", value.c_str());
} }
return false; return false;
} }
// *************************************************************************** // ***************************************************************************
inline bool CFormElm::convertValue (uint8 &result, const char *value) const inline bool CFormElm::convertValue (uint8 &result, const std::string &value) const
{ {
float tmp; float tmp;
if (NLMISC::fromString(value, tmp)) if (NLMISC::fromString(value, tmp))
@ -501,14 +501,14 @@ inline bool CFormElm::convertValue (uint8 &result, const char *value) const
else else
{ {
// Error message // Error message
warning (false, "convertValue", "Can't convert the string \"%s\" in uint8.", value); warning (false, "convertValue", "Can't convert the string \"%s\" in uint8.", value.c_str());
} }
return false; return false;
} }
// *************************************************************************** // ***************************************************************************
inline bool CFormElm::convertValue (sint16 &result, const char *value) const inline bool CFormElm::convertValue (sint16 &result, const std::string &value) const
{ {
float tmp; float tmp;
if (NLMISC::fromString(value, tmp)) if (NLMISC::fromString(value, tmp))
@ -520,14 +520,14 @@ inline bool CFormElm::convertValue (sint16 &result, const char *value) const
else else
{ {
// Error message // Error message
warning (false, "convertValue", "Can't convert the string \"%s\" in sint16.", value); warning (false, "convertValue", "Can't convert the string \"%s\" in sint16.", value.c_str());
} }
return false; return false;
} }
// *************************************************************************** // ***************************************************************************
inline bool CFormElm::convertValue (uint16 &result, const char *value) const inline bool CFormElm::convertValue (uint16 &result, const std::string &value) const
{ {
float tmp; float tmp;
if (NLMISC::fromString(value, tmp)) if (NLMISC::fromString(value, tmp))
@ -539,14 +539,14 @@ inline bool CFormElm::convertValue (uint16 &result, const char *value) const
else else
{ {
// Error message // Error message
warning (false, "convertValue", "Can't convert the string \"%s\" in uint16.", value); warning (false, "convertValue", "Can't convert the string \"%s\" in uint16.", value.c_str());
} }
return false; return false;
} }
// *************************************************************************** // ***************************************************************************
inline bool CFormElm::convertValue (sint32 &result, const char *value) const inline bool CFormElm::convertValue (sint32 &result, const std::string &value) const
{ {
float tmp; float tmp;
if (NLMISC::fromString(value, tmp)) if (NLMISC::fromString(value, tmp))
@ -558,14 +558,14 @@ inline bool CFormElm::convertValue (sint32 &result, const char *value) const
else else
{ {
// Error message // Error message
warning (false, "convertValue", "Can't convert the string \"%s\" in sint32.", value); warning (false, "convertValue", "Can't convert the string \"%s\" in sint32.", value.c_str());
} }
return false; return false;
} }
// *************************************************************************** // ***************************************************************************
inline bool CFormElm::convertValue (uint32 &result, const char *value) const inline bool CFormElm::convertValue (uint32 &result, const std::string &value) const
{ {
float tmp; float tmp;
if (NLMISC::fromString(value, tmp)) if (NLMISC::fromString(value, tmp))
@ -577,14 +577,14 @@ inline bool CFormElm::convertValue (uint32 &result, const char *value) const
else else
{ {
// Error message // Error message
warning (false, "convertValue", "Can't convert the string \"%s\" in uint32.", value); warning (false, "convertValue", "Can't convert the string \"%s\" in uint32.", value.c_str());
} }
return false; return false;
} }
// *************************************************************************** // ***************************************************************************
inline bool CFormElm::convertValue (float &result, const char *value) const inline bool CFormElm::convertValue (float &result, const std::string &value) const
{ {
if (NLMISC::fromString(value, result)) if (NLMISC::fromString(value, result))
{ {
@ -593,16 +593,16 @@ inline bool CFormElm::convertValue (float &result, const char *value) const
else else
{ {
// Error message // Error message
warning (false, "convertValue", "Can't convert the string \"%s\" in float.", value); warning (false, "convertValue", "Can't convert the string \"%s\" in float.", value.c_str());
} }
return false; return false;
} }
// *************************************************************************** // ***************************************************************************
inline bool CFormElm::convertValue (double &result, const char *value) const inline bool CFormElm::convertValue (double &result, const std::string &value) const
{ {
float tmp; double tmp;
if (NLMISC::fromString(value, tmp)) if (NLMISC::fromString(value, tmp))
{ {
result = tmp; result = tmp;
@ -611,14 +611,14 @@ inline bool CFormElm::convertValue (double &result, const char *value) const
else else
{ {
// Error message // Error message
warning (false, "convertValue", "Can't convert the string \"%s\" in double.", value); warning (false, "convertValue", "Can't convert the string \"%s\" in double.", value.c_str());
} }
return false; return false;
} }
// *************************************************************************** // ***************************************************************************
inline bool CFormElm::convertValue (bool &result, const char *value) const inline bool CFormElm::convertValue (bool &result, const std::string &value) const
{ {
int tmp; int tmp;
if (NLMISC::fromString(value, tmp)) if (NLMISC::fromString(value, tmp))
@ -628,7 +628,7 @@ inline bool CFormElm::convertValue (bool &result, const char *value) const
} }
else else
{ {
std::string temp = NLMISC::toLower(std::string(value)); std::string temp = NLMISC::toLower(value);
if (strcmp (temp.c_str (), "true") == 0) if (strcmp (temp.c_str (), "true") == 0)
{ {
result = true; result = true;
@ -642,17 +642,17 @@ inline bool CFormElm::convertValue (bool &result, const char *value) const
} }
// Error message // Error message
warning (false, "convertValue", "Can't convert the string \"%s\" in boolean.", value); warning (false, "convertValue", "Can't convert the string \"%s\" in boolean.", value.c_str());
return false; return false;
} }
// *************************************************************************** // ***************************************************************************
inline bool CFormElm::convertValue (NLMISC::CRGBA &result, const char *value) const inline bool CFormElm::convertValue (NLMISC::CRGBA &result, const std::string &value) const
{ {
float r, g, b; float r, g, b;
if (sscanf (value, "%f,%f,%f", &r, &g, &b) == 3) if (sscanf (value.c_str(), "%f,%f,%f", &r, &g, &b) == 3)
{ {
NLMISC::clamp (r, 0.f, 255.f); NLMISC::clamp (r, 0.f, 255.f);
NLMISC::clamp (g, 0.f, 255.f); NLMISC::clamp (g, 0.f, 255.f);
@ -664,7 +664,7 @@ inline bool CFormElm::convertValue (NLMISC::CRGBA &result, const char *value) co
} }
// Error message // Error message
warning (false, "convertValue", "Can't convert the string \"%s\" in RGB color.", value); warning (false, "convertValue", "Can't convert the string \"%s\" in RGB color.", value.c_str());
return false; return false;
} }

12
code/nel/include/nel/georges/form_loader.h
View file

@ -42,18 +42,18 @@ class CFormLoader : public UFormLoader
public: public:
virtual ~CFormLoader(); virtual ~CFormLoader();
// From UFormLoader // From UFormLoader
UForm *loadForm (const char *filename); UForm *loadForm (const std::string &filename);
UFormDfn *loadFormDfn (const char *filename); UFormDfn *loadFormDfn (const std::string &filename);
UType *loadFormType (const char *filename); UType *loadFormType (const std::string &filename);
// Load type and formDfn // Load type and formDfn
CType *loadType (const char *filename); CType *loadType (const std::string &filename);
CFormDfn *loadFormDfn (const char *filename, bool forceLoad); CFormDfn *loadFormDfn (const std::string &filename, bool forceLoad);
private: private:
// Error handling // Error handling
virtual void warning (bool exception, const char *function, const char *format, ... ) const; virtual void warning (bool exception, const std::string &function, const char *format, ... ) const;
typedef std::map<std::string, NLMISC::CRefPtr<CType> > TTypeMap; typedef std::map<std::string, NLMISC::CRefPtr<CType> > TTypeMap;
typedef std::map<std::string, NLMISC::CRefPtr<CFormDfn> > TFormDfnMap; typedef std::map<std::string, NLMISC::CRefPtr<CFormDfn> > TFormDfnMap;

6
code/nel/include/nel/georges/header.h
View file

@ -44,10 +44,10 @@ public:
}; };
/// Add a log /// Add a log
void addLog (const char *log); void addLog(const std::string &log);
/// Set the comment /// Set the comment
void setComments (const char *comments); void setComments (const std::string &comments);
/// Major version number /// Major version number
uint32 MajorVersion; uint32 MajorVersion;
@ -72,7 +72,7 @@ public:
static const char *getStateString (TState state); static const char *getStateString (TState state);
// Error handling // Error handling
void warning (bool exception, const char *function, const char *format, ... ) const; void warning (bool exception, const std::string &function, const char *format, ... ) const;
}; };
} // NLGEORGES } // NLGEORGES

6
code/nel/include/nel/georges/type.h
View file

@ -80,7 +80,7 @@ public:
// Evaluate a node // Evaluate a node
bool getValue (std::string &result, const class CForm *form, const class CFormElmAtom *node, const class CFormDfn &parentDfn, bool getValue (std::string &result, const class CForm *form, const class CFormElmAtom *node, const class CFormDfn &parentDfn,
uint parentIndex, UFormElm::TEval evaluate, uint32 *where, uint32 round, const char *formName) const; uint parentIndex, UFormElm::TEval evaluate, uint32 *where, uint32 round, const std::string &formName) const;
// Definitions // Definitions
class CDefinition class CDefinition
@ -114,8 +114,8 @@ public:
private: private:
// Error handling // Error handling
virtual void warning (bool exception, const char *formName, const char *formFilename, const char *function, const char *format, ... ) const; virtual void warning (bool exception, const std::string &formName, const std::string &formFilename, const std::string &function, const char *format, ... ) const;
virtual void warning2 (bool exception, const char *function, const char *format, ... ) const; virtual void warning2 (bool exception, const std::string &function, const char *format, ... ) const;
// Type names // Type names
static const char *TypeNames[]; static const char *TypeNames[];

48
code/nel/include/nel/georges/u_form_elm.h
View file

@ -78,8 +78,8 @@ public:
* "position.x" : get the element named x in the struct named position * "position.x" : get the element named x in the struct named position
* "entities[2].color" : get the node named color in the second element of the entities array * "entities[2].color" : get the node named color in the second element of the entities array
*/ */
virtual bool getNodeByName (const UFormElm **result, const char *name, TWhereIsNode *where = NULL, bool reserved=true, uint32 round=0) const = 0; virtual bool getNodeByName (const UFormElm **result, const std::string &name, TWhereIsNode *where = NULL, bool reserved=true, uint32 round=0) const = 0;
virtual bool getNodeByName (UFormElm **result, const char *name, TWhereIsNode *where = NULL, bool reserved=true, uint32 round=0) = 0; virtual bool getNodeByName (UFormElm **result, const std::string &name, TWhereIsNode *where = NULL, bool reserved=true, uint32 round=0) = 0;
/// Where a value has been found /// Where a value has been found
@ -104,19 +104,19 @@ public:
* \return true if the result has been filled, false if the value has not been found or the cast has failed or the evaluation has failed. * \return true if the result has been filled, false if the value has not been found or the cast has failed or the evaluation has failed.
* \see getNodeByName () * \see getNodeByName ()
*/ */
virtual bool getValueByName (std::string &result, const char *namename, TEval evaluate = Eval, TWhereIsValue *where = NULL, uint32 round=0) const = 0; virtual bool getValueByName (std::string &result, const std::string &name, TEval evaluate = Eval, TWhereIsValue *where = NULL, uint32 round=0) const = 0;
virtual bool getValueByName (sint8 &result, const char *name, TEval evaluate = Eval, TWhereIsValue *where = NULL, uint32 round=0) const = 0; virtual bool getValueByName (sint8 &result, const std::string &name, TEval evaluate = Eval, TWhereIsValue *where = NULL, uint32 round=0) const = 0;
virtual bool getValueByName (uint8 &result, const char *name, TEval evaluate = Eval, TWhereIsValue *where = NULL, uint32 round=0) const = 0; virtual bool getValueByName (uint8 &result, const std::string &name, TEval evaluate = Eval, TWhereIsValue *where = NULL, uint32 round=0) const = 0;
virtual bool getValueByName (sint16 &result, const char *name, TEval evaluate = Eval, TWhereIsValue *where = NULL, uint32 round=0) const = 0; virtual bool getValueByName (sint16 &result, const std::string &name, TEval evaluate = Eval, TWhereIsValue *where = NULL, uint32 round=0) const = 0;
virtual bool getValueByName (uint16 &result, const char *name, TEval evaluate = Eval, TWhereIsValue *where = NULL, uint32 round=0) const = 0; virtual bool getValueByName (uint16 &result, const std::string &name, TEval evaluate = Eval, TWhereIsValue *where = NULL, uint32 round=0) const = 0;
virtual bool getValueByName (sint32 &result, const char *name, TEval evaluate = Eval, TWhereIsValue *where = NULL, uint32 round=0) const = 0; virtual bool getValueByName (sint32 &result, const std::string &name, TEval evaluate = Eval, TWhereIsValue *where = NULL, uint32 round=0) const = 0;
virtual bool getValueByName (uint32 &result, const char *name, TEval evaluate = Eval, TWhereIsValue *where = NULL, uint32 round=0) const = 0; virtual bool getValueByName (uint32 &result, const std::string &name, TEval evaluate = Eval, TWhereIsValue *where = NULL, uint32 round=0) const = 0;
virtual bool getValueByName (float &result, const char *name, TEval evaluate = Eval, TWhereIsValue *where = NULL, uint32 round=0) const = 0; virtual bool getValueByName (float &result, const std::string &name, TEval evaluate = Eval, TWhereIsValue *where = NULL, uint32 round=0) const = 0;
virtual bool getValueByName (double &result, const char *name, TEval evaluate = Eval, TWhereIsValue *where = NULL, uint32 round=0) const = 0; virtual bool getValueByName (double &result, const std::string &name, TEval evaluate = Eval, TWhereIsValue *where = NULL, uint32 round=0) const = 0;
virtual bool getValueByName (bool &result, const char *name, TEval evaluate = Eval, TWhereIsValue *where = NULL, uint32 round=0) const = 0; virtual bool getValueByName (bool &result, const std::string &name, TEval evaluate = Eval, TWhereIsValue *where = NULL, uint32 round=0) const = 0;
/// Warning, only R, G and B members are filled, not A. /// Warning, only R, G and B members are filled, not A.
virtual bool getValueByName (NLMISC::CRGBA &result, const char *name, TEval evaluate = Eval, TWhereIsValue *where = NULL, uint32 round=0) const = 0; virtual bool getValueByName (NLMISC::CRGBA &result, const std::string &name, TEval evaluate = Eval, TWhereIsValue *where = NULL, uint32 round=0) const = 0;
/** /**
* Set a form value with its name. If the node doesn't exist, it is created. * Set a form value with its name. If the node doesn't exist, it is created.
@ -129,17 +129,17 @@ public:
* true if the value has been created, false it the value has been filled. * true if the value has been created, false it the value has been filled.
* \return true if the value has been set, false if the value has not been found or hasn't been created. * \return true if the value has been set, false if the value has not been found or hasn't been created.
*/ */
virtual bool setValueByName (const char *value, const char *name, bool *created = NULL) = 0; virtual bool setValueByName (const std::string &value, const std::string &name, bool *created = NULL) = 0;
virtual bool setValueByName (sint8 value, const char *name, bool *created = NULL) = 0; virtual bool setValueByName (sint8 value, const std::string &name, bool *created = NULL) = 0;
virtual bool setValueByName (uint8 value, const char *name, bool *created = NULL) = 0; virtual bool setValueByName (uint8 value, const std::string &name, bool *created = NULL) = 0;
virtual bool setValueByName (sint16 value, const char *name, bool *created = NULL) = 0; virtual bool setValueByName (sint16 value, const std::string &name, bool *created = NULL) = 0;
virtual bool setValueByName (uint16 value, const char *name, bool *created = NULL) = 0; virtual bool setValueByName (uint16 value, const std::string &name, bool *created = NULL) = 0;
virtual bool setValueByName (sint32 value, const char *name, bool *created = NULL) = 0; virtual bool setValueByName (sint32 value, const std::string &name, bool *created = NULL) = 0;
virtual bool setValueByName (uint32 value, const char *name, bool *created = NULL) = 0; virtual bool setValueByName (uint32 value, const std::string &name, bool *created = NULL) = 0;
virtual bool setValueByName (float value, const char *name, bool *created = NULL) = 0; virtual bool setValueByName (float value, const std::string &name, bool *created = NULL) = 0;
virtual bool setValueByName (double value, const char *name, bool *created = NULL) = 0; virtual bool setValueByName (double value, const std::string &name, bool *created = NULL) = 0;
virtual bool setValueByName (bool value, const char *name, bool *created = NULL) = 0; virtual bool setValueByName (bool value, const std::string &name, bool *created = NULL) = 0;
virtual bool setValueByName (NLMISC::CRGBA value, const char *name, bool *created = NULL) = 0; virtual bool setValueByName (NLMISC::CRGBA value, const std::string &name, bool *created = NULL) = 0;
// ** Array element methods // ** Array element methods

6
code/nel/include/nel/georges/u_form_loader.h
View file

@ -43,19 +43,19 @@ public:
* *
* The pointer on the form must be held in a CSmartPtr<UForm>. Returns NULL if the form can't be loaded. * The pointer on the form must be held in a CSmartPtr<UForm>. Returns NULL if the form can't be loaded.
*/ */
virtual UForm *loadForm (const char *filename) = 0; virtual UForm *loadForm (const std::string &filename) = 0;
/** Load a DFN, use NMISC::CPath to find the file. /** Load a DFN, use NMISC::CPath to find the file.
* *
* The pointer on the form must be held in a CSmartPtr<UFormDfn>. Returns NULL if the DFN can't be loaded. * The pointer on the form must be held in a CSmartPtr<UFormDfn>. Returns NULL if the DFN can't be loaded.
*/ */
virtual UFormDfn *loadFormDfn (const char *filename) = 0; virtual UFormDfn *loadFormDfn (const std::string &filename) = 0;
/** Load a type, use NMISC::CPath to find the file. /** Load a type, use NMISC::CPath to find the file.
* *
* The pointer on the form must be held in a CSmartPtr<UType>. Returns NULL if the type can't be loaded. * The pointer on the form must be held in a CSmartPtr<UType>. Returns NULL if the type can't be loaded.
*/ */
virtual UType *loadFormType (const char *filename) = 0; virtual UType *loadFormType (const std::string &filename) = 0;
/// Create a form loader /// Create a form loader
static UFormLoader *createLoader (); static UFormLoader *createLoader ();

12
code/nel/src/georges/form.cpp
View file

@ -104,10 +104,10 @@ CForm::~CForm ()
// *************************************************************************** // ***************************************************************************
void CForm::write (xmlDocPtr doc, const char *filename) void CForm::write (xmlDocPtr doc, const std::string &filename)
{ {
// Save the filename // Save the filename
if (filename) if (!filename.empty())
_Filename = CFile::getFilename (filename); _Filename = CFile::getFilename (filename);
// Create the first node // Create the first node
@ -176,7 +176,7 @@ void CForm::readParent (const char *parent, CFormLoader &loader)
// *************************************************************************** // ***************************************************************************
void CForm::read (xmlNodePtr node, CFormLoader &loader, CFormDfn *dfn, const char *filename) void CForm::read (xmlNodePtr node, CFormLoader &loader, CFormDfn *dfn, const std::string &filename)
{ {
// Save the filename // Save the filename
_Filename = CFile::getFilename (filename); _Filename = CFile::getFilename (filename);
@ -271,7 +271,7 @@ void CForm::write (class NLMISC::IStream &stream)
// *************************************************************************** // ***************************************************************************
bool CForm::insertParent (uint before, const char *filename, CForm *parent) bool CForm::insertParent (uint before, const std::string &filename, CForm *parent)
{ {
// Set or reset ? // Set or reset ?
nlassert (parent); nlassert (parent);
@ -346,7 +346,7 @@ const std::string &CForm::getFilename () const
// *************************************************************************** // ***************************************************************************
void CForm::warning (bool exception, const char *function, const char *format, ... ) const void CForm::warning (bool exception, const std::string &function, const char *format, ... ) const
{ {
// Make a buffer string // Make a buffer string
va_list args; va_list args;
@ -356,7 +356,7 @@ void CForm::warning (bool exception, const char *function, const char *format, .
va_end( args ); va_end( args );
// Set the warning // Set the warning
NLGEORGES::warning (exception, "(CForm::%s) in form (%s) : %s", function, _Filename.c_str (), buffer); NLGEORGES::warning (exception, "(CForm::%s) in form (%s) : %s", function.c_str(), _Filename.c_str (), buffer);
} }
// *************************************************************************** // ***************************************************************************

24
code/nel/src/georges/form_dfn.cpp
View file

@ -56,7 +56,7 @@ void CFormDfn::removeEntry( uint idx )
// *************************************************************************** // ***************************************************************************
void CFormDfn::write (xmlDocPtr doc, const char *filename) void CFormDfn::write (xmlDocPtr doc, const std::string &filename)
{ {
// Save filename // Save filename
_Filename = CFile::getFilename (filename); _Filename = CFile::getFilename (filename);
@ -121,7 +121,7 @@ void CFormDfn::write (xmlDocPtr doc, const char *filename)
// *************************************************************************** // ***************************************************************************
void CFormDfn::read (xmlNodePtr root, CFormLoader &loader, bool forceLoad, const char *filename) void CFormDfn::read (xmlNodePtr root, CFormLoader &loader, bool forceLoad, const std::string &filename)
{ {
// Save filename // Save filename
_Filename = CFile::getFilename (filename); _Filename = CFile::getFilename (filename);
@ -459,9 +459,9 @@ void CFormDfn::setNumParent (uint size)
// *************************************************************************** // ***************************************************************************
void CFormDfn::setParent (uint parent, CFormLoader &loader, const char *filename) void CFormDfn::setParent (uint parent, CFormLoader &loader, const std::string &filename)
{ {
if (strcmp (filename, "")==0) if (filename.empty())
Parents[parent].Parent = NULL; Parents[parent].Parent = NULL;
else else
Parents[parent].Parent = loader.loadFormDfn (filename, false); Parents[parent].Parent = loader.loadFormDfn (filename, false);
@ -470,7 +470,7 @@ void CFormDfn::setParent (uint parent, CFormLoader &loader, const char *filename
// *************************************************************************** // ***************************************************************************
void CFormDfn::CEntry::setType (CFormLoader &loader, const char *filename) void CFormDfn::CEntry::setType (CFormLoader &loader, const std::string &filename)
{ {
TypeElement = EntryType; TypeElement = EntryType;
Dfn = NULL; Dfn = NULL;
@ -485,7 +485,7 @@ void CFormDfn::CEntry::setType( TEntryType type )
// *************************************************************************** // ***************************************************************************
void CFormDfn::CEntry::setDfn (CFormLoader &loader, const char *filename) void CFormDfn::CEntry::setDfn (CFormLoader &loader, const std::string &filename)
{ {
TypeElement = EntryDfn; TypeElement = EntryDfn;
Filename = filename; Filename = filename;
@ -512,7 +512,7 @@ const std::string &CFormDfn::CEntry::getName () const
// *************************************************************************** // ***************************************************************************
void CFormDfn::CEntry::setName (const char *name) void CFormDfn::CEntry::setName (const std::string &name)
{ {
Name = name; Name = name;
} }
@ -526,7 +526,7 @@ const std::string &CFormDfn::CEntry::getDefault () const
// *************************************************************************** // ***************************************************************************
void CFormDfn::CEntry::setDefault (const char *def) void CFormDfn::CEntry::setDefault (const std::string &def)
{ {
Default = def; Default = def;
} }
@ -561,7 +561,7 @@ const std::string &CFormDfn::CEntry::getFilename() const
// *************************************************************************** // ***************************************************************************
void CFormDfn::CEntry::setFilename (const char *def) void CFormDfn::CEntry::setFilename (const std::string &def)
{ {
Filename = def; Filename = def;
} }
@ -849,14 +849,14 @@ const std::string &CFormDfn::CEntry::getFilenameExt() const
// *************************************************************************** // ***************************************************************************
void CFormDfn::CEntry::setFilenameExt (const char *ext) void CFormDfn::CEntry::setFilenameExt (const std::string &ext)
{ {
FilenameExt = ext; FilenameExt = ext;
} }
// *************************************************************************** // ***************************************************************************
void CFormDfn::warning (bool exception, const char *function, const char *format, ... ) const void CFormDfn::warning (bool exception, const std::string &function, const char *format, ... ) const
{ {
// Make a buffer string // Make a buffer string
va_list args; va_list args;
@ -866,7 +866,7 @@ void CFormDfn::warning (bool exception, const char *function, const char *format
va_end( args ); va_end( args );
// Set the warning // Set the warning
NLGEORGES::warning (exception, "(CFormDfn::%s) in form DFN (%s) : %s", function, _Filename.c_str (), buffer); NLGEORGES::warning (exception, "(CFormDfn::%s) in form DFN (%s) : %s", function.c_str(), _Filename.c_str (), buffer);
} }
// *************************************************************************** // ***************************************************************************

246
code/nel/src/georges/form_elm.cpp
View file

@ -356,7 +356,7 @@ CForm *CFormElm::getForm () const
// *************************************************************************** // ***************************************************************************
bool CFormElm::getNodeByName (UFormElm **result, const char *name, TWhereIsNode *where, bool verbose, uint32 round) bool CFormElm::getNodeByName (UFormElm **result, const std::string &name, TWhereIsNode *where, bool verbose, uint32 round)
{ {
const UFormElm *resultConst = NULL; const UFormElm *resultConst = NULL;
if (((const UFormElm*)this)->getNodeByName (&resultConst, name, where, verbose, round)) if (((const UFormElm*)this)->getNodeByName (&resultConst, name, where, verbose, round))
@ -369,7 +369,7 @@ bool CFormElm::getNodeByName (UFormElm **result, const char *name, TWhereIsNode
// *************************************************************************** // ***************************************************************************
bool CFormElm::getNodeByName (const UFormElm **result, const char *name, TWhereIsNode *where, bool verbose, uint32 round) const bool CFormElm::getNodeByName (const UFormElm **result, const std::string &name, TWhereIsNode *where, bool verbose, uint32 round) const
{ {
// The parent Dfn // The parent Dfn
const CFormDfn *parentDfn; const CFormDfn *parentDfn;
@ -402,7 +402,7 @@ bool CFormElm::getNodeByName (const UFormElm **result, const char *name, TWhereI
// *************************************************************************** // ***************************************************************************
bool CFormElm::getValueByName (string& result, const char *name, TEval evaluate, TWhereIsValue *where, uint32 round) const bool CFormElm::getValueByName (string& result, const std::string &name, TEval evaluate, TWhereIsValue *where, uint32 round) const
{ {
// The parent Dfn // The parent Dfn
const CFormDfn *parentDfn; const CFormDfn *parentDfn;
@ -430,13 +430,13 @@ bool CFormElm::getValueByName (string& result, const char *name, TEval evaluate,
else else
{ {
// Error message // Error message
warning (false, "getValueByName", "The node (%s) is not an atom element. Can't return a value.", name); warning (false, "getValueByName", "The node (%s) is not an atom element. Can't return a value.", name.c_str());
} }
} }
else else
{ {
// Error message // Error message
warning (false, "getValueByName", "Can't find the node (%s).", name); warning (false, "getValueByName", "Can't find the node (%s).", name.c_str());
} }
// Error // Error
@ -445,13 +445,13 @@ bool CFormElm::getValueByName (string& result, const char *name, TEval evaluate,
// *************************************************************************** // ***************************************************************************
bool CFormElm::getValueByName (sint8 &result, const char *name, TEval evaluate, TWhereIsValue *where, uint32 round) const bool CFormElm::getValueByName (sint8 &result, const std::string &name, TEval evaluate, TWhereIsValue *where, uint32 round) const
{ {
// Get the string value // Get the string value
string value; string value;
if (getValueByName (value, name, evaluate, where, round)) if (getValueByName (value, name, evaluate, where, round))
{ {
return convertValue (result, value.c_str ()); return convertValue (result, value);
} }
return false; return false;
@ -459,13 +459,13 @@ bool CFormElm::getValueByName (sint8 &result, const char *name, TEval evaluate,
// *************************************************************************** // ***************************************************************************
bool CFormElm::getValueByName (uint8 &result, const char *name, TEval evaluate, TWhereIsValue *where, uint32 round) const bool CFormElm::getValueByName (uint8 &result, const std::string &name, TEval evaluate, TWhereIsValue *where, uint32 round) const
{ {
// Get the string value // Get the string value
string value; string value;
if (getValueByName (value, name, evaluate, where, round)) if (getValueByName (value, name, evaluate, where, round))
{ {
return convertValue (result, value.c_str ()); return convertValue (result, value);
} }
return false; return false;
@ -473,13 +473,13 @@ bool CFormElm::getValueByName (uint8 &result, const char *name, TEval evaluate,
// *************************************************************************** // ***************************************************************************
bool CFormElm::getValueByName (sint16 &result, const char *name, TEval evaluate, TWhereIsValue *where, uint32 round) const bool CFormElm::getValueByName (sint16 &result, const std::string &name, TEval evaluate, TWhereIsValue *where, uint32 round) const
{ {
// Get the string value // Get the string value
string value; string value;
if (getValueByName (value, name, evaluate, where, round)) if (getValueByName (value, name, evaluate, where, round))
{ {
return convertValue (result, value.c_str ()); return convertValue (result, value);
} }
return false; return false;
@ -487,13 +487,13 @@ bool CFormElm::getValueByName (sint16 &result, const char *name, TEval evaluate,
// *************************************************************************** // ***************************************************************************
bool CFormElm::getValueByName (uint16 &result, const char *name, TEval evaluate, TWhereIsValue *where, uint32 round) const bool CFormElm::getValueByName (uint16 &result, const std::string &name, TEval evaluate, TWhereIsValue *where, uint32 round) const
{ {
// Get the string value // Get the string value
string value; string value;
if (getValueByName (value, name, evaluate, where, round)) if (getValueByName (value, name, evaluate, where, round))
{ {
return convertValue (result, value.c_str ()); return convertValue (result, value);
} }
return false; return false;
@ -501,13 +501,13 @@ bool CFormElm::getValueByName (uint16 &result, const char *name, TEval evaluate,
// *************************************************************************** // ***************************************************************************
bool CFormElm::getValueByName (sint32 &result, const char *name, TEval evaluate, TWhereIsValue *where, uint32 round) const bool CFormElm::getValueByName (sint32 &result, const std::string &name, TEval evaluate, TWhereIsValue *where, uint32 round) const
{ {
// Get the string value // Get the string value
string value; string value;
if (getValueByName (value, name, evaluate, where, round)) if (getValueByName (value, name, evaluate, where, round))
{ {
return convertValue (result, value.c_str ()); return convertValue (result, value);
} }
return false; return false;
@ -515,13 +515,13 @@ bool CFormElm::getValueByName (sint32 &result, const char *name, TEval evaluate,
// *************************************************************************** // ***************************************************************************
bool CFormElm::getValueByName (uint32 &result, const char *name, TEval evaluate, TWhereIsValue *where, uint32 round) const bool CFormElm::getValueByName (uint32 &result, const std::string &name, TEval evaluate, TWhereIsValue *where, uint32 round) const
{ {
// Get the string value // Get the string value
string value; string value;
if (getValueByName (value, name, evaluate, where, round)) if (getValueByName (value, name, evaluate, where, round))
{ {
return convertValue (result, value.c_str ()); return convertValue (result, value);
} }
return false; return false;
@ -529,13 +529,13 @@ bool CFormElm::getValueByName (uint32 &result, const char *name, TEval evaluate,
// *************************************************************************** // ***************************************************************************
bool CFormElm::getValueByName (float &result, const char *name, TEval evaluate, TWhereIsValue *where, uint32 round) const bool CFormElm::getValueByName (float &result, const std::string &name, TEval evaluate, TWhereIsValue *where, uint32 round) const
{ {
// Get the string value // Get the string value
string value; string value;
if (getValueByName (value, name, evaluate, where, round)) if (getValueByName (value, name, evaluate, where, round))
{ {
return convertValue (result, value.c_str ()); return convertValue (result, value);
} }
return false; return false;
@ -543,13 +543,13 @@ bool CFormElm::getValueByName (float &result, const char *name, TEval evaluate,
// *************************************************************************** // ***************************************************************************
bool CFormElm::getValueByName (double &result, const char *name, TEval evaluate, TWhereIsValue *where, uint32 round) const bool CFormElm::getValueByName(double &result, const std::string &name, TEval evaluate, TWhereIsValue *where, uint32 round) const
{ {
// Get the string value // Get the string value
string value; string value;
if (getValueByName (value, name, evaluate, where, round)) if (getValueByName (value, name, evaluate, where, round))
{ {
return convertValue (result, value.c_str ()); return convertValue (result, value);
} }
return false; return false;
@ -557,13 +557,13 @@ bool CFormElm::getValueByName (double &result, const char *name, TEval evaluate,
// *************************************************************************** // ***************************************************************************
bool CFormElm::getValueByName (bool &result, const char *name, TEval evaluate, TWhereIsValue *where, uint32 round) const bool CFormElm::getValueByName (bool &result, const std::string &name, TEval evaluate, TWhereIsValue *where, uint32 round) const
{ {
// Get the string value // Get the string value
string value; string value;
if (getValueByName (value, name, evaluate, where, round)) if (getValueByName (value, name, evaluate, where, round))
{ {
return convertValue (result, value.c_str ()); return convertValue (result, value);
} }
return false; return false;
@ -571,13 +571,13 @@ bool CFormElm::getValueByName (bool &result, const char *name, TEval evaluate, T
// *************************************************************************** // ***************************************************************************
bool CFormElm::getValueByName (NLMISC::CRGBA &result, const char *name, TEval evaluate, TWhereIsValue *where, uint32 round) const bool CFormElm::getValueByName (NLMISC::CRGBA &result, const std::string &name, TEval evaluate, TWhereIsValue *where, uint32 round) const
{ {
// Get the string value // Get the string value
string value; string value;
if (getValueByName (value, name, evaluate, where, round)) if (getValueByName (value, name, evaluate, where, round))
{ {
return convertValue (result, value.c_str ()); return convertValue (result, value);
} }
return false; return false;
@ -592,7 +592,7 @@ UFormElm *CFormElm::getParent () const
// *************************************************************************** // ***************************************************************************
bool CFormElm::createNodeByName (const char *name, const CFormDfn **parentDfn, uint &indexDfn, bool CFormElm::createNodeByName (const std::string &name, const CFormDfn **parentDfn, uint &indexDfn,
const CFormDfn **nodeDfn, const CType **nodeType, const CFormDfn **nodeDfn, const CType **nodeType,
CFormElm **node, UFormDfn::TEntryType &type, CFormElm **node, UFormDfn::TEntryType &type,
bool &array, bool &created) bool &array, bool &created)
@ -608,7 +608,7 @@ bool CFormElm::createNodeByName (const char *name, const CFormDfn **parentDfn, u
// *************************************************************************** // ***************************************************************************
bool CFormElm::deleteNodeByName (const char *name, const CFormDfn **parentDfn, uint &indexDfn, bool CFormElm::deleteNodeByName (const std::string &name, const CFormDfn **parentDfn, uint &indexDfn,
const CFormDfn **nodeDfn, const CType **nodeType, const CFormDfn **nodeDfn, const CType **nodeType,
CFormElm **node, UFormDfn::TEntryType &type, CFormElm **node, UFormDfn::TEntryType &type,
bool &array) bool &array)
@ -625,7 +625,7 @@ bool CFormElm::deleteNodeByName (const char *name, const CFormDfn **parentDfn, u
// *************************************************************************** // ***************************************************************************
bool CFormElm::getNodeByName (const char *name, const CFormDfn **parentDfn, uint &indexDfn, bool CFormElm::getNodeByName (const std::string &name, const CFormDfn **parentDfn, uint &indexDfn,
const CFormDfn **nodeDfn, const CType **nodeType, const CFormDfn **nodeDfn, const CType **nodeType,
CFormElm **node, UFormDfn::TEntryType &type, CFormElm **node, UFormDfn::TEntryType &type,
bool &array, bool &parentVDfnArray, bool verbose, uint32 round) const bool &array, bool &parentVDfnArray, bool verbose, uint32 round) const
@ -641,7 +641,7 @@ bool CFormElm::getNodeByName (const char *name, const CFormDfn **parentDfn, uint
// *************************************************************************** // ***************************************************************************
bool CFormElm::arrayInsertNodeByName (const char *name, const CFormDfn **parentDfn, uint &indexDfn, bool CFormElm::arrayInsertNodeByName (const std::string &name, const CFormDfn **parentDfn, uint &indexDfn,
const CFormDfn **nodeDfn, const CType **nodeType, const CFormDfn **nodeDfn, const CType **nodeType,
CFormElm **node, UFormDfn::TEntryType &type, CFormElm **node, UFormDfn::TEntryType &type,
bool &array, bool verbose, uint arrayIndex) const bool &array, bool verbose, uint arrayIndex) const
@ -715,7 +715,7 @@ bool CFormElm::arrayInsertNodeByName (const char *name, const CFormDfn **parentD
// *************************************************************************** // ***************************************************************************
bool CFormElm::arrayDeleteNodeByName (const char *name, const CFormDfn **parentDfn, uint &indexDfn, bool CFormElm::arrayDeleteNodeByName (const std::string &name, const CFormDfn **parentDfn, uint &indexDfn,
const CFormDfn **nodeDfn, const CType **nodeType, const CFormDfn **nodeDfn, const CType **nodeType,
CFormElm **node, UFormDfn::TEntryType &type, CFormElm **node, UFormDfn::TEntryType &type,
bool &array, bool verbose, uint arrayIndex) const bool &array, bool verbose, uint arrayIndex) const
@ -760,7 +760,7 @@ bool CFormElm::arrayDeleteNodeByName (const char *name, const CFormDfn **parentD
// *************************************************************************** // ***************************************************************************
bool CFormElm::getInternalNodeByName (CForm *form, const char *name, const CFormDfn **parentDfn, uint &indexDfn, const CFormDfn **nodeDfn, const CType **nodeType, CFormElm **node, UFormDfn::TEntryType &type, bool &array, TNodeAction action, bool &created, bool &parentVDfnArray, bool verbose, uint32 round) bool CFormElm::getInternalNodeByName (CForm *form, const std::string &name, const CFormDfn **parentDfn, uint &indexDfn, const CFormDfn **nodeDfn, const CType **nodeType, CFormElm **node, UFormDfn::TEntryType &type, bool &array, TNodeAction action, bool &created, bool &parentVDfnArray, bool verbose, uint32 round)
{ {
// *** Init output variables // *** Init output variables
created = false; created = false;
@ -815,7 +815,7 @@ bool CFormElm::getInternalNodeByName (CForm *form, const char *name, const CForm
// *** Parsing variables // *** Parsing variables
// Current token start and end // Current token start and end
const char *startToken = name; const char *startToken = name.c_str();
const char *endToken; const char *endToken;
// Current token start // Current token start
@ -909,7 +909,7 @@ bool CFormElm::getInternalNodeByName (CForm *form, const char *name, const CForm
// Get the virtual node by name // Get the virtual node by name
UFormElm *uelm; UFormElm *uelm;
if (parentPtr->getRootNode ().getNodeByName (&uelm, formName.c_str (), NULL, verbose, round+1) && uelm) if (parentPtr->getRootNode ().getNodeByName (&uelm, formName, NULL, verbose, round+1) && uelm)
{ {
// Value node ? // Value node ?
if (uelm->isVirtualStruct ()) if (uelm->isVirtualStruct ())
@ -1134,7 +1134,7 @@ bool CFormElm::getInternalNodeByName (CForm *form, const char *name, const CForm
case TokenString: case TokenString:
{ {
// To int // To int
if (sscanf (token.c_str(), "%d", &arrayIndex)!=1) if (!fromString(token, arrayIndex))
{ {
// Error message // Error message
smprintf (error, 512, "Keyword (%s) is not an array index.", token.c_str()); smprintf (error, 512, "Keyword (%s) is not an array index.", token.c_str());
@ -1406,7 +1406,7 @@ exit:;
bool arrayParent; bool arrayParent;
bool createdParent; bool createdParent;
bool parentVDfnArray; bool parentVDfnArray;
if (getInternalNodeByName (parentPtr, formName.c_str (), &parentDfnParent, indexDfnParent, &nodeDfnParent, &nodeTypeParent, &nodeParent, typeParent, arrayParent, action, createdParent, parentVDfnArray, false, round+1)) if (getInternalNodeByName (parentPtr, formName, &parentDfnParent, indexDfnParent, &nodeDfnParent, &nodeTypeParent, &nodeParent, typeParent, arrayParent, action, createdParent, parentVDfnArray, false, round+1))
{ {
// Node found ? // Node found ?
if (nodeParent) if (nodeParent)
@ -1466,7 +1466,7 @@ exit:;
// Turn around.. // Turn around..
string formName; string formName;
(*node)->getFormName (formName); (*node)->getFormName (formName);
warning (false, formName.c_str (), form->getFilename ().c_str(), "getInternalNodeByName", "Recursive call on the same node (%s), look for loop references or inheritances.", name); warning (false, formName, form->getFilename (), "getInternalNodeByName", "Recursive call on the same node (%s), look for loop references or inheritances.", name.c_str());
return false; return false;
} }
} }
@ -1476,7 +1476,7 @@ exit:;
nlassert (*error); nlassert (*error);
// Get the best form name // Get the best form name
warning (false, currentName.c_str (), form->getFilename ().c_str(), "getInternalNodeByName", "Getting the node (%s) : %s", name, error); warning (false, currentName, form->getFilename (), "getInternalNodeByName", "Getting the node (%s) : %s", name.c_str(), error);
} }
return !errorAppend; return !errorAppend;
@ -1534,7 +1534,7 @@ void CFormElm::unlink (CFormElm * /* child */)
// *************************************************************************** // ***************************************************************************
bool CFormElm::setValueByName (const char *value, const char *name, bool *created) bool CFormElm::setValueByName(const std::string &value, const std::string &name, bool *created)
{ {
// The parent Dfn // The parent Dfn
const CFormDfn *parentDfn; const CFormDfn *parentDfn;
@ -1567,13 +1567,13 @@ bool CFormElm::setValueByName (const char *value, const char *name, bool *create
else else
{ {
// Error message // Error message
warning (false, "setValueByName", "The node (%s) is not an atom element. Can't set the value.", name); warning (false, "setValueByName", "The node (%s) is not an atom element. Can't set the value.", name.c_str());
} }
} }
else else
{ {
// Error message // Error message
warning (false, "setValueByName", "Can't created / set the node (%s).", name); warning (false, "setValueByName", "Can't created / set the node (%s).", name.c_str());
// Created flag // Created flag
if (created) if (created)
@ -1586,70 +1586,70 @@ bool CFormElm::setValueByName (const char *value, const char *name, bool *create
// *************************************************************************** // ***************************************************************************
bool CFormElm::setValueByName (sint8 value, const char *name, bool *created) bool CFormElm::setValueByName (sint8 value, const std::string &name, bool *created)
{ {
return setValueByName (toString (value).c_str (), name, created); return setValueByName (toString (value), name, created);
} }
// *************************************************************************** // ***************************************************************************
bool CFormElm::setValueByName (uint8 value, const char *name, bool *created) bool CFormElm::setValueByName (uint8 value, const std::string &name, bool *created)
{ {
return setValueByName (toString (value).c_str (), name, created); return setValueByName (toString (value), name, created);
} }
// *************************************************************************** // ***************************************************************************
bool CFormElm::setValueByName (sint16 value, const char *name, bool *created) bool CFormElm::setValueByName (sint16 value, const std::string &name, bool *created)
{ {
return setValueByName (toString (value).c_str (), name, created); return setValueByName (toString (value), name, created);
} }
// *************************************************************************** // ***************************************************************************
bool CFormElm::setValueByName (uint16 value, const char *name, bool *created) bool CFormElm::setValueByName (uint16 value, const std::string &name, bool *created)
{ {
return setValueByName (toString (value).c_str (), name, created); return setValueByName (toString (value), name, created);
} }
// *************************************************************************** // ***************************************************************************
bool CFormElm::setValueByName (sint32 value, const char *name, bool *created) bool CFormElm::setValueByName(sint32 value, const std::string &name, bool *created)
{ {
return setValueByName (toString (value).c_str (), name, created); return setValueByName (toString (value), name, created);
} }
// *************************************************************************** // ***************************************************************************
bool CFormElm::setValueByName (uint32 value, const char *name, bool *created) bool CFormElm::setValueByName (uint32 value, const std::string &name, bool *created)
{ {
return setValueByName (toString (value).c_str (), name, created); return setValueByName (toString (value), name, created);
} }
// *************************************************************************** // ***************************************************************************
bool CFormElm::setValueByName (float value, const char *name, bool *created) bool CFormElm::setValueByName (float value, const std::string &name, bool *created)
{ {
return setValueByName (toString (value).c_str (), name, created); return setValueByName (toString (value), name, created);
} }
// *************************************************************************** // ***************************************************************************
bool CFormElm::setValueByName (double value, const char *name, bool *created) bool CFormElm::setValueByName (double value, const std::string &name, bool *created)
{ {
return setValueByName (toString (value).c_str (), name, created); return setValueByName (toString (value), name, created);
} }
// *************************************************************************** // ***************************************************************************
bool CFormElm::setValueByName (bool value, const char *name, bool *created) bool CFormElm::setValueByName (bool value, const std::string &name, bool *created)
{ {
return setValueByName (toString (value).c_str (), name, created); return setValueByName (toString (value), name, created);
} }
// *************************************************************************** // ***************************************************************************
bool CFormElm::setValueByName (NLMISC::CRGBA value, const char *name, bool *created) bool CFormElm::setValueByName (NLMISC::CRGBA value, const std::string &name, bool *created)
{ {
char tmp[512]; char tmp[512];
smprintf (tmp, 512, "%d,%d,%d", value.R, value.G, value.B); smprintf (tmp, 512, "%d,%d,%d", value.R, value.G, value.B);
@ -1658,7 +1658,7 @@ bool CFormElm::setValueByName (NLMISC::CRGBA value, const char *name, bool *crea
// *************************************************************************** // ***************************************************************************
void CFormElm::warning (bool exception, const char *formName, const char *formFileName, const char *function, const char *format, ... ) void CFormElm::warning (bool exception, const std::string &formName, const std::string &formFileName, const std::string &function, const char *format, ... )
{ {
// Make a buffer string // Make a buffer string
va_list args; va_list args;
@ -1668,19 +1668,19 @@ void CFormElm::warning (bool exception, const char *formName, const char *formFi
va_end( args ); va_end( args );
// Set the warning // Set the warning
NLGEORGES::warning (exception, "(CFormElm::%s) on node (%s) in form (%s) : %s", function, formName, formFileName, buffer); NLGEORGES::warning (exception, "(CFormElm::%s) on node (%s) in form (%s) : %s", function.c_str(), formName.c_str(), formFileName.c_str(), buffer);
} }
// *************************************************************************** // ***************************************************************************
void CFormElm::warning (bool exception, const char *function, const char *format, ... ) const void CFormElm::warning (bool exception, const std::string &function, const char *format, ... ) const
{ {
va_list args; va_list args;
va_start( args, format ); va_start( args, format );
string formName; string formName;
getFormName (formName); getFormName (formName);
warning (exception, formName.c_str (), getForm ()->getFilename ().c_str (), function, format, args); warning (exception, formName, getForm ()->getFilename (), function, format, args);
va_end( args ); va_end( args );
} }
@ -1741,7 +1741,7 @@ bool CFormElmStruct::getStructNodeName (uint element, string &result) const
} }
else else
{ {
warning (false, "getStructNodeName", "Index (%d) out of bound (%d).", element, Elements.size() ); warning (false, "getStructNodeName", "Index (%u) out of bound (%u).", element, (uint)Elements.size() );
return false; return false;
} }
} }
@ -1757,7 +1757,7 @@ bool CFormElmStruct::getStructNode (uint element, const UFormElm **result) const
} }
else else
{ {
warning (false, "getStructNode", "Index (%d) out of bound (%d).", element, Elements.size() ); warning (false, "getStructNode", "Index (%u) out of bound (%u).", element, (uint)Elements.size() );
return false; return false;
} }
} }
@ -1780,14 +1780,14 @@ bool CFormElmStruct::getStructNode (uint element, UFormElm **result)
} }
else else
{ {
warning (false, "getStructNode", "Index (%d) out of bound (%d).", element, Elements.size() ); warning (false, "getStructNode", "Index (%u) out of bound (%u).", element, (uint)Elements.size() );
return false; return false;
} }
} }
// *************************************************************************** // ***************************************************************************
xmlNodePtr CFormElmStruct::write (xmlNodePtr root, const CForm *form, const char *structName, bool forceWrite) const xmlNodePtr CFormElmStruct::write (xmlNodePtr root, const CForm *form, const std::string &structName, bool forceWrite) const
{ {
// Is used ? // Is used ?
if (isUsed (form) || forceWrite) if (isUsed (form) || forceWrite)
@ -1796,10 +1796,10 @@ xmlNodePtr CFormElmStruct::write (xmlNodePtr root, const CForm *form, const cha
xmlNodePtr node = xmlNewChild ( root, NULL, (const xmlChar*)"STRUCT", NULL); xmlNodePtr node = xmlNewChild ( root, NULL, (const xmlChar*)"STRUCT", NULL);
// Element name // Element name
if (structName != NULL) if (!structName.empty())
{ {
// Struct name // Struct name
xmlSetProp (node, (const xmlChar*)"Name", (const xmlChar*)structName); xmlSetProp (node, (const xmlChar*)"Name", (const xmlChar*)structName.c_str());
} }
// For each elements of the structure // For each elements of the structure
@ -1808,7 +1808,7 @@ xmlNodePtr CFormElmStruct::write (xmlNodePtr root, const CForm *form, const cha
{ {
// Create a node if it exist // Create a node if it exist
if (Elements[elm].Element) if (Elements[elm].Element)
Elements[elm].Element->write (node, form, Elements[elm].Name.c_str()); Elements[elm].Element->write (node, form, Elements[elm].Name);
} }
// Return the new node // Return the new node
@ -1905,8 +1905,8 @@ void CFormElmStruct::read (xmlNodePtr node, CFormLoader &loader, const CFormDfn
else else
{ {
// Make a warning message // Make a warning message
warning (false, "read", "In block line %p, node (%s) type in DFN have changed.", warning (false, "read", "In block line %u, node (%s) type in DFN have changed.",
child->content, child->name); (uint)child->line, child->name);
} }
} }
else else
@ -1918,8 +1918,8 @@ void CFormElmStruct::read (xmlNodePtr node, CFormLoader &loader, const CFormDfn
} }
// Throw exception // Throw exception
warning (true, "read", "XML Syntax error in block line %p, node (%s) name should be STRUCT, ATOM or ARRAY.", warning (true, "read", "XML Syntax error in block line %u, node (%s) name should be STRUCT, ATOM or ARRAY.",
child->content, child->name); (uint)child->line, child->name);
} }
} }
@ -2101,7 +2101,7 @@ void CFormElmStruct::getFormName (std::string &result, const CFormElm *child) co
// *************************************************************************** // ***************************************************************************
void CFormElmStruct::warning (bool exception, const char *function, const char *format, ... ) const void CFormElmStruct::warning (bool exception, const std::string &function, const char *format, ... ) const
{ {
// Make a buffer string // Make a buffer string
va_list args; va_list args;
@ -2113,7 +2113,7 @@ void CFormElmStruct::warning (bool exception, const char *function, const char *
// Set the warning // Set the warning
string formName; string formName;
getFormName (formName, NULL); getFormName (formName, NULL);
NLGEORGES::warning (exception, "(CFormElmStruct::%s) on node (%s) in form (%s) : %s", function, formName.c_str (), Form->getFilename ().c_str (), buffer); NLGEORGES::warning (exception, "(CFormElmStruct::%s) on node (%s) in form (%s) : %s", function.c_str(), formName.c_str (), Form->getFilename ().c_str (), buffer);
} }
// *************************************************************************** // ***************************************************************************
@ -2142,7 +2142,7 @@ CFormElmVirtualStruct::CFormElmVirtualStruct (CForm *form, CFormElm *parentNode,
// *************************************************************************** // ***************************************************************************
xmlNodePtr CFormElmVirtualStruct::write (xmlNodePtr root, const CForm *form, const char *structName, bool forceWrite) const xmlNodePtr CFormElmVirtualStruct::write (xmlNodePtr root, const CForm *form, const std::string &structName, bool forceWrite) const
{ {
// Is used ? // Is used ?
if (isUsed (form) || forceWrite) if (isUsed (form) || forceWrite)
@ -2154,10 +2154,10 @@ xmlNodePtr CFormElmVirtualStruct::write (xmlNodePtr root, const CForm *form, co
xmlSetProp (node, (const xmlChar*)"DfnName", (const xmlChar*)DfnFilename.c_str()); xmlSetProp (node, (const xmlChar*)"DfnName", (const xmlChar*)DfnFilename.c_str());
// Element name // Element name
if (structName != NULL) if (!structName.empty())
{ {
// Struct name // Struct name
xmlSetProp (node, (const xmlChar*)"Name", (const xmlChar*)structName); xmlSetProp (node, (const xmlChar*)"Name", (const xmlChar*)structName.c_str());
} }
// For each elements of the structure // For each elements of the structure
@ -2166,7 +2166,7 @@ xmlNodePtr CFormElmVirtualStruct::write (xmlNodePtr root, const CForm *form, co
{ {
// Create a node if it exist // Create a node if it exist
if (Elements[elm].Element) if (Elements[elm].Element)
Elements[elm].Element->write (node, form, Elements[elm].Name.c_str()); Elements[elm].Element->write (node, form, Elements[elm].Name);
} }
// Return the new node // Return the new node
@ -2190,7 +2190,7 @@ void CFormElmVirtualStruct::read (xmlNodePtr node, CFormLoader &loader, CForm *f
xmlFree ((void*)filename); xmlFree ((void*)filename);
// Load the dfn // Load the dfn
FormDfn = loader.loadFormDfn (DfnFilename.c_str (), false); FormDfn = loader.loadFormDfn (DfnFilename, false);
if (!FormDfn) if (!FormDfn)
{ {
// Throw exception // Throw exception
@ -2200,8 +2200,8 @@ void CFormElmVirtualStruct::read (xmlNodePtr node, CFormLoader &loader, CForm *f
else else
{ {
// Throw exception // Throw exception
warning (true, "read", "XML Syntax error in virtual struct in block line %p, should have a DfnName property.", warning (true, "read", "XML Syntax error in virtual struct in block line %u, should have a DfnName property.",
node->content); (uint)node->line);
} }
// Read the parent // Read the parent
@ -2232,7 +2232,7 @@ bool CFormElmVirtualStruct::isUsed (const CForm * /* form */) const
// *************************************************************************** // ***************************************************************************
void CFormElmVirtualStruct::warning (bool exception, const char *function, const char *format, ... ) const void CFormElmVirtualStruct::warning (bool exception, const std::string &function, const char *format, ... ) const
{ {
// Make a buffer string // Make a buffer string
va_list args; va_list args;
@ -2244,7 +2244,7 @@ void CFormElmVirtualStruct::warning (bool exception, const char *function, const
// Set the warning // Set the warning
string formName; string formName;
getFormName (formName, NULL); getFormName (formName, NULL);
NLGEORGES::warning (exception, "(CFormElmVirtualStruct::%s) on node (%s) in form (%s) : %s", function, formName.c_str (), Form->getFilename ().c_str (), buffer); NLGEORGES::warning (exception, "(CFormElmVirtualStruct::%s) on node (%s) in form (%s) : %s", function.c_str(), formName.c_str (), Form->getFilename ().c_str (), buffer);
} }
// *************************************************************************** // ***************************************************************************
@ -2304,7 +2304,7 @@ bool CFormElmArray::getArrayNode (const UFormElm **result, uint arrayIndex) cons
} }
else else
{ {
warning (false, "getArrayNode", "Index (%d) out of bound (%d).", arrayIndex, Elements.size() ); warning (false, "getArrayNode", "Index (%u) out of bound (%u).", arrayIndex, (uint)Elements.size() );
return false; return false;
} }
} }
@ -2323,7 +2323,7 @@ bool CFormElmArray::getArrayNodeName (std::string &result, uint arrayIndex) cons
} }
else else
{ {
warning (false, "getArrayNodeName", "Index (%d) out of bound (%d).", arrayIndex, Elements.size() ); warning (false, "getArrayNodeName", "Index (%u) out of bound (%u).", arrayIndex, (uint)Elements.size() );
return false; return false;
} }
} }
@ -2339,7 +2339,7 @@ bool CFormElmArray::getArrayNode (UFormElm **result, uint arrayIndex)
} }
else else
{ {
warning (false, "getArrayNode", "Index (%d) out of bound (%d).", arrayIndex, Elements.size() ); warning (false, "getArrayNode", "Index (%u) out of bound (%u).", arrayIndex, (uint)Elements.size() );
return false; return false;
} }
} }
@ -2351,11 +2351,11 @@ bool CFormElmArray::getArrayValue (std::string &result, uint arrayIndex, TEval e
{ {
if (arrayIndex >= Elements.size()) if (arrayIndex >= Elements.size())
{ {
warning (false, "getArrayValue", "Access out of bound, trying to access array index %u, array size is %u.", arrayIndex, Elements.size()); warning (false, "getArrayValue", "Access out of bound, trying to access array index %u, array size is %u.", arrayIndex, (uint)Elements.size());
} }
else if (Type) else if (Type)
{ {
return (Type->getValue (result, Form, safe_cast<const CFormElmAtom*> (Elements[arrayIndex].Element), *ParentDfn, ParentIndex, evaluate, (uint32*)where, NLGEORGES_FIRST_ROUND, NULL)); return (Type->getValue (result, Form, safe_cast<const CFormElmAtom*> (Elements[arrayIndex].Element), *ParentDfn, ParentIndex, evaluate, (uint32*)where, NLGEORGES_FIRST_ROUND, ""));
} }
else else
{ {
@ -2372,9 +2372,9 @@ bool CFormElmArray::getArrayValue (sint8 &result, uint arrayIndex, TEval evaluat
if (Type) if (Type)
{ {
string str; string str;
if (Type->getValue (str, Form, safe_cast<const CFormElmAtom*> (Elements[arrayIndex].Element), *ParentDfn, ParentIndex, evaluate, (uint32*)where, NLGEORGES_FIRST_ROUND, NULL)) if (Type->getValue (str, Form, safe_cast<const CFormElmAtom*> (Elements[arrayIndex].Element), *ParentDfn, ParentIndex, evaluate, (uint32*)where, NLGEORGES_FIRST_ROUND, ""))
{ {
return convertValue (result, str.c_str ()); return convertValue (result, str);
} }
} }
else else
@ -2392,9 +2392,9 @@ bool CFormElmArray::getArrayValue (uint8 &result, uint arrayIndex, TEval evaluat
if (Type) if (Type)
{ {
string str; string str;
if (Type->getValue (str, Form, safe_cast<const CFormElmAtom*> (Elements[arrayIndex].Element), *ParentDfn, ParentIndex, evaluate, (uint32*)where, NLGEORGES_FIRST_ROUND, NULL)) if (Type->getValue (str, Form, safe_cast<const CFormElmAtom*> (Elements[arrayIndex].Element), *ParentDfn, ParentIndex, evaluate, (uint32*)where, NLGEORGES_FIRST_ROUND, ""))
{ {
return convertValue (result, str.c_str ()); return convertValue (result, str);
} }
} }
else else
@ -2412,9 +2412,9 @@ bool CFormElmArray::getArrayValue (sint16 &result, uint arrayIndex, TEval evalua
if (Type) if (Type)
{ {
string str; string str;
if (Type->getValue (str, Form, safe_cast<const CFormElmAtom*> (Elements[arrayIndex].Element), *ParentDfn, ParentIndex, evaluate, (uint32*)where, NLGEORGES_FIRST_ROUND, NULL)) if (Type->getValue (str, Form, safe_cast<const CFormElmAtom*> (Elements[arrayIndex].Element), *ParentDfn, ParentIndex, evaluate, (uint32*)where, NLGEORGES_FIRST_ROUND, ""))
{ {
return convertValue (result, str.c_str ()); return convertValue (result, str);
} }
} }
else else
@ -2432,9 +2432,9 @@ bool CFormElmArray::getArrayValue (uint16 &result, uint arrayIndex, TEval evalua
if (Type) if (Type)
{ {
string str; string str;
if (Type->getValue (str, Form, safe_cast<const CFormElmAtom*> (Elements[arrayIndex].Element), *ParentDfn, ParentIndex, evaluate, (uint32*)where, NLGEORGES_FIRST_ROUND, NULL)) if (Type->getValue (str, Form, safe_cast<const CFormElmAtom*> (Elements[arrayIndex].Element), *ParentDfn, ParentIndex, evaluate, (uint32*)where, NLGEORGES_FIRST_ROUND, ""))
{ {
return convertValue (result, str.c_str ()); return convertValue (result, str);
} }
} }
else else
@ -2452,9 +2452,9 @@ bool CFormElmArray::getArrayValue (sint32 &result, uint arrayIndex, TEval evalua
if (Type) if (Type)
{ {
string str; string str;
if (Type->getValue (str, Form, safe_cast<const CFormElmAtom*> (Elements[arrayIndex].Element), *ParentDfn, ParentIndex, evaluate, (uint32*)where, NLGEORGES_FIRST_ROUND, NULL)) if (Type->getValue (str, Form, safe_cast<const CFormElmAtom*> (Elements[arrayIndex].Element), *ParentDfn, ParentIndex, evaluate, (uint32*)where, NLGEORGES_FIRST_ROUND, ""))
{ {
return convertValue (result, str.c_str ()); return convertValue (result, str);
} }
} }
else else
@ -2472,9 +2472,9 @@ bool CFormElmArray::getArrayValue (uint32 &result, uint arrayIndex, TEval evalua
if (Type) if (Type)
{ {
string str; string str;
if (Type->getValue (str, Form, safe_cast<const CFormElmAtom*> (Elements[arrayIndex].Element), *ParentDfn, ParentIndex, evaluate, (uint32*)where, NLGEORGES_FIRST_ROUND, NULL)) if (Type->getValue (str, Form, safe_cast<const CFormElmAtom*> (Elements[arrayIndex].Element), *ParentDfn, ParentIndex, evaluate, (uint32*)where, NLGEORGES_FIRST_ROUND, ""))
{ {
return convertValue (result, str.c_str ()); return convertValue (result, str);
} }
} }
else else
@ -2492,9 +2492,9 @@ bool CFormElmArray::getArrayValue (float &result, uint arrayIndex, TEval evaluat
if (Type) if (Type)
{ {
string str; string str;
if (Type->getValue (str, Form, safe_cast<const CFormElmAtom*> (Elements[arrayIndex].Element), *ParentDfn, ParentIndex, evaluate, (uint32*)where, NLGEORGES_FIRST_ROUND, NULL)) if (Type->getValue (str, Form, safe_cast<const CFormElmAtom*> (Elements[arrayIndex].Element), *ParentDfn, ParentIndex, evaluate, (uint32*)where, NLGEORGES_FIRST_ROUND, ""))
{ {
return convertValue (result, str.c_str ()); return convertValue (result, str);
} }
} }
else else
@ -2512,9 +2512,9 @@ bool CFormElmArray::getArrayValue (double &result, uint arrayIndex, TEval evalua
if (Type) if (Type)
{ {
string str; string str;
if (Type->getValue (str, Form, safe_cast<const CFormElmAtom*> (Elements[arrayIndex].Element), *ParentDfn, ParentIndex, evaluate, (uint32*)where, NLGEORGES_FIRST_ROUND, NULL)) if (Type->getValue (str, Form, safe_cast<const CFormElmAtom*> (Elements[arrayIndex].Element), *ParentDfn, ParentIndex, evaluate, (uint32*)where, NLGEORGES_FIRST_ROUND, ""))
{ {
return convertValue (result, str.c_str ()); return convertValue (result, str);
} }
} }
else else
@ -2532,9 +2532,9 @@ bool CFormElmArray::getArrayValue (bool &result, uint arrayIndex, TEval evaluate
if (Type) if (Type)
{ {
string str; string str;
if (Type->getValue (str, Form, safe_cast<const CFormElmAtom*> (Elements[arrayIndex].Element), *ParentDfn, ParentIndex, evaluate, (uint32*)where, NLGEORGES_FIRST_ROUND, NULL)) if (Type->getValue (str, Form, safe_cast<const CFormElmAtom*> (Elements[arrayIndex].Element), *ParentDfn, ParentIndex, evaluate, (uint32*)where, NLGEORGES_FIRST_ROUND, ""))
{ {
return convertValue (result, str.c_str ()); return convertValue (result, str);
} }
} }
else else
@ -2552,9 +2552,9 @@ bool CFormElmArray::getArrayValue (NLMISC::CRGBA &result, uint arrayIndex, TEval
if (Type) if (Type)
{ {
string str; string str;
if (Type->getValue (str, Form, safe_cast<const CFormElmAtom*> (Elements[arrayIndex].Element), *ParentDfn, ParentIndex, evaluate, (uint32*)where, NLGEORGES_FIRST_ROUND, NULL)) if (Type->getValue (str, Form, safe_cast<const CFormElmAtom*> (Elements[arrayIndex].Element), *ParentDfn, ParentIndex, evaluate, (uint32*)where, NLGEORGES_FIRST_ROUND, ""))
{ {
return convertValue (result, str.c_str ()); return convertValue (result, str);
} }
} }
else else
@ -2567,7 +2567,7 @@ bool CFormElmArray::getArrayValue (NLMISC::CRGBA &result, uint arrayIndex, TEval
// *************************************************************************** // ***************************************************************************
xmlNodePtr CFormElmArray::write (xmlNodePtr root, const CForm *form, const char *structName, bool forceWrite) const xmlNodePtr CFormElmArray::write (xmlNodePtr root, const CForm *form, const std::string &structName, bool forceWrite) const
{ {
// Arrau is used ? // Arrau is used ?
if (isUsed (form) || forceWrite) if (isUsed (form) || forceWrite)
@ -2576,10 +2576,10 @@ xmlNodePtr CFormElmArray::write (xmlNodePtr root, const CForm *form, const char
xmlNodePtr node = xmlNewChild ( root, NULL, (const xmlChar*)"ARRAY", NULL); xmlNodePtr node = xmlNewChild ( root, NULL, (const xmlChar*)"ARRAY", NULL);
// Element name // Element name
if (structName != NULL) if (!structName.empty())
{ {
// Struct name // Struct name
xmlSetProp (node, (const xmlChar*)"Name", (const xmlChar*)structName); xmlSetProp (node, (const xmlChar*)"Name", (const xmlChar*)structName.c_str());
} }
// For each elements of the structure // For each elements of the structure
@ -2588,7 +2588,7 @@ xmlNodePtr CFormElmArray::write (xmlNodePtr root, const CForm *form, const char
{ {
// Create a node // Create a node
if (Elements[elm].Element) if (Elements[elm].Element)
Elements[elm].Element->write (node, form, Elements[elm].Name.empty ()?NULL:Elements[elm].Name.c_str (), true); Elements[elm].Element->write (node, form, Elements[elm].Name, true);
} }
// Return the new node // Return the new node
@ -2760,7 +2760,7 @@ void CFormElmArray::getFormName (std::string &result, const CFormElm *child) con
// *************************************************************************** // ***************************************************************************
void CFormElmArray::warning (bool exception, const char *function, const char *format, ... ) const void CFormElmArray::warning (bool exception, const std::string &function, const char *format, ... ) const
{ {
// Make a buffer string // Make a buffer string
va_list args; va_list args;
@ -2772,7 +2772,7 @@ void CFormElmArray::warning (bool exception, const char *function, const char *f
// Set the warning // Set the warning
string formName; string formName;
getFormName (formName, NULL); getFormName (formName, NULL);
NLGEORGES::warning (exception, "(CFormElmArray::%s) on node (%s) in form (%s) : %s", function, formName.c_str (), Form->getFilename ().c_str (), buffer); NLGEORGES::warning (exception, "(CFormElmArray::%s) on node (%s) in form (%s) : %s", function.c_str(), formName.c_str (), Form->getFilename ().c_str (), buffer);
} }
// *************************************************************************** // ***************************************************************************
@ -2979,7 +2979,7 @@ bool CFormElmAtom::getValue (NLMISC::CRGBA &result, TEval evaluate) const
// *************************************************************************** // ***************************************************************************
xmlNodePtr CFormElmAtom::write (xmlNodePtr root, const CForm *form, const char *structName, bool forceWrite) const xmlNodePtr CFormElmAtom::write (xmlNodePtr root, const CForm *form, const std::string &structName, bool forceWrite) const
{ {
// Atom is used ? // Atom is used ?
if (isUsed (form) || forceWrite) if (isUsed (form) || forceWrite)
@ -2988,16 +2988,16 @@ xmlNodePtr CFormElmAtom::write (xmlNodePtr root, const CForm *form, const char
xmlNodePtr node = xmlNewChild ( root, NULL, (const xmlChar*)"ATOM", NULL); xmlNodePtr node = xmlNewChild ( root, NULL, (const xmlChar*)"ATOM", NULL);
// Element name // Element name
if (structName != NULL) if (!structName.empty())
{ {
// Struct name // Struct name
xmlSetProp (node, (const xmlChar*)"Name", (const xmlChar*)structName); xmlSetProp (node, (const xmlChar*)"Name", (const xmlChar*)structName.c_str());
} }
// The value // The value
if (!Value.empty ()) if (!Value.empty ())
{ {
if (COXml::isStringValidForProperties (Value.c_str ())) if (COXml::isStringValidForProperties (Value))
xmlSetProp (node, (const xmlChar*)"Value", (const xmlChar*)Value.c_str()); xmlSetProp (node, (const xmlChar*)"Value", (const xmlChar*)Value.c_str());
else else
{ {
@ -3049,7 +3049,7 @@ void CFormElmAtom::read (xmlNodePtr node, CFormLoader &/* loader */, const CType
// *************************************************************************** // ***************************************************************************
void CFormElmAtom::setValue (const char *value) void CFormElmAtom::setValue (const std::string &value)
{ {
Value = value; Value = value;
} }
@ -3077,7 +3077,7 @@ void CFormElmAtom::getFormName (std::string &result, const CFormElm *child) cons
// *************************************************************************** // ***************************************************************************
void CFormElmAtom::warning (bool exception, const char *function, const char *format, ... ) const void CFormElmAtom::warning (bool exception, const std::string &function, const char *format, ... ) const
{ {
// Make a buffer string // Make a buffer string
va_list args; va_list args;
@ -3089,7 +3089,7 @@ void CFormElmAtom::warning (bool exception, const char *function, const char *fo
// Set the warning // Set the warning
string formName; string formName;
getFormName (formName, NULL); getFormName (formName, NULL);
NLGEORGES::warning (exception, "(CFormElmAtom::%s) on node (%s) in form (%s) : %s", function, formName.c_str (), Form->getFilename ().c_str (), buffer); NLGEORGES::warning (exception, "(CFormElmAtom::%s) on node (%s) in form (%s) : %s", function.c_str(), formName.c_str (), Form->getFilename ().c_str (), buffer);
} }
// *************************************************************************** // ***************************************************************************

22
code/nel/src/georges/form_loader.cpp
View file

@ -60,10 +60,10 @@ CFormLoader::~CFormLoader()
{ {
} }
CType *CFormLoader::loadType (const char *filename) CType *CFormLoader::loadType (const std::string &filename)
{ {
// Lower string filename // Lower string filename
string lowerStr = toLower((string)filename); string lowerStr = toLower(filename);
lowerStr = CFile::getFilename (lowerStr); lowerStr = CFile::getFilename (lowerStr);
// Already in the map ? // Already in the map ?
@ -98,7 +98,7 @@ CType *CFormLoader::loadType (const char *filename)
else else
{ {
// Output error // Output error
warning (false, "loadType", "Can't open the form file (%s).", filename); warning (false, "loadType", "Can't open the form file (%s).", filename.c_str());
// Delete the type // Delete the type
delete type; delete type;
@ -108,7 +108,7 @@ CType *CFormLoader::loadType (const char *filename)
catch (const Exception &e) catch (const Exception &e)
{ {
// Output error // Output error
warning (false, "loadType", "Error while loading the form (%s): %s", filename, e.what()); warning (false, "loadType", "Error while loading the form (%s): %s", filename.c_str(), e.what());
// Delete the type // Delete the type
delete type; delete type;
@ -130,10 +130,10 @@ CType *CFormLoader::loadType (const char *filename)
// *************************************************************************** // ***************************************************************************
CFormDfn *CFormLoader::loadFormDfn (const char *filename, bool forceLoad) CFormDfn *CFormLoader::loadFormDfn (const std::string &filename, bool forceLoad)
{ {
// Lower string filename // Lower string filename
string lowerStr = toLower((string)filename); string lowerStr = toLower(filename);
lowerStr = CFile::getFilename (lowerStr); lowerStr = CFile::getFilename (lowerStr);
// Already in the map ? // Already in the map ?
@ -196,7 +196,7 @@ CFormDfn *CFormLoader::loadFormDfn (const char *filename, bool forceLoad)
// *************************************************************************** // ***************************************************************************
UForm *CFormLoader::loadForm (const char *filename) UForm *CFormLoader::loadForm (const std::string &filename)
{ {
// Lower string filename // Lower string filename
string lowerStr = toLower((string)filename); string lowerStr = toLower((string)filename);
@ -237,7 +237,7 @@ UForm *CFormLoader::loadForm (const char *filename)
name += ".dfn"; name += ".dfn";
// Load the dfn // Load the dfn
CFormDfn *dfn = loadFormDfn (name.c_str (), false); CFormDfn *dfn = loadFormDfn (name, false);
if (dfn) if (dfn)
{ {
// Open the file // Open the file
@ -293,21 +293,21 @@ UForm *CFormLoader::loadForm (const char *filename)
// *************************************************************************** // ***************************************************************************
UFormDfn *CFormLoader::loadFormDfn (const char *filename) UFormDfn *CFormLoader::loadFormDfn (const std::string &filename)
{ {
return loadFormDfn (filename, false); return loadFormDfn (filename, false);
} }
// *************************************************************************** // ***************************************************************************
UType *CFormLoader::loadFormType (const char *filename) UType *CFormLoader::loadFormType (const std::string &filename)
{ {
return loadType (filename); return loadType (filename);
} }
// *************************************************************************** // ***************************************************************************
void CFormLoader::warning (bool exception, const char *function, const char *format, ... ) const void CFormLoader::warning (bool exception, const std::string &function, const char *format, ... ) const
{ {
// Make a buffer string // Make a buffer string
va_list args; va_list args;

8
code/nel/src/georges/header.cpp
View file

@ -76,7 +76,7 @@ void CFileHeader::write (xmlNodePtr node) const
// *************************************************************************** // ***************************************************************************
void CFileHeader::addLog (const char *log) void CFileHeader::addLog (const std::string &log)
{ {
time_t t; time_t t;
time (&t); time (&t);
@ -92,7 +92,7 @@ void CFileHeader::addLog (const char *log)
// *************************************************************************** // ***************************************************************************
void CFileHeader::setComments (const char *comments) void CFileHeader::setComments (const std::string &comments)
{ {
Comments = comments; Comments = comments;
} }
@ -215,7 +215,7 @@ const char *CFileHeader::getStateString (TState state)
// *************************************************************************** // ***************************************************************************
void CFileHeader::warning (bool exception, const char *function, const char *format, ... ) const void CFileHeader::warning (bool exception, const std::string &function, const char *format, ... ) const
{ {
// Make a buffer string // Make a buffer string
va_list args; va_list args;
@ -225,7 +225,7 @@ void CFileHeader::warning (bool exception, const char *function, const char *for
va_end( args ); va_end( args );
// Set the warning // Set the warning
NLGEORGES::warning (exception, "(CFileHeader::%s) : %s", function, buffer); NLGEORGES::warning (exception, "(CFileHeader::%s) : %s", function.c_str(), buffer);
} }
// *************************************************************************** // ***************************************************************************

15
code/nel/src/georges/type.cpp
View file

@ -326,6 +326,7 @@ public:
Type = type; Type = type;
Form = form; Form = form;
} }
virtual CEvalNumExpr::TReturnState evalValue (const char *value, double &result, uint32 round) virtual CEvalNumExpr::TReturnState evalValue (const char *value, double &result, uint32 round)
{ {
// If a form is available // If a form is available
@ -412,7 +413,7 @@ public:
result = res.empty ()?0:1; result = res.empty ()?0:1;
return CEvalNumExpr::NoError; return CEvalNumExpr::NoError;
} }
else if (((const CFormElm&)Form->getRootNode ()).convertValue (result, res.c_str ())) else if (((const CFormElm&)Form->getRootNode ()).convertValue (result, res))
{ {
return CEvalNumExpr::NoError; return CEvalNumExpr::NoError;
} }
@ -535,7 +536,7 @@ void buildError (char *msg, uint offset)
// *************************************************************************** // ***************************************************************************
bool CType::getValue (string &result, const CForm *form, const CFormElmAtom *node, const CFormDfn &parentDfn, uint parentIndex, UFormElm::TEval evaluate, uint32 *where, uint32 round, const char *formName) const bool CType::getValue (string &result, const CForm *form, const CFormElmAtom *node, const CFormDfn &parentDfn, uint parentIndex, UFormElm::TEval evaluate, uint32 *where, uint32 round, const std::string &formName) const
{ {
if (round > NLGEORGES_MAX_RECURSION) if (round > NLGEORGES_MAX_RECURSION)
{ {
@ -721,7 +722,7 @@ bool CType::getValue (string &result, const CForm *form, const CFormElmAtom *nod
UFormDfn::TEntryType type; UFormDfn::TEntryType type;
// Search for the node // Search for the node
if (((const CFormElm&)form->getRootNode ()).getNodeByName (valueName.c_str (), &parentDfn, parentIndex, &nodeDfn, &nodeType, &node, type, array, parentVDfnArray, false, round+1)) if (((const CFormElm&)form->getRootNode ()).getNodeByName (valueName, &parentDfn, parentIndex, &nodeDfn, &nodeType, &node, type, array, parentVDfnArray, false, round+1))
{ {
// End, return the current index // End, return the current index
if (type == UFormDfn::EntryType) if (type == UFormDfn::EntryType)
@ -809,7 +810,7 @@ bool CType::uiCompatible (TType type, TUI ui)
// *************************************************************************** // ***************************************************************************
void CType::warning (bool exception, const char *formName, const char *formFilename, const char *function, const char *format, ... ) const void CType::warning (bool exception, const std::string &formName, const std::string &formFilename, const std::string &function, const char *format, ... ) const
{ {
// Make a buffer string // Make a buffer string
va_list args; va_list args;
@ -819,12 +820,12 @@ void CType::warning (bool exception, const char *formName, const char *formFilen
va_end( args ); va_end( args );
// Set the warning // Set the warning
NLGEORGES::warning (exception, "(CType::%s) In form (%s) in node (%s) : %s", function, formFilename, formName, buffer); NLGEORGES::warning (exception, "(CType::%s) In form (%s) in node (%s) : %s", function.c_str(), formFilename.c_str(), formName.c_str(), buffer);
} }
// *************************************************************************** // ***************************************************************************
void CType::warning2 (bool exception, const char *function, const char *format, ... ) const void CType::warning2 (bool exception, const std::string &function, const char *format, ... ) const
{ {
// Make a buffer string // Make a buffer string
va_list args; va_list args;
@ -834,7 +835,7 @@ void CType::warning2 (bool exception, const char *function, const char *format,
va_end( args ); va_end( args );
// Set the warning // Set the warning
NLGEORGES::warning (exception, "(CType::%s) : %s", function, buffer); NLGEORGES::warning (exception, "(CType::%s) : %s", function.c_str(), buffer);
} }
// *************************************************************************** // ***************************************************************************

12
code/nel/tools/georges/georges2csv/georges2csv.cpp
View file

@ -405,7 +405,7 @@ void scanFiles(const CSString &filespec)
} }
else else
{ {
if (form->getRootNode ().getValueByName(valueString,fields[i]._name.c_str(),fields[i]._evaluated,&where)) //fieldForm->getValue(valueString,fields[i]._evaluated)) if (form->getRootNode ().getValueByName(valueString,fields[i]._name, fields[i]._evaluated, &where)) //fieldForm->getValue(valueString,fields[i]._evaluated))
;//addQuotesRoundString (valueString); ;//addQuotesRoundString (valueString);
else else
setErrorString (valueString, fields[i]._evaluated, where); setErrorString (valueString, fields[i]._evaluated, where);
@ -422,7 +422,7 @@ void scanFiles(const CSString &filespec)
// UFormElm::TWhereIsValue where; // UFormElm::TWhereIsValue where;
// //
// bool result=form->getRootNode ().getValueByName(s,fields[i]._name.c_str(),fields[i]._evaluated,&where); // bool result=form->getRootNode ().getValueByName(s,fields[i]._name, fields[i]._evaluated,&where);
// if (!result) // if (!result)
// { // {
// if (fields[i]._evaluated) // if (fields[i]._evaluated)
@ -1122,8 +1122,8 @@ void convertCsvFile( const string &file, bool generate, const string& sheetType
} }
//nldebug( "%s: %s '%s'", args[0].c_str(), var.c_str(), memberVal.c_str() ); //nldebug( "%s: %s '%s'", args[0].c_str(), var.c_str(), memberVal.c_str() );
// need to put the value at the correct index. // need to put the value at the correct index.
const std::string fieldName=NLMISC::toString("%s[%d]", var.c_str(), currentMemberIndex).c_str(); const std::string fieldName=NLMISC::toString("%s[%u]", var.c_str(), currentMemberIndex).c_str();
const_cast<UFormElm&>(rootForm).setValueByName(memberVal.c_str(), fieldName.c_str()); const_cast<UFormElm&>(rootForm).setValueByName(memberVal, fieldName);
isModified=true; isModified=true;
displayed = true; displayed = true;
} }
@ -1132,7 +1132,7 @@ void convertCsvFile( const string &file, bool generate, const string& sheetType
if (!isNewSheet) if (!isNewSheet)
{ {
string test; string test;
if ( rootForm.getValueByName(test,var.c_str()) if ( rootForm.getValueByName(test, var)
&& test==memberVal ) && test==memberVal )
{ {
continue; continue;
@ -1140,7 +1140,7 @@ void convertCsvFile( const string &file, bool generate, const string& sheetType
} }
//nldebug( "%s: %s '%s'", args[0].c_str(), var.c_str(), memberVal.c_str() ); //nldebug( "%s: %s '%s'", args[0].c_str(), var.c_str(), memberVal.c_str() );
const_cast<UFormElm&>(rootForm).setValueByName(memberVal.c_str(), var.c_str()); const_cast<UFormElm&>(rootForm).setValueByName(memberVal, var);
isModified=true; isModified=true;
displayed = true; displayed = true;
} }

2
code/ryzom/client/src/browse_faq.cpp
View file

@ -60,6 +60,6 @@ void browseFAQ(NLMISC::CConfigFile &cf)
} }
else else
{ {
openURL(url.c_str()); openURL(url);
} }
} }

2
code/ryzom/client/src/client_sheets/item_fx_sheet.cpp
View file

@ -54,7 +54,7 @@ void CItemFXSheet::build(const NLGEORGES::UFormElm &item, const std::string &pre
item.getValueByName(AttackFXRot.z, (prefix + "AttackFXRot.Z").c_str()); item.getValueByName(AttackFXRot.z, (prefix + "AttackFXRot.Z").c_str());
item.getValueByName(ImpactFXDelay, (prefix + "ImpactFXDelay").c_str()); item.getValueByName(ImpactFXDelay, (prefix + "ImpactFXDelay").c_str());
const NLGEORGES::UFormElm *array = NULL; const NLGEORGES::UFormElm *array = NULL;
if (item.getNodeByName(&array, (prefix + "StaticFXs").c_str()) && array) if (item.getNodeByName(&array, prefix + "StaticFXs") && array)
{ {
uint count; uint count;
nlverify(array->getArraySize(count)); nlverify(array->getArraySize(count));

2
code/ryzom/client/src/client_sheets/outpost_building_sheet.cpp
View file

@ -75,7 +75,7 @@ void COutpostBuildingSheet::build(const NLGEORGES::UFormElm &root)
// Get Mps sheets // Get Mps sheets
const UFormElm *pMp; const UFormElm *pMp;
uint32 i = 0; uint32 i = 0;
while (pDriller->getNodeByName(&pMp, ("mp" + NLMISC::toString(i)).c_str()) && pMp) while (pDriller->getNodeByName(&pMp, "mp" + NLMISC::toString(i)) && pMp)
{ {
string sTmp; string sTmp;
pMp->getValueByName(sTmp, "name"); pMp->getValueByName(sTmp, "name");

2
code/ryzom/client/src/client_sheets/race_stats_sheet.cpp
View file

@ -226,7 +226,7 @@ void CRaceStatsSheet::buildGroundFXs(const NLGEORGES::UFormElm &item, const std:
{ {
// ground fxs // ground fxs
const NLGEORGES::UFormElm *elm; const NLGEORGES::UFormElm *elm;
if(item.getNodeByName(&elm, name.c_str()) && elm) if(item.getNodeByName(&elm, name) && elm)
{ {
// Check array. // Check array.
if(elm->isArray()) if(elm->isArray())

2
code/ryzom/client/src/client_sheets/sky_object_sheet.cpp
View file

@ -48,7 +48,7 @@ void CSkyObjectSheet::CColorGradientInfoSheet::build(const NLGEORGES::UFormElm &
{ {
item.getValueByName(TargetTextureStage, (prefix + "TargetTextureStage").c_str()); item.getValueByName(TargetTextureStage, (prefix + "TargetTextureStage").c_str());
const NLGEORGES::UFormElm *elm = NULL; const NLGEORGES::UFormElm *elm = NULL;
if(item.getNodeByName (&elm, (prefix + "WeatherToGradient").c_str()) && elm) if(item.getNodeByName (&elm, prefix + "WeatherToGradient") && elm)
{ {
uint numBitmaps; uint numBitmaps;
nlverify (elm->getArraySize (numBitmaps)); nlverify (elm->getArraySize (numBitmaps));

2
code/ryzom/client/src/commands.cpp
View file

@ -3910,7 +3910,7 @@ NLMISC_COMMAND (url, "launch a browser to the specified url", "<url>")
if (args.size () != 1) if (args.size () != 1)
return false; return false;
return openURL(args[0].c_str()); return openURL(args[0]);
} }
NLMISC_COMMAND( reconnect, "Reconnect to the same shard (self Far TP)", "") NLMISC_COMMAND( reconnect, "Reconnect to the same shard (self Far TP)", "")

2
code/ryzom/client/src/login.cpp
View file

@ -1911,7 +1911,7 @@ class CAHOpenURL : public IActionHandler
else else
url += "?"; url += "?";
url += "language=" + ClientCfg.LanguageCode; url += "language=" + ClientCfg.LanguageCode;
openURL(url.c_str()); openURL(url);
nlinfo("openURL %s", url.c_str()); nlinfo("openURL %s", url.c_str());
} }

2
code/ryzom/common/src/game_share/light_cycle.cpp
View file

@ -62,7 +62,7 @@ void CLightCycle::build(const NLGEORGES::UFormElm &item)
for(uint k = 0; k < EGSPD::CSeason::Invalid; ++k) for(uint k = 0; k < EGSPD::CSeason::Invalid; ++k)
{ {
const NLGEORGES::UFormElm *seasonsItem; const NLGEORGES::UFormElm *seasonsItem;
if (item.getNodeByName(&seasonsItem, EGSPD::CSeason::toString( (EGSPD::CSeason::TSeason) k).c_str()) && seasonsItem) if (item.getNodeByName(&seasonsItem, EGSPD::CSeason::toString( (EGSPD::CSeason::TSeason) k)) && seasonsItem)
{ {
SeasonLightCycle[k].build(*seasonsItem); SeasonLightCycle[k].build(*seasonsItem);
} }

2
code/ryzom/common/src/game_share/time_weather_season/static_light_cycle.cpp
View file

@ -46,7 +46,7 @@ void CStaticLightCycle::readGeorges( const NLMISC::CSmartPtr<NLGEORGES::UForm> &
for( uint i = 0; i < NbSeasons; ++i ) for( uint i = 0; i < NbSeasons; ++i )
{ {
UFormElm* SeasonElt = NULL; UFormElm* SeasonElt = NULL;
if( ! ( root.getNodeByName( &SeasonElt, season[ i ].c_str() ) && SeasonElt ) ) if( ! ( root.getNodeByName( &SeasonElt, season[ i ] ) && SeasonElt ) )
{ {
nlwarning("<CStaticLightCycle readGeorges> can get node %s in sheet %s", season[ i ].c_str(), sheetId.toString().c_str() ); nlwarning("<CStaticLightCycle readGeorges> can get node %s in sheet %s", season[ i ].c_str(), sheetId.toString().c_str() );
} }

2
code/ryzom/server/src/ai_service/sheets.cpp
View file

@ -258,7 +258,7 @@ void AISHEETS::CCreature::calcFightAndVisualValues(std::string* left, std::strin
void AISHEETS::CCreature::parseFightConfig(NLGEORGES::UForm const* form, std::string const& fightConfigString, uint32 actionListIndex, NLMISC::CDbgPtr<CActionList>& fightConfig) void AISHEETS::CCreature::parseFightConfig(NLGEORGES::UForm const* form, std::string const& fightConfigString, uint32 actionListIndex, NLMISC::CDbgPtr<CActionList>& fightConfig)
{ {
NLGEORGES::UFormElm const* actionListNode = NULL; NLGEORGES::UFormElm const* actionListNode = NULL;
const_cast<NLGEORGES::UFormElm&>(form->getRootNode()).getNodeByName(&actionListNode, fightConfigString.c_str()); const_cast<NLGEORGES::UFormElm&>(form->getRootNode()).getNodeByName(&actionListNode, fightConfigString);
if (actionListNode) if (actionListNode)
{ {

4
code/ryzom/server/src/entities_game_service/egs_sheets/egs_static_brick.cpp
View file

@ -1754,10 +1754,10 @@ void CStaticBrick::loadFaber( const UFormElm &root, const CSheetId &sheetId )
for (uint i = 1 ; i <= 5 ; ++i) for (uint i = 1 ; i <= 5 ; ++i)
{ {
propName = "faber.Create.MP "+toString(i); propName = "faber.Create.MP "+toString(i);
if (root.getValueByName( value, propName.c_str() ) && !value.empty() ) if (root.getValueByName( value, propName ) && !value.empty() )
{ {
propName = "faber.Create.Quantity "+toString(i); propName = "faber.Create.Quantity "+toString(i);
if ( root.getValueByName( quantity, propName.c_str() ) && quantity > 0) if ( root.getValueByName( quantity, propName ) && quantity > 0)
{ {
CFaber::TRawMaterial mp; CFaber::TRawMaterial mp;
mp.MpType = RM_FABER_TYPE::toFaberType( value ); mp.MpType = RM_FABER_TYPE::toFaberType( value );

38
code/ryzom/server/src/entities_game_service/egs_sheets/egs_static_game_sheet.cpp
View file

@ -1770,12 +1770,12 @@ void CStaticCharacters::readGeorges( const NLMISC::CSmartPtr<NLGEORGES::UForm> &
for( i = 0; i < SLOT_EQUIPMENT::NB_SLOT_EQUIPMENT; ++i ) for( i = 0; i < SLOT_EQUIPMENT::NB_SLOT_EQUIPMENT; ++i )
{ {
root.getValueByName( sheetName, (string("Basics.Equipment.") + SLOT_EQUIPMENT::toString( (SLOT_EQUIPMENT::TSlotEquipment) i ) + string(".Item" )).c_str() ); root.getValueByName( sheetName, "Basics.Equipment." + SLOT_EQUIPMENT::toString( (SLOT_EQUIPMENT::TSlotEquipment) i ) + ".Item" );
if( sheetName != string("") ) if (!sheetName.empty())
{ {
sheet = CSheetId( sheetName ); sheet = CSheetId( sheetName );
Items[ i ].IdSheet = sheet.asInt(); Items[ i ].IdSheet = sheet.asInt();
root.getValueByName( Items[ i ].Quality, (string("Basics.Equipment.") + SLOT_EQUIPMENT::toString( (SLOT_EQUIPMENT::TSlotEquipment) i ) + string(".Quality")).c_str() ); root.getValueByName( Items[ i ].Quality, "Basics.Equipment." + SLOT_EQUIPMENT::toString( (SLOT_EQUIPMENT::TSlotEquipment) i ) + ".Quality" );
} }
else else
{ {
@ -1789,12 +1789,12 @@ void CStaticCharacters::readGeorges( const NLMISC::CSmartPtr<NLGEORGES::UForm> &
/////////////////////////////////////////////////////// ///////////////////////////////////////////////////////
/* for( i = 0; i < NB_SHEATH; ++i ) /* for( i = 0; i < NB_SHEATH; ++i )
{ {
root.getValueByName( sheetName, (string("Basics.Equipment.Sheath") + toString( i ) + string("LeftHand.Item" )).c_str() ); root.getValueByName( sheetName, "Basics.Equipment.Sheath" + toString( i ) + "LeftHand.Item" );
if( sheetName != string("") ) if( sheetName != string("") )
{ {
sheet = CSheetId( sheetName ); sheet = CSheetId( sheetName );
Sheaths[ i ].Left.IdSheet = sheet.asInt(); Sheaths[ i ].Left.IdSheet = sheet.asInt();
root.getValueByName( Sheaths[ i ].Left.Quality, (string("Basics.Equipment.Sheath") + toString( i ) + string("LeftHand.Quality")).c_str() ); root.getValueByName( Sheaths[ i ].Left.Quality, "Basics.Equipment.Sheath" + toString( i ) + "LeftHand.Quality" );
} }
else else
{ {
@ -1802,12 +1802,12 @@ void CStaticCharacters::readGeorges( const NLMISC::CSmartPtr<NLGEORGES::UForm> &
Sheaths[ i ].Left.Quality = 0; Sheaths[ i ].Left.Quality = 0;
} }
root.getValueByName( sheetName, (string("Basics.Equipment.Sheath") + toString( i ) + string("RightHand.Item" )).c_str() ); root.getValueByName( sheetName, "Basics.Equipment.Sheath" + toString( i ) + "RightHand.Item" );
if( sheetName != string("") ) if( sheetName != string("") )
{ {
sheet = CSheetId( sheetName ); sheet = CSheetId( sheetName );
Sheaths[ i ].Right.IdSheet = sheet.asInt(); Sheaths[ i ].Right.IdSheet = sheet.asInt();
root.getValueByName( Sheaths[ i ].Right.Quality, (string("Basics.Equipment.Sheath") + toString( i ) + string("RightHand.Quality")).c_str() ); root.getValueByName( Sheaths[ i ].Right.Quality, "Basics.Equipment.Sheath" + toString( i ) + "RightHand.Quality" );
} }
else else
{ {
@ -1815,12 +1815,12 @@ void CStaticCharacters::readGeorges( const NLMISC::CSmartPtr<NLGEORGES::UForm> &
Sheaths[ i ].Right.Quality = 0; Sheaths[ i ].Right.Quality = 0;
} }
root.getValueByName( sheetName, (string("Basics.Equipment.Sheath") + toString( i ) + string("Ammo0.Item" )).c_str() ); root.getValueByName( sheetName, "Basics.Equipment.Sheath" + toString( i ) + "Ammo0.Item" );
if( sheetName != string("") ) if( sheetName != string("") )
{ {
sheet = CSheetId( sheetName ); sheet = CSheetId( sheetName );
Sheaths[ i ].Ammo0.IdSheet = sheet.asInt(); Sheaths[ i ].Ammo0.IdSheet = sheet.asInt();
root.getValueByName( Sheaths[ i ].Ammo0.Quality, (string("Basics.Equipment.Sheath") + toString( i ) + string("Ammo0.Quality")).c_str() ); root.getValueByName( Sheaths[ i ].Ammo0.Quality, "Basics.Equipment.Sheath" + toString( i ) + "Ammo0.Quality" );
} }
else else
{ {
@ -1828,12 +1828,12 @@ void CStaticCharacters::readGeorges( const NLMISC::CSmartPtr<NLGEORGES::UForm> &
Sheaths[ i ].Ammo0.Quality = 0; Sheaths[ i ].Ammo0.Quality = 0;
} }
root.getValueByName( sheetName, (string("Basics.Equipment.Sheath") + toString( i ) + string("Ammo1.Item" )).c_str() ); root.getValueByName( sheetName, "Basics.Equipment.Sheath" + toString( i ) + "Ammo1.Item" );
if( sheetName != string("") ) if( sheetName != string("") )
{ {
sheet = CSheetId( sheetName ); sheet = CSheetId( sheetName );
Sheaths[ i ].Ammo1.IdSheet = sheet.asInt(); Sheaths[ i ].Ammo1.IdSheet = sheet.asInt();
root.getValueByName( Sheaths[ i ].Ammo1.Quality, (string("Basics.Equipment.Sheath") + toString( i ) + string("Ammo1.Quality")).c_str() ); root.getValueByName( Sheaths[ i ].Ammo1.Quality, "Basics.Equipment.Sheath" + toString( i ) + "Ammo1.Quality" );
} }
else else
{ {
@ -1841,12 +1841,12 @@ void CStaticCharacters::readGeorges( const NLMISC::CSmartPtr<NLGEORGES::UForm> &
Sheaths[ i ].Ammo1.Quality = 0; Sheaths[ i ].Ammo1.Quality = 0;
} }
root.getValueByName( sheetName, (string("Basics.Equipment.Sheath") + toString( i ) + string("Ammo2.Item" )).c_str() ); root.getValueByName( sheetName, "Basics.Equipment.Sheath" + toString( i ) + "Ammo2.Item" );
if( sheetName != string("") ) if( sheetName != string("") )
{ {
sheet = CSheetId( sheetName ); sheet = CSheetId( sheetName );
Sheaths[ i ].Ammo2.IdSheet = sheet.asInt(); Sheaths[ i ].Ammo2.IdSheet = sheet.asInt();
root.getValueByName( Sheaths[ i ].Ammo2.Quality, (string("Basics.Equipment.Sheath") + toString( i ) + string("Ammo2.Quality")).c_str() ); root.getValueByName( Sheaths[ i ].Ammo2.Quality, "Basics.Equipment.Sheath" + toString( i ) + "Ammo2.Quality" );
} }
else else
{ {
@ -2202,7 +2202,7 @@ void CStaticRaceStats::readGeorges( const NLMISC::CSmartPtr<NLGEORGES::UForm> &f
int i; int i;
for( i = 0; i < CHARACTERISTICS::NUM_CHARACTERISTICS; ++i ) for( i = 0; i < CHARACTERISTICS::NUM_CHARACTERISTICS; ++i )
{ {
root.getValueByName( Characteristics[ (CHARACTERISTICS::TCharacteristics)i ], ( string("Characteristics.") + CHARACTERISTICS::toString( (CHARACTERISTICS::TCharacteristics)i ) ).c_str() ); root.getValueByName( Characteristics[ (CHARACTERISTICS::TCharacteristics)i ], "Characteristics." + CHARACTERISTICS::toString( (CHARACTERISTICS::TCharacteristics)i ) );
} }
/////////////////////////////////////////////////////// ///////////////////////////////////////////////////////
@ -2210,7 +2210,7 @@ void CStaticRaceStats::readGeorges( const NLMISC::CSmartPtr<NLGEORGES::UForm> &f
/////////////////////////////////////////////////////// ///////////////////////////////////////////////////////
for( i = 0; i < SCORES::NUM_SCORES; ++i ) for( i = 0; i < SCORES::NUM_SCORES; ++i )
{ {
root.getValueByName( Scores[ i ], ( string("Scores.") + SCORES::toString( i ) ).c_str(), UFormElm::Formula ); root.getValueByName( Scores[ i ], "Scores." + SCORES::toString( i ), UFormElm::Formula );
} }
/////////////////////////////////////////////////////// ///////////////////////////////////////////////////////
@ -2306,7 +2306,7 @@ void CStaticRole::readGeorgesSentenceAndEquipment( UFormElm& root, const NLMISC:
{ {
string value; string value;
const UFormElm *sentenceArray = NULL; const UFormElm *sentenceArray = NULL;
if (root.getNodeByName (&sentenceArray, SentenceString.c_str()) && sentenceArray) if (root.getNodeByName (&sentenceArray, SentenceString) && sentenceArray)
{ {
// Get array size // Get array size
uint size; uint size;
@ -2352,12 +2352,12 @@ void CStaticRole::readGeorgesSentenceAndEquipment( UFormElm& root, const NLMISC:
for( int i = 0; i < SLOT_EQUIPMENT::NB_SLOT_EQUIPMENT; ++i ) for( int i = 0; i < SLOT_EQUIPMENT::NB_SLOT_EQUIPMENT; ++i )
{ {
root.getValueByName( sheetName, ( EquipmentString + string(".") + SLOT_EQUIPMENT::toString( (SLOT_EQUIPMENT::TSlotEquipment) i ) + string(".Item" )).c_str() ); root.getValueByName( sheetName, EquipmentString + "." + SLOT_EQUIPMENT::toString( (SLOT_EQUIPMENT::TSlotEquipment) i ) + ".Item" );
if( sheetName != string("") ) if (!sheetName.empty())
{ {
sheet = CSheetId( sheetName ); sheet = CSheetId( sheetName );
Items[ i ].IdSheet = sheet.asInt(); Items[ i ].IdSheet = sheet.asInt();
root.getValueByName( Items[ i ].Quality, ( EquipmentString + string(".") + SLOT_EQUIPMENT::toString( (SLOT_EQUIPMENT::TSlotEquipment) i ) + string(".Quality")).c_str() ); root.getValueByName( Items[ i ].Quality, EquipmentString + "." + SLOT_EQUIPMENT::toString( (SLOT_EQUIPMENT::TSlotEquipment) i ) + ".Quality" );
} }
else else
{ {

18
code/ryzom/server/src/entities_game_service/egs_sheets/egs_static_harvestable.cpp
View file

@ -83,8 +83,8 @@ static void getVarListFromParents (const NLGEORGES::UForm *form, std::set<NLGEOR
const NLGEORGES::UFormElm &item=form->getRootNode(); const NLGEORGES::UFormElm &item=form->getRootNode();
NLGEORGES::UFormElm *elem=NULL; NLGEORGES::UFormElm *elem=NULL;
const_cast<NLGEORGES::UFormElm*>(&item)->getNodeByName(&elem, varName.c_str()); const_cast<NLGEORGES::UFormElm*>(&item)->getNodeByName(&elem, varName);
if (elem!=NULL) // item.getValueByName(temp, varName.c_str())) if (elem!=NULL) // item.getValueByName(temp, varName))
{ {
varList.insert (elem); varList.insert (elem);
} }
@ -123,7 +123,7 @@ void CStaticHarvestable::loadFromGeorges( const UForm &form, const NLMISC::CShee
*/ */
{ {
string value; string value;
if ( form.getRootNode().getValueByName( value, (string("Harvest.")+"Skill").c_str() ) if ( form.getRootNode().getValueByName( value, "Harvest.Skill" )
&& !value.empty() ) && !value.empty() )
{ {
_HarvestSkill = SKILLS::toSkill( value ); _HarvestSkill = SKILLS::toSkill( value );
@ -139,22 +139,22 @@ void CStaticHarvestable::loadFromGeorges( const UForm &form, const NLMISC::CShee
const string mpName=NLMISC::toString("MP%u",i); const string mpName=NLMISC::toString("MP%u",i);
CStaticCreatureRawMaterial mp; CStaticCreatureRawMaterial mp;
if( form.getRootNode().getValueByName( mp.MpCommon.AssociatedItemName, ("Harvest." +mpName+".AssociatedItem").c_str()) if( form.getRootNode().getValueByName( mp.MpCommon.AssociatedItemName, "Harvest." +mpName+".AssociatedItem")
&& !mp.MpCommon.AssociatedItemName.empty() ) && !mp.MpCommon.AssociatedItemName.empty() )
{ {
if (VerboseQuartering) if (VerboseQuartering)
nldebug("QRTR: %s=%s", mpName.c_str(), mp.MpCommon.AssociatedItemName.c_str()); nldebug("QRTR: %s=%s", mpName.c_str(), mp.MpCommon.AssociatedItemName.c_str());
form.getRootNode().getValueByName( mp.MpCommon.Name, ("Harvest." +mpName+".Name").c_str() ); form.getRootNode().getValueByName( mp.MpCommon.Name, "Harvest." +mpName+".Name" );
uint16 sheetQuantity; uint16 sheetQuantity;
form.getRootNode().getValueByName( sheetQuantity, ("Harvest." +mpName+".Quantity").c_str() ); form.getRootNode().getValueByName( sheetQuantity, "Harvest." +mpName+".Quantity" );
if ( sheetQuantity != 0 ) if ( sheetQuantity != 0 )
{ {
nlwarning( "Quantity set to %hu in %s", sheetQuantity, sheetId.toString().c_str() ); nlwarning( "Quantity set to %hu in %s", sheetQuantity, sheetId.toString().c_str() );
} }
form.getRootNode().getValueByName( mp.MpCommon.MinQuality, ("Harvest." +mpName+".MinQuality").c_str() ); form.getRootNode().getValueByName( mp.MpCommon.MinQuality, "Harvest." +mpName+".MinQuality" );
form.getRootNode().getValueByName( mp.MpCommon.MaxQuality, ("Harvest." +mpName+".MaxQuality").c_str() ); form.getRootNode().getValueByName( mp.MpCommon.MaxQuality, "Harvest." +mpName+".MaxQuality" );
// harvest->getValueByName( mp.PresenceProbabilities, (mpName+".PresenceProbabilities").c_str() ); // harvest->getValueByName( mp.PresenceProbabilities, mpName+".PresenceProbabilities" );
mp.ItemId = mp.MpCommon.AssociatedItemName; mp.ItemId = mp.MpCommon.AssociatedItemName;
if ( mp.MpCommon.MinQuality == 0) if ( mp.MpCommon.MinQuality == 0)

8
code/ryzom/server/src/entities_game_service/egs_sheets/egs_static_outpost.cpp
View file

@ -142,12 +142,12 @@ void CStaticOutpostBuilding::CDriller::readGeorges (const NLGEORGES::UFormElm *p
TotalMP = 0.0f; TotalMP = 0.0f;
for (uint i = 0; i < 20; ++i) for (uint i = 0; i < 20; ++i)
{ {
string namePath = NLMISC::toString("mp%d.name", i); string namePath = NLMISC::toString("mp%u.name", i);
string quantityPath = NLMISC::toString("mp%d.quantity", i); string quantityPath = NLMISC::toString("mp%u.quantity", i);
string name; string name;
float quantity; float quantity;
pElt->getValueByName (name, namePath.c_str()); pElt->getValueByName (name, namePath);
pElt->getValueByName (quantity, quantityPath.c_str()); pElt->getValueByName (quantity, quantityPath);
if(!name.empty() && quantity>0.f) if(!name.empty() && quantity>0.f)
{ {
CSheetId mpSheetId = CSheetId(name); CSheetId mpSheetId = CSheetId(name);

2
code/ryzom/server/src/entities_game_service/egs_sheets/egs_static_rolemaster_phrase.cpp
View file

@ -41,7 +41,7 @@ void CStaticRolemasterPhrase::readGeorges (const NLMISC::CSmartPtr<NLGEORGES::UF
uint i = 0; uint i = 0;
while ( i < 100 ) while ( i < 100 )
{ {
bool res = form->getRootNode().getValueByName( sbrickSheetName, toString( "brick %u", i ).c_str() ); bool res = form->getRootNode().getValueByName( sbrickSheetName, toString( "brick %u", i ) );
if ( (! res) || sbrickSheetName.empty() ) if ( (! res) || sbrickSheetName.empty() )
{ {
++i; ++i;

14
code/ryzom/tools/leveldesign/georges_dll/action.cpp
View file

@ -44,7 +44,7 @@ IAction::IAction (TTypeAction type, uint selId, uint slot)
// *************************************************************************** // ***************************************************************************
void IAction::setLabel (const char *logLabel, CGeorgesEditDoc &doc) void IAction::setLabel (const std::string &logLabel, CGeorgesEditDoc &doc)
{ {
_LogLabel = logLabel; _LogLabel = logLabel;
@ -75,7 +75,7 @@ bool IAction::doAction (CGeorgesEditDoc &doc, bool redo, bool &modified, bool fi
// *************************************************************************** // ***************************************************************************
void IAction::update (bool updateLeftView, TUpdateRightView rightViewFlag, CGeorgesEditDoc &doc, const char *_FormName) void IAction::update (bool updateLeftView, TUpdateRightView rightViewFlag, CGeorgesEditDoc &doc, const std::string &_FormName)
{ {
// Right and left view // Right and left view
CGeorgesEditView *rightView = doc.getRightView (); CGeorgesEditView *rightView = doc.getRightView ();
@ -129,7 +129,7 @@ void IAction::update (bool updateLeftView, TUpdateRightView rightViewFlag, CGeor
// *************************************************************************** // ***************************************************************************
CActionString::CActionString (IAction::TTypeAction type, const char *newValue, CGeorgesEditDoc &doc, const char *formName, const char *userData, uint selId, uint slot) : IAction (type, selId, slot) CActionString::CActionString (IAction::TTypeAction type, const std::string &newValue, CGeorgesEditDoc &doc, const std::string &formName, const std::string &userData, uint selId, uint slot) : IAction (type, selId, slot)
{ {
// Set the new value // Set the new value
_NewValue = newValue; _NewValue = newValue;
@ -145,7 +145,9 @@ CActionString::CActionString (IAction::TTypeAction type, const char *newValue, C
CType *type = doc.getTypePtr (); CType *type = doc.getTypePtr ();
_OldValue = toString ((int)(type->Type)); _OldValue = toString ((int)(type->Type));
setLabel ("Type Type", doc); setLabel ("Type Type", doc);
_Log[1] = type->getTypeName ((UType::TType)atoi (newValue)); uint ttype;
fromString(newValue, ttype);
_Log[1] = type->getTypeName ((UType::TType)ttype);
} }
break; break;
case TypeUI: case TypeUI:
@ -153,7 +155,9 @@ CActionString::CActionString (IAction::TTypeAction type, const char *newValue, C
CType *type = doc.getTypePtr (); CType *type = doc.getTypePtr ();
_OldValue = toString ((int)(type->UIType)); _OldValue = toString ((int)(type->UIType));
setLabel ("Type UI", doc); setLabel ("Type UI", doc);
_Log[1] = type->getUIName ((CType::TUI)atoi (newValue)); uint ttype;
fromString(newValue, ttype);
_Log[1] = type->getUIName ((CType::TUI)ttype);
} }
break; break;
case TypeDefault: case TypeDefault:

10
code/ryzom/tools/leveldesign/georges_dll/action.h
View file

@ -59,7 +59,7 @@ protected:
IAction (TTypeAction type, uint selId, uint slot); IAction (TTypeAction type, uint selId, uint slot);
// Init log label // Init log label
void setLabel (const char *logLabel, CGeorgesEditDoc &doc); void setLabel (const std::string &logLabel, CGeorgesEditDoc &doc);
public: public:
@ -96,7 +96,7 @@ protected:
UpdateValues, UpdateValues,
Redraw Redraw
}; };
void update (bool updateLeftView, TUpdateRightView rightView, CGeorgesEditDoc &doc, const char *_FormName); void update (bool updateLeftView, TUpdateRightView rightView, CGeorgesEditDoc &doc, const std::string &_FormName);
}; };
// String modification action // String modification action
@ -105,7 +105,7 @@ class CActionString : public IAction
public: public:
// Constructor // Constructor
CActionString (IAction::TTypeAction type, const char *newValue, CGeorgesEditDoc &doc, const char *formName, const char *userData, uint selId, uint slot); CActionString(IAction::TTypeAction type, const std::string &newValue, CGeorgesEditDoc &doc, const std::string &formName, const std::string &userData, uint selId, uint slot);
protected: protected:
@ -165,7 +165,7 @@ class CActionBuffer : public IAction
public: public:
// Constructor // Constructor
CActionBuffer (IAction::TTypeAction type, const uint8 *buffer, uint bufferSize, CGeorgesEditDoc &doc, const char *formName, const char *userData, uint selId, uint slot); CActionBuffer (IAction::TTypeAction type, const uint8 *buffer, uint bufferSize, CGeorgesEditDoc &doc, const std::string &formName, const std::string &userData, uint selId, uint slot);
protected: protected:
@ -182,4 +182,4 @@ protected:
virtual bool doAction (CGeorgesEditDoc &doc, bool redo, bool &modified, bool firstTime); virtual bool doAction (CGeorgesEditDoc &doc, bool redo, bool &modified, bool firstTime);
}; };
#endif GEORGES_EDIT_ACTION_H #endif

8
code/ryzom/tools/leveldesign/georges_dll/form_dialog.cpp
View file

@ -1292,14 +1292,14 @@ void IFormWidget::updateLabel ()
UFormElm::TWhereIsValue where; UFormElm::TWhereIsValue where;
CForm *form=doc->getFormPtr (); CForm *form=doc->getFormPtr ();
CFormElm *elm = doc->getRootNode (getSlot ()); CFormElm *elm = doc->getRootNode (getSlot ());
nlverify (elm->getValueByName (result, FormName.c_str (), UFormElm::NoEval, &where)); nlverify (elm->getValueByName (result, FormName, UFormElm::NoEval, &where));
// Get the value evaluated // Get the value evaluated
std::string resultEvaluated; std::string resultEvaluated;
#ifdef TEST_EVAL_FORMULA #ifdef TEST_EVAL_FORMULA
bool error = !elm->getValueByName (resultEvaluated, FormName.c_str (), UFormElm::Formula, &where); bool error = !elm->getValueByName (resultEvaluated, FormName, UFormElm::Formula, &where);
#else // TEST_EVAL_FORMULA #else // TEST_EVAL_FORMULA
bool error = !elm->getValueByName (resultEvaluated, FormName.c_str (), UFormElm::Eval, &where); bool error = !elm->getValueByName (resultEvaluated, FormName, UFormElm::Eval, &where);
#endif // TEST_EVAL_FORMULA #endif // TEST_EVAL_FORMULA
// Complete the array ? // Complete the array ?
@ -1688,7 +1688,7 @@ void CFormMemCombo::getFromDocument (CForm &form)
if ((SrcType == TypeForm) || (SrcType == TypeType)) if ((SrcType == TypeForm) || (SrcType == TypeType))
{ {
string result; string result;
if (doc->getRootNode(getSlot ())->getValueByName (result, FormName.c_str(), UFormElm::NoEval, NULL)) if (doc->getRootNode(getSlot ())->getValueByName (result, FormName, UFormElm::NoEval, NULL))
{ {
Combo.UpdateData (); Combo.UpdateData ();
Combo.SetWindowText (result.c_str()); Combo.SetWindowText (result.c_str());