Changeset 332 for ps

Timestamp:

06/01/04 18:51:37 (21 years ago)

Author:

janwas

Message:

removed obsoleted _int etc. typedefs

Location:

ps/trunk/source

Files:

• maths/MathUtil.cpp (modified) (16 diffs)
• maths/MathUtil.h (modified) (5 diffs)
• ps/CStr.cpp (modified) (23 diffs)
• ps/CStr.h (modified) (5 diffs)
• ps/Config.cpp (modified) (2 diffs)
• ps/Encryption.cpp (modified) (4 diffs)
• ps/Encryption.h (modified) (2 diffs)
• ps/LogFile.cpp (modified) (2 diffs)
• ps/LogFile.h (modified) (4 diffs)
• ps/Parser.cpp (modified) (10 diffs)
• ps/Parser.h (modified) (5 diffs)
• ps/Prometheus.cpp (modified) (1 diff)
• ps/Prometheus.h (modified) (2 diffs)

ps/trunk/source/maths/MathUtil.cpp

@@ -18 +18 @@
 //            FL_FP_TOLERANCE of each other.
 //
-_bool MathUtil::CompareFloat(const _double &num1, const _double &num2)
+bool MathUtil::CompareFloat(const double &num1, const double &num2)
 {
     if( Abs(num1 - num2) < FL_FP_TOLERANCE )
@@ -31 +31 @@
 // PURPOSE: Converts from Radians to Degrees
 //
-inline _double MathUtil::RadiansToDegrees(const _double &num)
+inline double MathUtil::RadiansToDegrees(const double &num)
 {
     return num*(PI/180);
@@ -41 +41 @@
 // PURPOSE: Converts from Degrees to Radians
 //
-inline _double MathUtil::DegreesToRadians(const _double &num)
+inline double MathUtil::DegreesToRadians(const double &num)
 {
     return (num*180)/PI;
@@ -53 +53 @@
 //   NOTES: returns -1 if lowerBound >= upperBound
 //
-_float MathUtil::Random(const _float &lowerBound, const _float &upperBound)
+float MathUtil::Random(const float &lowerBound, const float &upperBound)
 {
 
@@ -64 +64 @@
 
         // finds a floating point number between 0 and 1.0
-        _float randVar = ( static_cast<_float>( rand() )/RAND_MAX );
+        float randVar = ( static_cast<float>( rand() )/RAND_MAX );
 
         // maps the number onto the set from 0 to upperBound
@@ -82 +82 @@
 //   NOTES: returns -1 if lowerBound >= upperBound
 //
-_int MathUtil::Random(const _int &lowerBound,const _int &upperBound)
+int MathUtil::Random(const int &lowerBound,const int &upperBound)
 {
     if( lowerBound >= upperBound)
@@ -92 +92 @@
 
         // find a random variable between 0 and range size
-        _int randVar = rand()%( Abs(upperBound - lowerBound) + 1);
+        int randVar = rand()%( Abs(upperBound - lowerBound) + 1);
 
         // translate to proper range
@@ -108 +108 @@
 //           float version.
 //
-_int MathUtil::Round(const float &num)
+int MathUtil::Round(const float &num)
 {
     if( num > 0 )
-        return static_cast<_int>(num + .5);
+        return static_cast<int>(num + .5);
     else if (num < 0 )
-        return static_cast<_int>(num - .5);
+        return static_cast<int>(num - .5);
     else
         return 0;
@@ -125 +125 @@
 //           double version.
 //
-_int MathUtil::Round(const double &num)
+int MathUtil::Round(const double &num)
 {
     if( num > 0 )
-        return static_cast<_int>(num + .5);
+        return static_cast<int>(num + .5);
     else if (num < 0 )
-        return static_cast<_int>(num - .5);
+        return static_cast<int>(num - .5);
     else
         return 0;
@@ -140 +140 @@
 // PURPOSE: returns a mathematically correct modulus for int
 //
-_int MathUtil::SignedModulus(const _int &num, const _int &n)
+int MathUtil::SignedModulus(const int &num, const int &n)
 {
     if( num >= 0 )
@@ -149 +149 @@
         // we have to multiply by -1 to reflect it back.  This method
         // is faster than calling Abs() and then doing the modulus.
-        _int Tnum = -1*(num%n);
+        int Tnum = -1*(num%n);
         
         // if num%n equals 0, then n - Tnum will be n, which, logically
@@ -167 +167 @@
 // PURPOSE: returns a mathematically correct modulus for long
 //
-_long MathUtil::SignedModulus(const _long &num, const _long &n)
+long MathUtil::SignedModulus(const long &num, const long &n)
 {
     if( num >= 0 )
@@ -176 +176 @@
         // we have to multiply by -1 to reflect it back.  This method
         // is faster than calling Abs() and then doing the modulus.
-        _long Tnum = -1*(num%n);
+        long Tnum = -1*(num%n);
 
         // if num%n equals 0, then n - Tnum will be n, which, logically
@@ -195 +195 @@
 //   NOTES: uses fmod() in math.h, which returns the modulus of floats
 //
-_float MathUtil::SignedModulus(const _float &num, const _float &n)
+float MathUtil::SignedModulus(const float &num, const float &n)
 {
     if( num >=0 )
-        return static_cast<_float>( fmod(num,n) );
-    else
-    {
-        // the % operator reflects the range if num < 0, so
-        // we have to multiply by -1 to reflect it back.  This method
-        // is faster than calling Abs() and then doing the modulus.
-        _float Tnum = -1*( static_cast<_float>( fmod(num,n) ) );
+        return static_cast<float>( fmod(num,n) );
+    else
+    {
+        // the % operator reflects the range if num < 0, so
+        // we have to multiply by -1 to reflect it back.  This method
+        // is faster than calling Abs() and then doing the modulus.
+        float Tnum = -1*( static_cast<float>( fmod(num,n) ) );
 
         // if num%n equals 0, then n - Tnum will be n, which, logically
@@ -224 +224 @@
 //   NOTES: uses fmod() in math.h, which returns the modulus of floats
 //
-_double MathUtil::SignedModulus(const _double &num, const _double &n)
+double MathUtil::SignedModulus(const double &num, const double &n)
 {
     if( num >=0 )
@@ -233 +233 @@
         // we have to multiply by -1 to reflect it back.  This method
         // is faster than calling Abs() and then doing the modulus.
-        _double Tnum = -1*( fmod(num,n) );
+        double Tnum = -1*( fmod(num,n) );
 
         // if num%n equals 0, then n - Tnum will be n, which, logically

ps/trunk/source/maths/MathUtil.h

@@ -55 +55 @@
 namespace MathUtil
 {
-    const _double PI = 3.14159265358932384;
-    const _double FL_FP_TOLERANCE = .000000001;
+    const double PI = 3.14159265358932384;
+    const double FL_FP_TOLERANCE = .000000001;
 
 
@@ -86 +86 @@
     //
     template <typename T>
-    T Clamp(T &num, const _int &lowerBound,const _int &upperBound)
+    T Clamp(T &num, const int &lowerBound,const int &upperBound)
     {
         if(num <= lowerBound)
@@ -129 +129 @@
     //
     template <typename T>
-    _int Sign(const T &num)
+    int Sign(const T &num)
     {
         if( num > 0 )
@@ -147 +147 @@
     //
     template <typename T>
-    inline _double Square(const T &num)
+    inline double Square(const T &num)
     {
         return num*num;
@@ -192 +192 @@
     //--------------------------------------------------------
 
-    _int Ceiling(const float &num);
-    _int Ceiling(const double &num);
-
-    _bool CompareFloat(const _double &, const _double &);
-
-    _int Floor(const float &num);
-    _int Floor(const double &num);
-
-    inline _double RadiansToDegrees(const _double &num);
-    inline _double DegreesToRadians(const _double &num);
-
-    _float Random(const _float &, const _float &);
-    _int Random(const _int &,const _int &); 
-
-    _int Round(const float &num);
-    _int Round(const double &num);
-
-    _int SignedModulus(const _int &num, const _int &n);
-    _long SignedModulus(const _long &num, const _long &n);
-    _float SignedModulus(const _float &num, const _float &n);
-    _double SignedModulus(const _double &num, const _double &n);
+    int Ceiling(const float &num);
+    int Ceiling(const double &num);
+
+    bool CompareFloat(const double &, const double &);
+
+    int Floor(const float &num);
+    int Floor(const double &num);
+
+    inline double RadiansToDegrees(const double &num);
+    inline double DegreesToRadians(const double &num);
+
+    float Random(const float &, const float &);
+    int Random(const int &,const int &);    
+
+    int Round(const float &num);
+    int Round(const double &num);
+
+    int SignedModulus(const int &num, const int &n);
+    long SignedModulus(const long &num, const long &n);
+    float SignedModulus(const float &num, const float &n);
+    double SignedModulus(const double &num, const double &n);
 }
 

ps/trunk/source/ps/CStr.cpp

@@ -30 +30 @@
 }
 
-CStr::CStr(_int Number)
+CStr::CStr(int Number)
 {
     // Creates CStr from a int
@@ -36 +36 @@
 }
 
-CStr::CStr(_uint Number)
+CStr::CStr(unsigned int Number)
 {
     // Creates CStr from a uint
@@ -43 +43 @@
 
 
-CStr::CStr(_long Number)
+CStr::CStr(long Number)
 {
     // Creates CStr from a long 
@@ -50 +50 @@
 
 
-CStr::CStr(_ulong Number)
+CStr::CStr(unsigned long Number)
 {
     // Creates CStr from a ulong 
@@ -57 +57 @@
 
 
-CStr::CStr(_float Number)
+CStr::CStr(float Number)
 {
     // Creates CStr from a float
@@ -64 +64 @@
 }
 
-CStr::CStr(_double Number)
+CStr::CStr(double Number)
 {
     // Creates CStr from a double
@@ -77 +77 @@
 
 
-_int CStr::ToInt() const
+int CStr::ToInt() const
 {
     return _ttoi(m_String.c_str());
 }
 
-_uint CStr::ToUInt() const
-{
-    return _uint(_ttoi(m_String.c_str()));
-}
-
-_long CStr::ToLong() const
+unsigned int CStr::ToUInt() const
+{
+    return unsigned int(_ttoi(m_String.c_str()));
+}
+
+long CStr::ToLong() const
 {
     return _ttol(m_String.c_str());
 }
 
-_ulong CStr::ToULong() const
-{
-    return _ulong(_ttol(m_String.c_str()));
-}
-
-
-_float CStr::ToFloat() const
-{
-    return (_float)_tstod(m_String.c_str(), NULL);
-}
-
-_double CStr::ToDouble() const
+unsigned long CStr::ToULong() const
+{
+    return unsigned long(_ttol(m_String.c_str()));
+}
+
+
+float CStr::ToFloat() const
+{
+    return (float)_tstod(m_String.c_str(), NULL);
+}
+
+double  CStr::ToDouble() const
 {
     return _tstod(m_String.c_str(), NULL);
@@ -116 +116 @@
 
 //Search the string for another string 
-_long CStr::Find(const CStr &Str) const
-{
-    _long Pos = (_long)m_String.find(Str.m_String, 0);
+long CStr::Find(const CStr &Str) const
+{
+    long Pos = (long)m_String.find(Str.m_String, 0);
 
     if (Pos != tstring::npos)
@@ -127 +127 @@
 
 //Search the string for another string 
-_long CStr::Find(const TCHAR &tchar) const
-{
-    _long Pos = (_long)m_String.find(tchar, 0);
+long CStr::Find(const TCHAR &tchar) const
+{
+    long Pos = (long)m_String.find(tchar, 0);
 
     if (Pos != tstring::npos)
@@ -138 +138 @@
 
 //Search the string for another string 
-_long CStr::Find(const int &start, const TCHAR &tchar) const
-{
-    _long Pos = (_long)m_String.find(tchar, start);
+long CStr::Find(const int &start, const TCHAR &tchar) const
+{
+    long Pos = (long)m_String.find(tchar, start);
 
     if (Pos != tstring::npos)
@@ -148 +148 @@
 }
 
-_long CStr::ReverseFind(const CStr &Str) const
-{
-    _long Pos = (_long)m_String.rfind(Str.m_String, m_String.length() );
+long CStr::ReverseFind(const CStr &Str) const
+{
+    long Pos = (long)m_String.rfind(Str.m_String, m_String.length() );
 
     if (Pos != tstring::npos)
@@ -199 +199 @@
 
 //Retreive the substring of the first n characters 
-CStr CStr::Left(_long len) const
+CStr CStr::Left(long len) const
 {
     return CStr( m_String.substr(0, len) );
@@ -205 +205 @@
 
 //Retreive the substring of the last n characters
-CStr CStr::Right(_long len) const
+CStr CStr::Right(long len) const
 {
     return CStr( m_String.substr(m_String.length()-len, len) );
@@ -299 +299 @@
 }
 
-CStr &CStr::operator=(_int Number)
+CStr &CStr::operator=(int Number)
 {
     m_String = _itot(Number, m_ConversionBuffer, 10);
@@ -305 +305 @@
 }
 
-CStr &CStr::operator=(_long Number)
+CStr &CStr::operator=(long Number)
 {
     m_String = _ltot(Number, m_ConversionBuffer, 10);
@@ -311 +311 @@
 }
 
-CStr &CStr::operator=(_uint Number)
+CStr &CStr::operator=(unsigned int Number)
 {
     m_String = _ultot(Number, m_ConversionBuffer, 10);
@@ -317 +317 @@
 }
 
-CStr &CStr::operator=(_ulong Number)
+CStr &CStr::operator=(unsigned long Number)
 {
     m_String = _ultot(Number, m_ConversionBuffer, 10);
@@ -324 +324 @@
 
 
-CStr &CStr::operator=(_float Number)
+CStr &CStr::operator=(float Number)
 {
     _tsprintf(m_ConversionBuffer, FLOAT_CONVERSION, Number);
@@ -331 +331 @@
 }
 
-CStr &CStr::operator=(_double Number)
+CStr &CStr::operator=(double Number)
 {
     _tsprintf(m_ConversionBuffer, FLOAT_CONVERSION, Number);
@@ -338 +338 @@
 }
 
-_bool CStr::operator==(const CStr &Str) const
+bool CStr::operator==(const CStr &Str) const
 {
     return (m_String == Str.m_String);
 }
 
-_bool CStr::operator!=(const CStr &Str) const
+bool CStr::operator!=(const CStr &Str) const
 {
     return (m_String != Str.m_String);
 }
 
-_bool CStr::operator<(const CStr &Str) const
+bool CStr::operator<(const CStr &Str) const
 {
     return (m_String < Str.m_String);
 }
 
-_bool CStr::operator<=(const CStr &Str) const
+bool CStr::operator<=(const CStr &Str) const
 {
     return (m_String <= Str.m_String);
 }
 
-_bool CStr::operator>(const CStr &Str) const
+bool CStr::operator>(const CStr &Str) const
 {
     return (m_String > Str.m_String);
 }
 
-_bool CStr::operator>=(const CStr &Str) const
+bool CStr::operator>=(const CStr &Str) const
 {
     return (m_String >= Str.m_String);
@@ -392 +392 @@
 
 
-TCHAR &CStr::operator[](_int n)
+TCHAR &CStr::operator[](int n)
 {
     assert((size_t)n < m_String.length());
@@ -398 +398 @@
 }
 
-TCHAR &CStr::operator[](_uint n)
+TCHAR &CStr::operator[](unsigned int n)
 {
     assert(n < m_String.length());
     return m_String[n];
 }
-TCHAR &CStr::operator[](_long n)
+TCHAR &CStr::operator[](long n)
 {
     assert((size_t)n < m_String.length());
@@ -409 +409 @@
 }
 
-TCHAR &CStr::operator[](_ulong n)
+TCHAR &CStr::operator[](unsigned long n)
 {
     assert(n < m_String.length());

ps/trunk/source/ps/CStr.h

@@ -13 +13 @@
     
     CStr MyString = _T("Hello, World.");
-    _int MyNum = 126;
+    int MyNum = 126;
     MyString += _T(" I'm the number ") += CStr(MyNumber);
     
@@ -103 +103 @@
     CStr(const TCHAR* String);  // Creates CStr from C-Style TCHAR string
     CStr(TCHAR Char);       // Creates CStr from a TCHAR
-    CStr(_int Number);      // Creates CStr from a int
-    CStr(_uint Number);     // Creates CStr from a uint
-    CStr(_long Number);     // Creates CStr from a long 
-    CStr(_ulong Number);    // Creates CStr from a ulong 
-    CStr(_float Number);    // Creates CStr from a float
-    CStr(_double Number);   // Creates CStr from a double
+    CStr(int Number);       // Creates CStr from a int
+    CStr(unsigned int Number);      // Creates CStr from a uint
+    CStr(long Number);      // Creates CStr from a long 
+    CStr(unsigned long Number); // Creates CStr from a ulong 
+    CStr(float Number); // Creates CStr from a float
+    CStr(double Number);    // Creates CStr from a double
     ~CStr();                // Destructor
 
     // Conversions
-    _int    ToInt() const;
-    _uint   ToUInt() const;
-    _long   ToLong() const;
-    _ulong  ToULong() const;
-    _float  ToFloat() const;
-    _double ToDouble() const;
+    int ToInt() const;
+    unsigned int    ToUInt() const;
+    long    ToLong() const;
+    unsigned long   ToULong() const;
+    float   ToFloat() const;
+    double  ToDouble() const;
 
     size_t Length() const {return m_String.length();}
@@ -124 +124 @@
 
     //Search the string for another string 
-    _long Find(const CStr &Str) const;
+    long Find(const CStr &Str) const;
 
     //Search the string for another string 
-    _long Find(const TCHAR &tchar) const;
+    long Find(const TCHAR &tchar) const;
 
     //Search the string for another string 
-    _long Find(const int &start, const TCHAR &tchar) const;
+    long Find(const int &start, const TCHAR &tchar) const;
 
     //You can also do a "ReverseFind"- i.e. search starting from the end 
-    _long ReverseFind(const CStr &Str) const;
+    long ReverseFind(const CStr &Str) const;
 
     // Lowercase and uppercase 
@@ -144 +144 @@
 
     // Retreive the substring of the first n characters 
-    CStr Left(_long len) const;
+    CStr Left(long len) const;
 
     // Retreive the substring of the last n characters
-    CStr Right(_long len) const;
+    CStr Right(long len) const;
     
     //Remove all occurences of some character or substring 
@@ -162 +162 @@
     CStr &operator=(const TCHAR* String);
     CStr &operator=(TCHAR Char);
-    CStr &operator=(_int Number);
-    CStr &operator=(_long Number);
-    CStr &operator=(_uint Number);
-    CStr &operator=(_ulong Number);
-    CStr &operator=(_float Number);
-    CStr &operator=(_double Number);
-
-    _bool operator==(const CStr &Str) const;
-    _bool operator!=(const CStr &Str) const;
-    _bool operator<(const CStr &Str) const;
-    _bool operator<=(const CStr &Str) const;
-    _bool operator>(const CStr &Str) const;
-    _bool operator>=(const CStr &Str) const;
+    CStr &operator=(int Number);
+    CStr &operator=(long Number);
+    CStr &operator=(unsigned int Number);
+    CStr &operator=(unsigned long Number);
+    CStr &operator=(float Number);
+    CStr &operator=(double Number);
+
+    bool operator==(const CStr &Str) const;
+    bool operator!=(const CStr &Str) const;
+    bool operator<(const CStr &Str) const;
+    bool operator<=(const CStr &Str) const;
+    bool operator>(const CStr &Str) const;
+    bool operator>=(const CStr &Str) const;
     CStr &operator+=(const CStr &Str);
     CStr  operator+(const CStr &Str);
     operator const TCHAR*();
     operator const TCHAR*() const; // Gee, I've added this, Maybe the one above should be removed?
-    TCHAR &operator[](_int n);
-    TCHAR &operator[](_uint n);
-    TCHAR &operator[](_long n);
-    TCHAR &operator[](_ulong n);
+    TCHAR &operator[](int n);
+    TCHAR &operator[](unsigned int n);
+    TCHAR &operator[](long n);
+    TCHAR &operator[](unsigned long n);
 
     inline const char *c_str()

ps/trunk/source/ps/Config.cpp

@@ -111 +111 @@
 PS_RESULT CConfig::Update()
 {
-    _int slice = 0;
-    _int failed = 0;
+    int slice = 0;
+    int failed = 0;
     struct stat FileInfo;
 
@@ -212 +212 @@
 {
     // Mostly identical to Update(), above.
-    _int failed = 0;
-    _int notfound = 0; 
+    int failed = 0;
+    int notfound = 0; 
     struct stat FileInfo;
 

ps/trunk/source/ps/Encryption.cpp

@@ -9 +9 @@
 // to call delete[]. 
 //--------------------------------------------------------------------
-_byte *EncryptData(_byte *Data, _long DataLength, _byte *Key, _long KeyLength)
+char *EncryptData(char *Data, long DataLength, char *Key, long KeyLength)
 {
     // Allocate space for new Encrypted data
-    _byte *NewData = new _byte[DataLength];
+    char *NewData = new char[DataLength];
 
     // A counter to hold our absolute position in data
-    _long DataOffset = 0;
+    long DataOffset = 0;
 
     // Loop through Data until end is reached
@@ -21 +21 @@
     {
         // Loop through the key
-        for (_long KeyOffset = 0; KeyOffset < KeyLength; KeyOffset++)
+        for (long KeyOffset = 0; KeyOffset < KeyLength; KeyOffset++)
         {
             // If were at end of data break and the the while loop should end as well.
@@ -51 +51 @@
 // to call delete[]. 
 //--------------------------------------------------------------------
-_byte *DecryptData(_byte *Data, _long DataLength, _byte *Key, _long KeyLength)
+char *DecryptData(char *Data, long DataLength, char *Key, long KeyLength)
 {
     // Allocate space for new Decrypted data
-    _byte *NewData = new _byte[DataLength];
+    char *NewData = new char[DataLength];
 
     // A counter to hold our absolute position in data
-    _long DataOffset = 0;
+    long DataOffset = 0;
 
     // Loop through Data until end is reached
@@ -63 +63 @@
     {
         // Loop through the key
-        for (_long KeyOffset = 0; KeyOffset < KeyLength; KeyOffset++)
+        for (long KeyOffset = 0; KeyOffset < KeyLength; KeyOffset++)
         {
             // If were at end of data break and the the while loop should end as well.

ps/trunk/source/ps/Encryption.h

@@ -8 +8 @@
 advice using 128bit keys which you can define as such.
 
-_byte MyKey[16] = { _byte(0xAF), _byte(0x2B), _byte(0x80), _byte(0x7E),
-                    _byte(0x09), _byte(0x23), _byte(0xCC), _byte(0x95),
-                    _byte(0xB4), _byte(0x2D), _byte(0xF4), _byte(0x90),
-                    _byte(0xB3), _byte(0xC4), _byte(0x2A), _byte(0x3B) };
+char MyKey[16] = { char(0xAF), char(0x2B), char(0x80), char(0x7E),
+                    char(0x09), char(0x23), char(0xCC), char(0x95),
+                    char(0xB4), char(0x2D), char(0xF4), char(0x90),
+                    char(0xB3), char(0xC4), char(0x2A), char(0x3B) };
 
 There may be a better way to do this but this looks alright to me.
@@ -23 +23 @@
 
 // Simple Encryption function
-_byte *EncryptData(_byte *Data, _long DataLength, _byte *Key, _long KeyLength);
+char *EncryptData(char *Data, long DataLength, char *Key, long KeyLength);
 
 // Simple Decryption function
-_byte *DecryptData(_byte *Data, _long DataLength, _byte *Key, _long KeyLength);
+char *DecryptData(char *Data, long DataLength, char *Key, long KeyLength);
 
 #endif

ps/trunk/source/ps/LogFile.cpp

@@ -53 +53 @@
 // 3rd parameter determines whether the error frame is shown.
 //-------------------------------------------------
-CLogFile::CLogFile(string FileName, string PageTitle, _bool WithFrame)
+CLogFile::CLogFile(string FileName, string PageTitle, bool WithFrame)
 {
     
@@ -105 +105 @@
 //Opens an error file. If WithFrame is true then it constructs a framed page.
 //-------------------------------------------------
-PS_RESULT CLogFile::Open(string FileName, string PageTitle, _bool WithFrame)
+PS_RESULT CLogFile::Open(string FileName, string PageTitle, bool WithFrame)
 {
     if(m_IsFileOpen)

ps/trunk/source/ps/LogFile.h

@@ -70 +70 @@
 public:
 
-    PS_DISPLAY_SETTINGS(_int Line, _char *File, _char *Date, PS_DISPLAY_MODE DisplayMode)
+    PS_DISPLAY_SETTINGS(int Line, char *File, char *Date, PS_DISPLAY_MODE DisplayMode)
     {
         line=Line;
@@ -78 +78 @@
     }
 
-    _int line;
-    _char *file;
-    _char *date;
+    int line;
+    char *file;
+    char *date;
     PS_DISPLAY_MODE displayMode;
 };
@@ -95 +95 @@
     CLogFile();
     ~CLogFile();
-    CLogFile(string FileName, string PageTitle, _bool WithFrame=false);
+    CLogFile(string FileName, string PageTitle, bool WithFrame=false);
     
     //Opens a file for output the 3rd parameter can be set to true to enable the error frame.
-    PS_RESULT Open(string FileName, string PageTitle, _bool WithFrame=false);
+    PS_RESULT Open(string FileName, string PageTitle, bool WithFrame=false);
 
     //Closes the file.
@@ -134 +134 @@
 
 private:
-    _bool m_IsFileOpen; //Is the file open.
-    _bool m_HasFrame; //Have frames been enabled.
+    bool m_IsFileOpen; //Is the file open.
+    bool m_HasFrame; //Have frames been enabled.
     ofstream m_TheFile; //The main file.
     ofstream m_ErrorFile; //The error link file, used only for frames.
     string m_CurrentColour; //The current colour.
     string m_FileName; //The name of the main file.
-    _int m_ErrNo; //The error number.
+    int m_ErrNo; //The error number.
 
     //Sets the current alignment of the text.

ps/trunk/source/ps/Parser.cpp

@@ -21 +21 @@
 bool CParserValue::func_name(type &ret)                 \
 {                                                       \
-    _double d;                                          \
+    double d;                                           \
     if (GetDouble(d))                                   \
         return ret = (type)d, true;                     \
@@ -43 +43 @@
 //-------------------------------------------------
 
-static bool _IsStrictNameChar(const _char& c);
-static bool _IsValueChar(const _char& c);
+static bool _IsStrictNameChar(const char& c);
+static bool _IsValueChar(const char& c);
 
 
@@ -51 +51 @@
 
 // Checks ident
-static bool _IsStrictNameChar(const _char& c)
+static bool _IsStrictNameChar(const char& c)
 {
     return ((c >= 'a' && c <= 'z') ||
@@ -59 +59 @@
 
 // Checks value
-static bool _IsValueChar(const _char& c)
+static bool _IsValueChar(const char& c)
 {
     return ((c >= 'a' && c <= 'z') ||
@@ -112 +112 @@
 
 // double
-bool CParserValue::GetDouble(_double &ret)
+bool CParserValue::GetDouble(double &ret)
 {
     // locals
-    _double         TempRet = 0.0;
+    double          TempRet = 0.0;
     int         Size = (int)m_String.size();
     int         i;
@@ -190 +190 @@
 // the function in the macro argument for CParserValue
 // They use GetDouble, and then type-cast it
-FUNC_IMPL_CAST_GETDOUBLE(GetFloat,          _float)
-FUNC_IMPL_CAST_GETDOUBLE(GetChar,           _char)
-FUNC_IMPL_CAST_GETDOUBLE(GetShort,          _short)
+FUNC_IMPL_CAST_GETDOUBLE(GetFloat,          float)
+FUNC_IMPL_CAST_GETDOUBLE(GetChar,           char)
+FUNC_IMPL_CAST_GETDOUBLE(GetShort,          short)
 FUNC_IMPL_CAST_GETDOUBLE(GetInt,            int)
-FUNC_IMPL_CAST_GETDOUBLE(GetLong,           _long)
-FUNC_IMPL_CAST_GETDOUBLE(GetUnsignedShort,  _ushort)
-FUNC_IMPL_CAST_GETDOUBLE(GetUnsignedInt,    _uint)
-FUNC_IMPL_CAST_GETDOUBLE(GetUnsignedLong,   _ulong)
+FUNC_IMPL_CAST_GETDOUBLE(GetLong,           long)
+FUNC_IMPL_CAST_GETDOUBLE(GetUnsignedShort,  unsigned short)
+FUNC_IMPL_CAST_GETDOUBLE(GetUnsignedInt,    unsigned int)
+FUNC_IMPL_CAST_GETDOUBLE(GetUnsignedLong,   unsigned long)
 
 // CParserTaskTypeNode
@@ -277 +277 @@
 FUNC_IMPL_GETARG(GetArgString,          GetString,          string)
 FUNC_IMPL_GETARG(GetArgBool,            GetBool,            bool)
-FUNC_IMPL_GETARG(GetArgChar,            GetChar,            _char)
-FUNC_IMPL_GETARG(GetArgShort,           GetShort,           _short)
+FUNC_IMPL_GETARG(GetArgChar,            GetChar,            char)
+FUNC_IMPL_GETARG(GetArgShort,           GetShort,           short)
 FUNC_IMPL_GETARG(GetArgInt,             GetInt,             int)
-FUNC_IMPL_GETARG(GetArgLong,            GetLong,            _long)
-FUNC_IMPL_GETARG(GetArgUnsignedShort,   GetUnsignedShort,   _ushort)
-FUNC_IMPL_GETARG(GetArgUnsignedInt,     GetUnsignedInt,     _uint)
-FUNC_IMPL_GETARG(GetArgUnsignedLong,    GetUnsignedLong,    _ulong)
-FUNC_IMPL_GETARG(GetArgFloat,           GetFloat,           _float)
-FUNC_IMPL_GETARG(GetArgDouble,          GetDouble,          _double)
+FUNC_IMPL_GETARG(GetArgLong,            GetLong,            long)
+FUNC_IMPL_GETARG(GetArgUnsignedShort,   GetUnsignedShort,   unsigned short)
+FUNC_IMPL_GETARG(GetArgUnsignedInt,     GetUnsignedInt,     unsigned int)
+FUNC_IMPL_GETARG(GetArgUnsignedLong,    GetUnsignedLong,    unsigned long)
+FUNC_IMPL_GETARG(GetArgFloat,           GetFloat,           float)
+FUNC_IMPL_GETARG(GetArgDouble,          GetDouble,          double)
 
 // ParseString
@@ -308 +308 @@
     bool                Extract=false;
     int             ExtractPos=0;
-    _char               Buffer[256];
-    _char               Letter[] = {'\0','\0'};     // Letter as string
+    char                Buffer[256];
+    char                Letter[] = {'\0','\0'};     // Letter as string
     vector<string>      Segments;
     string              strSub;
@@ -339 +339 @@
                 Extract = true;
                 ExtractPos = i;
-                memset((void*)Buffer, '\0', sizeof(_char)*256);
+                memset((void*)Buffer, '\0', sizeof(char)*256);
             }
             else
@@ -827 +827 @@
                 Extract = true;
                 ExtractPos = i+1; // Skip $
-                memset((void*)Buffer, '\0', sizeof(_char)*REGULAR_MAX_LENGTH);
+                memset((void*)Buffer, '\0', sizeof(char)*REGULAR_MAX_LENGTH);
 
                 // We don't want to extract '$' so we'll just continue to next loop run

ps/trunk/source/ps/Parser.h

@@ -76 +76 @@
 
     // return is error status
-    _bool GetString(std::string &ret);
-    _bool GetBool(_bool &ret);
-    _bool GetChar(_char &ret);  // As number! otherwise use GetString make sure size=1
-    _bool GetShort(_short &ret);
-    _bool GetInt(_int &ret);
-    _bool GetLong(_long &ret);
-    _bool GetUnsignedShort(_ushort &ret);
-    _bool GetUnsignedInt(_uint &ret);
-    _bool GetUnsignedLong(_ulong &ret);
-    _bool GetFloat(float &ret);
-    _bool GetDouble(double &ret);
+    bool GetString(std::string &ret);
+    bool GetBool(bool &ret);
+    bool GetChar(char &ret);    // As number! otherwise use GetString make sure size=1
+    bool GetShort(short &ret);
+    bool GetInt(int &ret);
+    bool GetLong(long &ret);
+    bool GetUnsignedShort(unsigned short &ret);
+    bool GetUnsignedInt(unsigned int &ret);
+    bool GetUnsignedLong(unsigned long &ret);
+    bool GetFloat(float &ret);
+    bool GetDouble(double &ret);
 
     // Memory regardless if it's an int, real, string or whatever
@@ -117 +117 @@
     // Either the node is a letter or a type, if m_Leter is '\0'
     //  then check m_Type what it is
-    _char                           m_Letter;
+    char                            m_Letter;
     _ParserValueType                m_Type;
     std::string                     m_String;   // Used for diverse storage
@@ -130 +130 @@
     // true means AltNode can be looped <...>
     // false means AltNode is just an optional part [...]
-    _bool                           m_AltNodeRepeatable;
+    bool                            m_AltNodeRepeatable;
 
     // Whenever a dynamic argument is used, it's first node is stored in this
@@ -171 +171 @@
 
     std::deque<CParserValue>            m_Arguments;
-    _bool                           m_ParseOK;      // same as ParseString will return
+    bool                            m_ParseOK;      // same as ParseString will return
     std::string                     m_TaskTypeName; // Name of the task type found
 
 protected:
-    _bool ClearArguments();
+    bool ClearArguments();
 
 public:
     // Interface
-    _bool ParseString(const CParser& parser, std::string line);
+    bool ParseString(const CParser& parser, std::string line);
 
     // Methods for getting arguments
     //  it returns success
-    _bool GetArgString          (const _int& arg, std::string &ret);
-    _bool GetArgBool                (const _int& arg, _bool &ret);
-    _bool GetArgChar                (const _int& arg, _char &ret);
-    _bool GetArgShort           (const _int& arg, _short &ret);
-    _bool GetArgInt             (const _int& arg, _int &ret);
-    _bool GetArgLong                (const _int& arg, _long &ret);
-    _bool GetArgUnsignedShort   (const _int& arg, _ushort &ret);
-    _bool GetArgUnsignedInt     (const _int& arg, _uint &ret);
-    _bool GetArgUnsignedLong        (const _int& arg, _ulong &ret);
-    _bool GetArgFloat           (const _int& arg, float &ret);
-    _bool GetArgDouble          (const _int& arg, double &ret);
+    bool GetArgString           (const int& arg, std::string &ret);
+    bool GetArgBool             (const int& arg, bool &ret);
+    bool GetArgChar             (const int& arg, char &ret);
+    bool GetArgShort            (const int& arg, short &ret);
+    bool GetArgInt              (const int& arg, int &ret);
+    bool GetArgLong             (const int& arg, long &ret);
+    bool GetArgUnsignedShort    (const int& arg, unsigned short &ret);
+    bool GetArgUnsignedInt      (const int& arg, unsigned int &ret);
+    bool GetArgUnsignedLong     (const int& arg, unsigned long &ret);
+    bool GetArgFloat            (const int& arg, float &ret);
+    bool GetArgDouble           (const int& arg, double &ret);
 
     // Get Argument count
@@ -211 +211 @@
 
     // Interface
-    _bool InputTaskType(const std::string& strName, const std::string& strSyntax);
+    bool InputTaskType(const std::string& strName, const std::string& strSyntax);
 };
 

ps/trunk/source/ps/Prometheus.cpp

@@ -3 +3 @@
 // Globals
 int g_xres = 800, g_yres = 600;
+int g_bpp  = 32;
+int g_freq = 60;
 
 DEFINE_ERROR(PS_OK, "OK");

ps/trunk/source/ps/Prometheus.h

@@ -10 +10 @@
 #define PROMETHEUS_H
 
-#pragma warning (disable : 4786)    // VC6 template warning spew
-#pragma warning (disable : 4291)
 
 #include <stdio.h>
@@ -20 +18 @@
 // Globals
 extern int g_xres, g_yres;
+extern int g_bpp;
+extern int g_freq;
 
-
-// Standard typedefs
-
-typedef int            _int;
-typedef unsigned int   _unsigned_int;
-
-typedef long           _long;
-typedef unsigned long  _unsigned_long;
-
-typedef bool           _bool;
-
-typedef char           _char;
-typedef unsigned char  _unsigned_char;
-
-typedef char           _byte;
-typedef unsigned char  _unsigned_byte;
-
-typedef float          _float;
-typedef double         _double;
-
-typedef unsigned short _unsigned_short;
-typedef unsigned short _ushort;
-typedef short _short;
-typedef unsigned long _ulong;
-typedef unsigned int _uint;
 
 // Error handling