[BACK]Return to math.C CVS log [TXT] [DIR] Up to [parser3project] / parser3 / src / classes

Diff for /parser3/src/classes/math.C between versions 1.45 and 1.49

version 1.45, 2007/04/23 10:30:09 version 1.49, 2007/07/06 15:06:28
Line 196  static void math1(Request& r, MethodPara Line 196  static void math1(Request& r, MethodPara
 MATH1(round);   MATH1(floor);   MATH1P(ceiling, ceil);  MATH1(round);   MATH1(floor);   MATH1P(ceiling, ceil);
 MATH1(trunc);   MATH1(frac);  MATH1(trunc);   MATH1(frac);
 MATH1P(abs, fabs);      MATH1(sign);  MATH1P(abs, fabs);      MATH1(sign);
 MATH1(exp);     MATH1(log);       MATH1(exp);     
   MATH1(log);     MATH1(log10);
 MATH1(sin);     MATH1(asin);      MATH1(sin);     MATH1(asin);    
 MATH1(cos);     MATH1(acos);      MATH1(cos);     MATH1(acos);    
 MATH1(tan);     MATH1(atan);  MATH1(tan);     MATH1(atan);
Line 293  static void _md5(Request& r, MethodParam Line 294  static void _md5(Request& r, MethodParam
         r.write_pass_lang(*new String(hex_string(digest, sizeof(digest), false)));          r.write_pass_lang(*new String(hex_string(digest, sizeof(digest), false)));
 }  }
   
   
   //SHA-1:
   
   struct SHA1Context
       {
       unsigned Message_Digest[5], Length_Low, Length_High;
       unsigned char Message_Block[64];
       int Message_Block_Index, Computed, Corrupted;
       };
   
   #define SHA1CircularShift(bits,word) ((((word) << (bits)) & 0xFFFFFFFF)|((word) >> (32-(bits))))
   void SHA1ProcessMessageBlock(SHA1Context *);
   void SHA1PadMessage(SHA1Context *);
   void SHA1Reset(SHA1Context *context)
       {
       context->Length_Low = context->Length_High = context->Message_Block_Index = 0;
       context->Message_Digest[0]      = 0x67452301;
       context->Message_Digest[1]      = 0xEFCDAB89;
       context->Message_Digest[2]      = 0x98BADCFE;
       context->Message_Digest[3]      = 0x10325476;
       context->Message_Digest[4]      = 0xC3D2E1F0;
       context->Computed = context->Corrupted  = 0;
       }
   
   int SHA1Result(SHA1Context *context)
       {
       if (context->Corrupted)
           return 0;
       if (!context->Computed)
           {
           SHA1PadMessage(context);
           context->Computed = 1;
           }
       return 1;
       }
   
   void SHA1Input (SHA1Context *context, const unsigned char *message_array, unsigned length)
       {
       if (!length)
           return;
       if (context->Computed || context->Corrupted)
           {
           context->Corrupted = 1;
           return;
           }
   
       while(length-- && !context->Corrupted)
           {
           context->Message_Block[context->Message_Block_Index++] = (*message_array & 0xFF);
           context->Length_Low += 8;
           context->Length_Low &= 0xFFFFFFFF;
           if (!context->Length_Low && !(context->Length_High=((1+context->Length_High)&0xFFFFFFFF)))
               context->Corrupted = 1; // too long message
           if (context->Message_Block_Index == 64)
               SHA1ProcessMessageBlock(context);
           message_array++;
           }
       }
   
   void SHA1ProcessMessageBlock(SHA1Context *context)
       {
       const unsigned K[] = {0x5A827999, 0x6ED9EBA1, 0x8F1BBCDC, 0xCA62C1D6 };
       int t;
       unsigned    temp, W[80], buf[5];
       unsigned &A=buf[0], &B=buf[1], &C=buf[2], &D=buf[3], &E=buf[4];
       for(t = 0; t < 16; t++)
           W[t] = (((unsigned) context->Message_Block[t * 4]) << 24) | (((unsigned) context->Message_Block[t * 4 + 1]) << 16) | (((unsigned) context->Message_Block[t * 4 + 2]) << 8) | ((unsigned) context->Message_Block[t * 4 + 3]);
       for(t = 16; t < 80; t++)
           W[t] = SHA1CircularShift(1,W[t-3] ^ W[t-8] ^ W[t-14] ^ W[t-16]);
   
       memcpy (buf, context->Message_Digest, sizeof(buf));
       for(t = 0; t < 20; t++)
           {
           temp =  (SHA1CircularShift(5,A) + ((B & C) | ((~B) & D)) + E + W[t] + K[0]) & 0xFFFFFFFF;
           E = D; D = C;
           C = SHA1CircularShift(30,B);
           B = A; A = temp;
           }
   
       for(t = 20; t < 40; t++)
           {
           temp = (SHA1CircularShift(5,A) + (B ^ C ^ D) + E + W[t] + K[1]) & 0xFFFFFFFF;
           E = D; D = C;
           C = SHA1CircularShift(30,B);
           B = A; A = temp;
           }
   
       for(t = 40; t < 60; t++)
           {
           temp = (SHA1CircularShift(5,A) + ((B & C) | (B & D) | (C & D)) + E + W[t] + K[2]) & 0xFFFFFFFF;
           E = D; D = C;
           C = SHA1CircularShift(30,B);
           B = A; A = temp;
           }
   
       for(t = 60; t < 80; t++)
           {
           temp = (SHA1CircularShift(5,A) + (B ^ C ^ D) + E + W[t] + K[3]) & 0xFFFFFFFF;
           E = D; D = C;
           C = SHA1CircularShift(30,B);
           B = A; A = temp;
           }
   
       for (t = 0; t < 5; t++)
           context->Message_Digest[t] = (context->Message_Digest[t] + buf[t]) & 0xFFFFFFFF;
       context->Message_Block_Index = 0;
       }
   
   void SHA1PadMessage(SHA1Context *context)
       {
       context->Message_Block[context->Message_Block_Index++] = 0x80;
       if (context->Message_Block_Index > 56) //was 55, one shift
           {
           while(context->Message_Block_Index < 64)
               context->Message_Block[context->Message_Block_Index++] = 0;
           SHA1ProcessMessageBlock(context);
           while(context->Message_Block_Index < 56)
               context->Message_Block[context->Message_Block_Index++] = 0;
           }
       else
           while(context->Message_Block_Index < 56)
               context->Message_Block[context->Message_Block_Index++] = 0;
       context->Message_Block[56] = (context->Length_High >> 24) & 0xFF;
       context->Message_Block[57] = (context->Length_High >> 16) & 0xFF;
       context->Message_Block[58] = (context->Length_High >> 8) & 0xFF;
       context->Message_Block[59] = (context->Length_High) & 0xFF;
       context->Message_Block[60] = (context->Length_Low >> 24) & 0xFF;
       context->Message_Block[61] = (context->Length_Low >> 16) & 0xFF;
       context->Message_Block[62] = (context->Length_Low >> 8) & 0xFF;
       context->Message_Block[63] = (context->Length_Low) & 0xFF;
       SHA1ProcessMessageBlock(context);
       }
   
   
   static void _sha1(Request& r, MethodParams& params)
       {
       const char *string = params.as_string(0, "parameter must be string").cstr();
   
       SHA1Context c;
       SHA1Reset (&c);
       SHA1Input (&c, (const unsigned char*)string, strlen(string));
       if (!SHA1Result (&c))
           throw Exception ("parser.runtime", 0, "Cannot compute SHA1");
       
       char digest[128];
       sprintf(digest, "%08x%08x%08x%08x%08x", c.Message_Digest[0], c.Message_Digest[1], c.Message_Digest[2], c.Message_Digest[3], c.Message_Digest[4]);
       
       char *ret = new(PointerFreeGC) char[strlen(digest)+1];
       strcpy(ret, digest);
       r.write_pass_lang(*new String(ret, 0, false));
       }
   
   
 /// to hell with extra bytes on 64bit platforms  /// to hell with extra bytes on 64bit platforms
 struct uuid {  struct uuid {
         unsigned int   time_low;          unsigned int   time_low;
Line 349  static void _crc32(Request& r, MethodPar Line 503  static void _crc32(Request& r, MethodPar
         r.write_no_lang(*new VInt(pa_crc32(string, strlen(string))));          r.write_no_lang(*new VInt(pa_crc32(string, strlen(string))));
 }  }
   
   static void _long2ip(Request& r, MethodParams& params) {
           unsigned long l=(unsigned long)trunc(params.as_double(0, "parameter must be expression", r));
           static const int ip_cstr_bufsize=15+1+1;
           char* ip_cstr=new(PointerFreeGC) char[ip_cstr_bufsize];
   
           snprintf(ip_cstr, ip_cstr_bufsize, "%d.%d.%d.%d",
                                   (l>>24) & 0xFF,
                                   (l>>16) & 0xFF,
                                   (l>>8) & 0xFF,
                                   l & 0xFF);
   
           r.write_no_lang(*new String(ip_cstr));
   }
   
 // constructor  // constructor
   
 MMath::MMath(): Methoded("math") {  MMath::MMath(): Methoded("math") {
Line 362  MMath::MMath(): Methoded("math") { Line 530  MMath::MMath(): Methoded("math") {
         ADD1(round);    ADD1(floor);    ADD1(ceiling);          ADD1(round);    ADD1(floor);    ADD1(ceiling);
         ADD1(trunc);    ADD1(frac);          ADD1(trunc);    ADD1(frac);
         ADD1(abs);      ADD1(sign);          ADD1(abs);      ADD1(sign);
         ADD1(exp);      ADD1(log);                ADD1(exp);
           ADD1(log);      ADD1(log10);
         ADD1(sin);      ADD1(asin);               ADD1(sin);      ADD1(asin);     
         ADD1(cos);      ADD1(acos);               ADD1(cos);      ADD1(acos);     
         ADD1(tan);      ADD1(atan);          ADD1(tan);      ADD1(atan);
Line 370  MMath::MMath(): Methoded("math") { Line 539  MMath::MMath(): Methoded("math") {
         ADD1(sqrt);          ADD1(sqrt);
         ADD1(random);          ADD1(random);
   
         // ^pow(x;y)          // ^math:pow(x;y)
         ADD2(pow);          ADD2(pow);
   
         // ^crypt[password;salt]          // ^math:crypt[password;salt]
         ADD2(crypt);          ADD2(crypt);
   
         // ^md5[string]          // ^math:md5[string]
         ADD1(md5);          ADD1(md5);
   
           // ^math:sha1[string]
           ADD1(sha1);
           
           // ^math:crc32[string]
         ADD1(crc32);          ADD1(crc32);
   
         // ^uuid[]          ADD1(long2ip);
   
           // ^math:uuid[]
         ADD0(uuid);          ADD0(uuid);
   
         // ^uid64[]          // ^math:uid64[]
         ADD0(uid64);          ADD0(uid64);
 }  }
Removed from v.1.45  
changed lines
  Added in v.1.49

E-mail: