From ec05778d5718a7912e506764d443a78d6a6179e3 Mon Sep 17 00:00:00 2001 From: Mike Buland Date: Mon, 5 Nov 2012 22:41:51 +0000 Subject: Converted tabs to spaces with tabconv. --- src/experimental/blowfish.h | 874 ++++++++++++++++++------------------ src/experimental/cache.h | 828 +++++++++++++++++----------------- src/experimental/cachecalc.h | 88 ++-- src/experimental/cachestore.h | 52 +-- src/experimental/cachestorefiles.h | 358 +++++++-------- src/experimental/cachestoremyriad.h | 270 +++++------ src/experimental/cipher.h | 218 ++++----- src/experimental/ciphermodecbc.h | 86 ++-- src/experimental/ciphermodecfb.h | 84 ++-- src/experimental/ciphermodeecb.h | 44 +- src/experimental/ciphermodeofb.h | 90 ++-- src/experimental/dir.h | 16 +- src/experimental/fastcgi.cpp | 592 ++++++++++++------------ src/experimental/fastcgi.h | 224 ++++----- src/experimental/filesystem.h | 30 +- src/experimental/httpget.cpp | 48 +- src/experimental/httpget.h | 72 +-- src/experimental/lexer.cpp | 16 +- src/experimental/lexer.h | 82 ++-- src/experimental/parser.cpp | 342 +++++++------- src/experimental/parser.h | 218 ++++----- src/experimental/regex.cpp | 94 ++-- src/experimental/regex.h | 46 +- src/experimental/regexengine.h | 260 +++++------ src/experimental/xmlreader.cpp | 250 +++++------ src/experimental/xmlreader.h | 76 ++-- 26 files changed, 2679 insertions(+), 2679 deletions(-) (limited to 'src/experimental') diff --git a/src/experimental/blowfish.h b/src/experimental/blowfish.h index 0308026..b287bd4 100644 --- a/src/experimental/blowfish.h +++ b/src/experimental/blowfish.h @@ -23,454 +23,454 @@ #define MAX_STRING 256 #define MAX_PASSWD 56 // 448bits #define F(x) \ - (((SB[0][x.byte.zero] + SB[1][x.byte.one]) ^ SB[2][x.byte.two]) + \ - SB[3][x.byte.three]) + (((SB[0][x.byte.zero] + SB[1][x.byte.one]) ^ SB[2][x.byte.two]) + \ + SB[3][x.byte.three]) #define revBytes( x ) x = (((x&0xff)<<24)|((x&0xff00)<<8)|((x&0xff0000)>>8)|((x&0xff000000)>>24)) namespace Bu { - template - class Blowfish : public Bu::Cipher<8> - { - public: - Blowfish( Bu::Stream &rNext ) : - Bu::Cipher<8>( rNext ) - { - } - - virtual ~Blowfish() - { - stop(); - reset(); - } - - void setPassword( const Bu::String &sPass ) - { - reset(); - - uint32_t i,j,len=sPass.getSize(); - Word Work,null0,null1; - - if (len > 0) - { - j = 0; - for (i=0;i + class Blowfish : public Bu::Cipher<8> + { + public: + Blowfish( Bu::Stream &rNext ) : + Bu::Cipher<8>( rNext ) + { + } + + virtual ~Blowfish() + { + stop(); + reset(); + } + + void setPassword( const Bu::String &sPass ) + { + reset(); + + uint32_t i,j,len=sPass.getSize(); + Word Work,null0,null1; + + if (len > 0) + { + j = 0; + for (i=0;iword0, &w2 = dwWork->word1; - - w1.word = be32toh( w1.word ); - w2.word = be32toh( w2.word ); - - keyEncipher( w1, w2 ); - - revBytes( w1.word ); - revBytes( w2.word ); - } - - virtual void decipher( void *pData ) - { - DWord *dwWork = (DWord *)pData; - Word &w1 = dwWork->word0, &w2 = dwWork->word1; - - revBytes( w1.word ); - revBytes( w2.word ); - - w1.word ^= PA[17]; - w2.word ^= F(w1)^PA[16]; w1.word ^= F(w2)^PA[15]; - w2.word ^= F(w1)^PA[14]; w1.word ^= F(w2)^PA[13]; - w2.word ^= F(w1)^PA[12]; w1.word ^= F(w2)^PA[11]; - w2.word ^= F(w1)^PA[10]; w1.word ^= F(w2)^PA[9]; - w2.word ^= F(w1)^PA[8]; w1.word ^= F(w2)^PA[7]; - w2.word ^= F(w1)^PA[6]; w1.word ^= F(w2)^PA[5]; - w2.word ^= F(w1)^PA[4]; w1.word ^= F(w2)^PA[3]; - w2.word ^= F(w1)^PA[2]; w1.word ^= F(w2)^PA[1]; - w2.word ^= PA[0]; - - Bu::swap( w1, w2 ); - - w1.word = htobe32( w1.word ); - w2.word = htobe32( w2.word ); - } - - inline void keyEncipher( Word &w1, Word &w2 ) - { - w1.word ^= PA[0]; - w2.word ^= F(w1)^PA[1]; w1.word ^= F(w2)^PA[2]; - w2.word ^= F(w1)^PA[3]; w1.word ^= F(w2)^PA[4]; - w2.word ^= F(w1)^PA[5]; w1.word ^= F(w2)^PA[6]; - w2.word ^= F(w1)^PA[7]; w1.word ^= F(w2)^PA[8]; - w2.word ^= F(w1)^PA[9]; w1.word ^= F(w2)^PA[10]; - w2.word ^= F(w1)^PA[11]; w1.word ^= F(w2)^PA[12]; - w2.word ^= F(w1)^PA[13]; w1.word ^= F(w2)^PA[14]; - w2.word ^= F(w1)^PA[15]; w1.word ^= F(w2)^PA[16]; - w2.word ^= PA[17]; - - Bu::swap( w1, w2 ); - } - }; - - typedef CipherModeEcb<8, Blowfish<1> > BlowfishEcb; - typedef CipherModeCfb<8, Blowfish<1> > BlowfishCfb; - typedef CipherModeCbc<8, Blowfish<1> > BlowfishCbc; - typedef CipherModeOfb<8, Blowfish<1> > BlowfishOfb; + union Word + { + uint32_t word; + WordByte byte; + }; + + struct DWord + { + Word word0; + Word word1; + }; + + void reset() + { + uint32_t i,j; + + static uint32_t PA_Init[NUM_SUBKEYS] = + { + 0x243f6a88, 0x85a308d3, 0x13198a2e, 0x03707344, + 0xa4093822, 0x299f31d0, 0x082efa98, 0xec4e6c89, + 0x452821e6, 0x38d01377, 0xbe5466cf, 0x34e90c6c, + 0xc0ac29b7, 0xc97c50dd, 0x3f84d5b5, 0xb5470917, + 0x9216d5d9, 0x8979fb1b + }; + + static uint32_t SB_Init[NUM_S_BOXES][NUM_ENTRIES] = { + { + 0xd1310ba6, 0x98dfb5ac, 0x2ffd72db, 0xd01adfb7, + 0xb8e1afed, 0x6a267e96, 0xba7c9045, 0xf12c7f99, + 0x24a19947, 0xb3916cf7, 0x0801f2e2, 0x858efc16, + 0x636920d8, 0x71574e69, 0xa458fea3, 0xf4933d7e, + 0x0d95748f, 0x728eb658, 0x718bcd58, 0x82154aee, + 0x7b54a41d, 0xc25a59b5, 0x9c30d539, 0x2af26013, + 0xc5d1b023, 0x286085f0, 0xca417918, 0xb8db38ef, + 0x8e79dcb0, 0x603a180e, 0x6c9e0e8b, 0xb01e8a3e, + 0xd71577c1, 0xbd314b27, 0x78af2fda, 0x55605c60, + 0xe65525f3, 0xaa55ab94, 0x57489862, 0x63e81440, + 0x55ca396a, 0x2aab10b6, 0xb4cc5c34, 0x1141e8ce, + 0xa15486af, 0x7c72e993, 0xb3ee1411, 0x636fbc2a, + 0x2ba9c55d, 0x741831f6, 0xce5c3e16, 0x9b87931e, + 0xafd6ba33, 0x6c24cf5c, 0x7a325381, 0x28958677, + 0x3b8f4898, 0x6b4bb9af, 0xc4bfe81b, 0x66282193, + 0x61d809cc, 0xfb21a991, 0x487cac60, 0x5dec8032, + 0xef845d5d, 0xe98575b1, 0xdc262302, 0xeb651b88, + 0x23893e81, 0xd396acc5, 0x0f6d6ff3, 0x83f44239, + 0x2e0b4482, 0xa4842004, 0x69c8f04a, 0x9e1f9b5e, + 0x21c66842, 0xf6e96c9a, 0x670c9c61, 0xabd388f0, + 0x6a51a0d2, 0xd8542f68, 0x960fa728, 0xab5133a3, + 0x6eef0b6c, 0x137a3be4, 0xba3bf050, 0x7efb2a98, + 0xa1f1651d, 0x39af0176, 0x66ca593e, 0x82430e88, + 0x8cee8619, 0x456f9fb4, 0x7d84a5c3, 0x3b8b5ebe, + 0xe06f75d8, 0x85c12073, 0x401a449f, 0x56c16aa6, + 0x4ed3aa62, 0x363f7706, 0x1bfedf72, 0x429b023d, + 0x37d0d724, 0xd00a1248, 0xdb0fead3, 0x49f1c09b, + 0x075372c9, 0x80991b7b, 0x25d479d8, 0xf6e8def7, + 0xe3fe501a, 0xb6794c3b, 0x976ce0bd, 0x04c006ba, + 0xc1a94fb6, 0x409f60c4, 0x5e5c9ec2, 0x196a2463, + 0x68fb6faf, 0x3e6c53b5, 0x1339b2eb, 0x3b52ec6f, + 0x6dfc511f, 0x9b30952c, 0xcc814544, 0xaf5ebd09, + + 0xbee3d004, 0xde334afd, 0x660f2807, 0x192e4bb3, + 0xc0cba857, 0x45c8740f, 0xd20b5f39, 0xb9d3fbdb, + 0x5579c0bd, 0x1a60320a, 0xd6a100c6, 0x402c7279, + 0x679f25fe, 0xfb1fa3cc, 0x8ea5e9f8, 0xdb3222f8, + 0x3c7516df, 0xfd616b15, 0x2f501ec8, 0xad0552ab, + 0x323db5fa, 0xfd238760, 0x53317b48, 0x3e00df82, + 0x9e5c57bb, 0xca6f8ca0, 0x1a87562e, 0xdf1769db, + 0xd542a8f6, 0x287effc3, 0xac6732c6, 0x8c4f5573, + 0x695b27b0, 0xbbca58c8, 0xe1ffa35d, 0xb8f011a0, + 0x10fa3d98, 0xfd2183b8, 0x4afcb56c, 0x2dd1d35b, + 0x9a53e479, 0xb6f84565, 0xd28e49bc, 0x4bfb9790, + 0xe1ddf2da, 0xa4cb7e33, 0x62fb1341, 0xcee4c6e8, + 0xef20cada, 0x36774c01, 0xd07e9efe, 0x2bf11fb4, + 0x95dbda4d, 0xae909198, 0xeaad8e71, 0x6b93d5a0, + 0xd08ed1d0, 0xafc725e0, 0x8e3c5b2f, 0x8e7594b7, + 0x8ff6e2fb, 0xf2122b64, 0x8888b812, 0x900df01c, + 0x4fad5ea0, 0x688fc31c, 0xd1cff191, 0xb3a8c1ad, + 0x2f2f2218, 0xbe0e1777, 0xea752dfe, 0x8b021fa1, + 0xe5a0cc0f, 0xb56f74e8, 0x18acf3d6, 0xce89e299, + 0xb4a84fe0, 0xfd13e0b7, 0x7cc43b81, 0xd2ada8d9, + 0x165fa266, 0x80957705, 0x93cc7314, 0x211a1477, + 0xe6ad2065, 0x77b5fa86, 0xc75442f5, 0xfb9d35cf, + 0xebcdaf0c, 0x7b3e89a0, 0xd6411bd3, 0xae1e7e49, + 0x00250e2d, 0x2071b35e, 0x226800bb, 0x57b8e0af, + 0x2464369b, 0xf009b91e, 0x5563911d, 0x59dfa6aa, + 0x78c14389, 0xd95a537f, 0x207d5ba2, 0x02e5b9c5, + 0x83260376, 0x6295cfa9, 0x11c81968, 0x4e734a41, + 0xb3472dca, 0x7b14a94a, 0x1b510052, 0x9a532915, + 0xd60f573f, 0xbc9bc6e4, 0x2b60a476, 0x81e67400, + 0x08ba6fb5, 0x571be91f, 0xf296ec6b, 0x2a0dd915, + 0xb6636521, 0xe7b9f9b6, 0xff34052e, 0xc5855664, + 0x53b02d5d, 0xa99f8fa1, 0x08ba4799, 0x6e85076a + }, { + 0x4b7a70e9, 0xb5b32944, 0xdb75092e, 0xc4192623, + 0xad6ea6b0, 0x49a7df7d, 0x9cee60b8, 0x8fedb266, + 0xecaa8c71, 0x699a17ff, 0x5664526c, 0xc2b19ee1, + 0x193602a5, 0x75094c29, 0xa0591340, 0xe4183a3e, + 0x3f54989a, 0x5b429d65, 0x6b8fe4d6, 0x99f73fd6, + 0xa1d29c07, 0xefe830f5, 0x4d2d38e6, 0xf0255dc1, + 0x4cdd2086, 0x8470eb26, 0x6382e9c6, 0x021ecc5e, + 0x09686b3f, 0x3ebaefc9, 0x3c971814, 0x6b6a70a1, + 0x687f3584, 0x52a0e286, 0xb79c5305, 0xaa500737, + 0x3e07841c, 0x7fdeae5c, 0x8e7d44ec, 0x5716f2b8, + 0xb03ada37, 0xf0500c0d, 0xf01c1f04, 0x0200b3ff, + 0xae0cf51a, 0x3cb574b2, 0x25837a58, 0xdc0921bd, + 0xd19113f9, 0x7ca92ff6, 0x94324773, 0x22f54701, + 0x3ae5e581, 0x37c2dadc, 0xc8b57634, 0x9af3dda7, + 0xa9446146, 0x0fd0030e, 0xecc8c73e, 0xa4751e41, + 0xe238cd99, 0x3bea0e2f, 0x3280bba1, 0x183eb331, + 0x4e548b38, 0x4f6db908, 0x6f420d03, 0xf60a04bf, + 0x2cb81290, 0x24977c79, 0x5679b072, 0xbcaf89af, + 0xde9a771f, 0xd9930810, 0xb38bae12, 0xdccf3f2e, + 0x5512721f, 0x2e6b7124, 0x501adde6, 0x9f84cd87, + 0x7a584718, 0x7408da17, 0xbc9f9abc, 0xe94b7d8c, + 0xec7aec3a, 0xdb851dfa, 0x63094366, 0xc464c3d2, + 0xef1c1847, 0x3215d908, 0xdd433b37, 0x24c2ba16, + 0x12a14d43, 0x2a65c451, 0x50940002, 0x133ae4dd, + 0x71dff89e, 0x10314e55, 0x81ac77d6, 0x5f11199b, + 0x043556f1, 0xd7a3c76b, 0x3c11183b, 0x5924a509, + 0xf28fe6ed, 0x97f1fbfa, 0x9ebabf2c, 0x1e153c6e, + 0x86e34570, 0xeae96fb1, 0x860e5e0a, 0x5a3e2ab3, + 0x771fe71c, 0x4e3d06fa, 0x2965dcb9, 0x99e71d0f, + 0x803e89d6, 0x5266c825, 0x2e4cc978, 0x9c10b36a, + 0xc6150eba, 0x94e2ea78, 0xa5fc3c53, 0x1e0a2df4, + 0xf2f74ea7, 0x361d2b3d, 0x1939260f, 0x19c27960, + + 0x5223a708, 0xf71312b6, 0xebadfe6e, 0xeac31f66, + 0xe3bc4595, 0xa67bc883, 0xb17f37d1, 0x018cff28, + 0xc332ddef, 0xbe6c5aa5, 0x65582185, 0x68ab9802, + 0xeecea50f, 0xdb2f953b, 0x2aef7dad, 0x5b6e2f84, + 0x1521b628, 0x29076170, 0xecdd4775, 0x619f1510, + 0x13cca830, 0xeb61bd96, 0x0334fe1e, 0xaa0363cf, + 0xb5735c90, 0x4c70a239, 0xd59e9e0b, 0xcbaade14, + 0xeecc86bc, 0x60622ca7, 0x9cab5cab, 0xb2f3846e, + 0x648b1eaf, 0x19bdf0ca, 0xa02369b9, 0x655abb50, + 0x40685a32, 0x3c2ab4b3, 0x319ee9d5, 0xc021b8f7, + 0x9b540b19, 0x875fa099, 0x95f7997e, 0x623d7da8, + 0xf837889a, 0x97e32d77, 0x11ed935f, 0x16681281, + 0x0e358829, 0xc7e61fd6, 0x96dedfa1, 0x7858ba99, + 0x57f584a5, 0x1b227263, 0x9b83c3ff, 0x1ac24696, + 0xcdb30aeb, 0x532e3054, 0x8fd948e4, 0x6dbc3128, + 0x58ebf2ef, 0x34c6ffea, 0xfe28ed61, 0xee7c3c73, + 0x5d4a14d9, 0xe864b7e3, 0x42105d14, 0x203e13e0, + 0x45eee2b6, 0xa3aaabea, 0xdb6c4f15, 0xfacb4fd0, + 0xc742f442, 0xef6abbb5, 0x654f3b1d, 0x41cd2105, + 0xd81e799e, 0x86854dc7, 0xe44b476a, 0x3d816250, + 0xcf62a1f2, 0x5b8d2646, 0xfc8883a0, 0xc1c7b6a3, + 0x7f1524c3, 0x69cb7492, 0x47848a0b, 0x5692b285, + 0x095bbf00, 0xad19489d, 0x1462b174, 0x23820e00, + 0x58428d2a, 0x0c55f5ea, 0x1dadf43e, 0x233f7061, + 0x3372f092, 0x8d937e41, 0xd65fecf1, 0x6c223bdb, + 0x7cde3759, 0xcbee7460, 0x4085f2a7, 0xce77326e, + 0xa6078084, 0x19f8509e, 0xe8efd855, 0x61d99735, + 0xa969a7aa, 0xc50c06c2, 0x5a04abfc, 0x800bcadc, + 0x9e447a2e, 0xc3453484, 0xfdd56705, 0x0e1e9ec9, + 0xdb73dbd3, 0x105588cd, 0x675fda79, 0xe3674340, + 0xc5c43465, 0x713e38d8, 0x3d28f89e, 0xf16dff20, + 0x153e21e7, 0x8fb03d4a, 0xe6e39f2b, 0xdb83adf7 + }, { + 0xe93d5a68, 0x948140f7, 0xf64c261c, 0x94692934, + 0x411520f7, 0x7602d4f7, 0xbcf46b2e, 0xd4a20068, + 0xd4082471, 0x3320f46a, 0x43b7d4b7, 0x500061af, + 0x1e39f62e, 0x97244546, 0x14214f74, 0xbf8b8840, + 0x4d95fc1d, 0x96b591af, 0x70f4ddd3, 0x66a02f45, + 0xbfbc09ec, 0x03bd9785, 0x7fac6dd0, 0x31cb8504, + 0x96eb27b3, 0x55fd3941, 0xda2547e6, 0xabca0a9a, + 0x28507825, 0x530429f4, 0x0a2c86da, 0xe9b66dfb, + 0x68dc1462, 0xd7486900, 0x680ec0a4, 0x27a18dee, + 0x4f3ffea2, 0xe887ad8c, 0xb58ce006, 0x7af4d6b6, + 0xaace1e7c, 0xd3375fec, 0xce78a399, 0x406b2a42, + 0x20fe9e35, 0xd9f385b9, 0xee39d7ab, 0x3b124e8b, + 0x1dc9faf7, 0x4b6d1856, 0x26a36631, 0xeae397b2, + 0x3a6efa74, 0xdd5b4332, 0x6841e7f7, 0xca7820fb, + 0xfb0af54e, 0xd8feb397, 0x454056ac, 0xba489527, + 0x55533a3a, 0x20838d87, 0xfe6ba9b7, 0xd096954b, + 0x55a867bc, 0xa1159a58, 0xcca92963, 0x99e1db33, + 0xa62a4a56, 0x3f3125f9, 0x5ef47e1c, 0x9029317c, + 0xfdf8e802, 0x04272f70, 0x80bb155c, 0x05282ce3, + 0x95c11548, 0xe4c66d22, 0x48c1133f, 0xc70f86dc, + 0x07f9c9ee, 0x41041f0f, 0x404779a4, 0x5d886e17, + 0x325f51eb, 0xd59bc0d1, 0xf2bcc18f, 0x41113564, + 0x257b7834, 0x602a9c60, 0xdff8e8a3, 0x1f636c1b, + 0x0e12b4c2, 0x02e1329e, 0xaf664fd1, 0xcad18115, + 0x6b2395e0, 0x333e92e1, 0x3b240b62, 0xeebeb922, + 0x85b2a20e, 0xe6ba0d99, 0xde720c8c, 0x2da2f728, + 0xd0127845, 0x95b794fd, 0x647d0862, 0xe7ccf5f0, + 0x5449a36f, 0x877d48fa, 0xc39dfd27, 0xf33e8d1e, + 0x0a476341, 0x992eff74, 0x3a6f6eab, 0xf4f8fd37, + 0xa812dc60, 0xa1ebddf8, 0x991be14c, 0xdb6e6b0d, + 0xc67b5510, 0x6d672c37, 0x2765d43b, 0xdcd0e804, + 0xf1290dc7, 0xcc00ffa3, 0xb5390f92, 0x690fed0b, + + 0x667b9ffb, 0xcedb7d9c, 0xa091cf0b, 0xd9155ea3, + 0xbb132f88, 0x515bad24, 0x7b9479bf, 0x763bd6eb, + 0x37392eb3, 0xcc115979, 0x8026e297, 0xf42e312d, + 0x6842ada7, 0xc66a2b3b, 0x12754ccc, 0x782ef11c, + 0x6a124237, 0xb79251e7, 0x06a1bbe6, 0x4bfb6350, + 0x1a6b1018, 0x11caedfa, 0x3d25bdd8, 0xe2e1c3c9, + 0x44421659, 0x0a121386, 0xd90cec6e, 0xd5abea2a, + 0x64af674e, 0xda86a85f, 0xbebfe988, 0x64e4c3fe, + 0x9dbc8057, 0xf0f7c086, 0x60787bf8, 0x6003604d, + 0xd1fd8346, 0xf6381fb0, 0x7745ae04, 0xd736fccc, + 0x83426b33, 0xf01eab71, 0xb0804187, 0x3c005e5f, + 0x77a057be, 0xbde8ae24, 0x55464299, 0xbf582e61, + 0x4e58f48f, 0xf2ddfda2, 0xf474ef38, 0x8789bdc2, + 0x5366f9c3, 0xc8b38e74, 0xb475f255, 0x46fcd9b9, + 0x7aeb2661, 0x8b1ddf84, 0x846a0e79, 0x915f95e2, + 0x466e598e, 0x20b45770, 0x8cd55591, 0xc902de4c, + 0xb90bace1, 0xbb8205d0, 0x11a86248, 0x7574a99e, + 0xb77f19b6, 0xe0a9dc09, 0x662d09a1, 0xc4324633, + 0xe85a1f02, 0x09f0be8c, 0x4a99a025, 0x1d6efe10, + 0x1ab93d1d, 0x0ba5a4df, 0xa186f20f, 0x2868f169, + 0xdcb7da83, 0x573906fe, 0xa1e2ce9b, 0x4fcd7f52, + 0x50115e01, 0xa70683fa, 0xa002b5c4, 0x0de6d027, + 0x9af88c27, 0x773f8641, 0xc3604c06, 0x61a806b5, + 0xf0177a28, 0xc0f586e0, 0x006058aa, 0x30dc7d62, + 0x11e69ed7, 0x2338ea63, 0x53c2dd94, 0xc2c21634, + 0xbbcbee56, 0x90bcb6de, 0xebfc7da1, 0xce591d76, + 0x6f05e409, 0x4b7c0188, 0x39720a3d, 0x7c927c24, + 0x86e3725f, 0x724d9db9, 0x1ac15bb4, 0xd39eb8fc, + 0xed545578, 0x08fca5b5, 0xd83d7cd3, 0x4dad0fc4, + 0x1e50ef5e, 0xb161e6f8, 0xa28514d9, 0x6c51133c, + 0x6fd5c7e7, 0x56e14ec4, 0x362abfce, 0xddc6c837, + 0xd79a3234, 0x92638212, 0x670efa8e, 0x406000e0 + }, { + 0x3a39ce37, 0xd3faf5cf, 0xabc27737, 0x5ac52d1b, + 0x5cb0679e, 0x4fa33742, 0xd3822740, 0x99bc9bbe, + 0xd5118e9d, 0xbf0f7315, 0xd62d1c7e, 0xc700c47b, + 0xb78c1b6b, 0x21a19045, 0xb26eb1be, 0x6a366eb4, + 0x5748ab2f, 0xbc946e79, 0xc6a376d2, 0x6549c2c8, + 0x530ff8ee, 0x468dde7d, 0xd5730a1d, 0x4cd04dc6, + 0x2939bbdb, 0xa9ba4650, 0xac9526e8, 0xbe5ee304, + 0xa1fad5f0, 0x6a2d519a, 0x63ef8ce2, 0x9a86ee22, + 0xc089c2b8, 0x43242ef6, 0xa51e03aa, 0x9cf2d0a4, + 0x83c061ba, 0x9be96a4d, 0x8fe51550, 0xba645bd6, + 0x2826a2f9, 0xa73a3ae1, 0x4ba99586, 0xef5562e9, + 0xc72fefd3, 0xf752f7da, 0x3f046f69, 0x77fa0a59, + 0x80e4a915, 0x87b08601, 0x9b09e6ad, 0x3b3ee593, + 0xe990fd5a, 0x9e34d797, 0x2cf0b7d9, 0x022b8b51, + 0x96d5ac3a, 0x017da67d, 0xd1cf3ed6, 0x7c7d2d28, + 0x1f9f25cf, 0xadf2b89b, 0x5ad6b472, 0x5a88f54c, + 0xe029ac71, 0xe019a5e6, 0x47b0acfd, 0xed93fa9b, + 0xe8d3c48d, 0x283b57cc, 0xf8d56629, 0x79132e28, + 0x785f0191, 0xed756055, 0xf7960e44, 0xe3d35e8c, + 0x15056dd4, 0x88f46dba, 0x03a16125, 0x0564f0bd, + 0xc3eb9e15, 0x3c9057a2, 0x97271aec, 0xa93a072a, + 0x1b3f6d9b, 0x1e6321f5, 0xf59c66fb, 0x26dcf319, + 0x7533d928, 0xb155fdf5, 0x03563482, 0x8aba3cbb, + 0x28517711, 0xc20ad9f8, 0xabcc5167, 0xccad925f, + 0x4de81751, 0x3830dc8e, 0x379d5862, 0x9320f991, + 0xea7a90c2, 0xfb3e7bce, 0x5121ce64, 0x774fbe32, + 0xa8b6e37e, 0xc3293d46, 0x48de5369, 0x6413e680, + 0xa2ae0810, 0xdd6db224, 0x69852dfd, 0x09072166, + 0xb39a460a, 0x6445c0dd, 0x586cdecf, 0x1c20c8ae, + 0x5bbef7dd, 0x1b588d40, 0xccd2017f, 0x6bb4e3bb, + 0xdda26a7e, 0x3a59ff45, 0x3e350a44, 0xbcb4cdd5, + 0x72eacea8, 0xfa6484bb, 0x8d6612ae, 0xbf3c6f47, + + 0xd29be463, 0x542f5d9e, 0xaec2771b, 0xf64e6370, + 0x740e0d8d, 0xe75b1357, 0xf8721671, 0xaf537d5d, + 0x4040cb08, 0x4eb4e2cc, 0x34d2466a, 0x0115af84, + 0xe1b00428, 0x95983a1d, 0x06b89fb4, 0xce6ea048, + 0x6f3f3b82, 0x3520ab82, 0x011a1d4b, 0x277227f8, + 0x611560b1, 0xe7933fdc, 0xbb3a792b, 0x344525bd, + 0xa08839e1, 0x51ce794b, 0x2f32c9b7, 0xa01fbac9, + 0xe01cc87e, 0xbcc7d1f6, 0xcf0111c3, 0xa1e8aac7, + 0x1a908749, 0xd44fbd9a, 0xd0dadecb, 0xd50ada38, + 0x0339c32a, 0xc6913667, 0x8df9317c, 0xe0b12b4f, + 0xf79e59b7, 0x43f5bb3a, 0xf2d519ff, 0x27d9459c, + 0xbf97222c, 0x15e6fc2a, 0x0f91fc71, 0x9b941525, + 0xfae59361, 0xceb69ceb, 0xc2a86459, 0x12baa8d1, + 0xb6c1075e, 0xe3056a0c, 0x10d25065, 0xcb03a442, + 0xe0ec6e0e, 0x1698db3b, 0x4c98a0be, 0x3278e964, + 0x9f1f9532, 0xe0d392df, 0xd3a0342b, 0x8971f21e, + 0x1b0a7441, 0x4ba3348c, 0xc5be7120, 0xc37632d8, + 0xdf359f8d, 0x9b992f2e, 0xe60b6f47, 0x0fe3f11d, + 0xe54cda54, 0x1edad891, 0xce6279cf, 0xcd3e7e6f, + 0x1618b166, 0xfd2c1d05, 0x848fd2c5, 0xf6fb2299, + 0xf523f357, 0xa6327623, 0x93a83531, 0x56cccd02, + 0xacf08162, 0x5a75ebb5, 0x6e163697, 0x88d273cc, + 0xde966292, 0x81b949d0, 0x4c50901b, 0x71c65614, + 0xe6c6c7bd, 0x327a140a, 0x45e1d006, 0xc3f27b9a, + 0xc9aa53fd, 0x62a80f00, 0xbb25bfe2, 0x35bdd2f6, + 0x71126905, 0xb2040222, 0xb6cbcf7c, 0xcd769c2b, + 0x53113ec0, 0x1640e3d3, 0x38abbd60, 0x2547adf0, + 0xba38209c, 0xf746ce76, 0x77afa1c5, 0x20756060, + 0x85cbfe4e, 0x8ae88dd8, 0x7aaaf9b0, 0x4cf9aa7e, + 0x1948c25c, 0x02fb8a8c, 0x01c36ae4, 0xd6ebe1f9, + 0x90d4f869, 0xa65cdea0, 0x3f09252d, 0xc208e69f, + 0xb74e6132, 0xce77e25b, 0x578fdfe3, 0x3ac372e6 + } + }; + + for (i=0;iword0, &w2 = dwWork->word1; + + w1.word = be32toh( w1.word ); + w2.word = be32toh( w2.word ); + + keyEncipher( w1, w2 ); + + revBytes( w1.word ); + revBytes( w2.word ); + } + + virtual void decipher( void *pData ) + { + DWord *dwWork = (DWord *)pData; + Word &w1 = dwWork->word0, &w2 = dwWork->word1; + + revBytes( w1.word ); + revBytes( w2.word ); + + w1.word ^= PA[17]; + w2.word ^= F(w1)^PA[16]; w1.word ^= F(w2)^PA[15]; + w2.word ^= F(w1)^PA[14]; w1.word ^= F(w2)^PA[13]; + w2.word ^= F(w1)^PA[12]; w1.word ^= F(w2)^PA[11]; + w2.word ^= F(w1)^PA[10]; w1.word ^= F(w2)^PA[9]; + w2.word ^= F(w1)^PA[8]; w1.word ^= F(w2)^PA[7]; + w2.word ^= F(w1)^PA[6]; w1.word ^= F(w2)^PA[5]; + w2.word ^= F(w1)^PA[4]; w1.word ^= F(w2)^PA[3]; + w2.word ^= F(w1)^PA[2]; w1.word ^= F(w2)^PA[1]; + w2.word ^= PA[0]; + + Bu::swap( w1, w2 ); + + w1.word = htobe32( w1.word ); + w2.word = htobe32( w2.word ); + } + + inline void keyEncipher( Word &w1, Word &w2 ) + { + w1.word ^= PA[0]; + w2.word ^= F(w1)^PA[1]; w1.word ^= F(w2)^PA[2]; + w2.word ^= F(w1)^PA[3]; w1.word ^= F(w2)^PA[4]; + w2.word ^= F(w1)^PA[5]; w1.word ^= F(w2)^PA[6]; + w2.word ^= F(w1)^PA[7]; w1.word ^= F(w2)^PA[8]; + w2.word ^= F(w1)^PA[9]; w1.word ^= F(w2)^PA[10]; + w2.word ^= F(w1)^PA[11]; w1.word ^= F(w2)^PA[12]; + w2.word ^= F(w1)^PA[13]; w1.word ^= F(w2)^PA[14]; + w2.word ^= F(w1)^PA[15]; w1.word ^= F(w2)^PA[16]; + w2.word ^= PA[17]; + + Bu::swap( w1, w2 ); + } + }; + + typedef CipherModeEcb<8, Blowfish<1> > BlowfishEcb; + typedef CipherModeCfb<8, Blowfish<1> > BlowfishCfb; + typedef CipherModeCbc<8, Blowfish<1> > BlowfishCbc; + typedef CipherModeOfb<8, Blowfish<1> > BlowfishOfb; }; #endif diff --git a/src/experimental/cache.h b/src/experimental/cache.h index e3c8483..795d180 100644 --- a/src/experimental/cache.h +++ b/src/experimental/cache.h @@ -18,420 +18,420 @@ namespace Bu { -// template -// keytype __cacheGetKey( obtype *&pObj ); - template - keytype __cacheGetKey( const obtype *pObj ) - { - return pObj->getKey(); - } - - template - class Cache - { - public: - /** - * Cache Pointer - Provides access to data that is held within the - * cache. This provides safe, refcounting access to data stored in - * the cache, with support for lazy loading. - */ - class Ptr - { - friend class Bu::Cache; - private: - Ptr( Cache *pCache, obtype *pData, - const keytype &kId ) : - pCache( pCache ), - pData( pData ), - kId( kId ) - { - if( pCache ) - pCache->incRef( kId ); - } - - Ptr( Cache *pCache, const keytype &kId ) : - pCache( pCache ), - pData( NULL ), - kId( kId ) - { - } - - public: - Ptr( const Ptr &rSrc ) : - pCache( rSrc.pCache ), - pData( rSrc.pData ), - kId( rSrc.kId ) - { - if( pCache && pData ) - pCache->incRef( kId ); - } - - Ptr() : - pCache( 0 ), - pData( 0 ) - { - } - - virtual ~Ptr() - { - if( pCache && pData ) - pCache->decRef( kId ); - } - - obtype &operator*() - { - checkPtr(); - return *pData; - } - - const obtype &operator*() const - { - checkPtr(); - return *pData; - } - - obtype *operator->() - { - checkPtr(); - return pData; - } - - const obtype *operator->() const - { - checkPtr(); - return pData; - } - - bool isValid() const - { - return pCache != NULL; - } - - bool isBound() const - { - return pData != NULL; - } - - bool isSet() const - { - return pCache != NULL; - } - - const keytype &getKey() const - { - return kId; - } - - void unbind() - { - if( pCache && pData ) - pCache->decRef( kId ); - pData = NULL; - } - - void clear() - { - unbind(); - pCache = NULL; - } - - void unset() - { - clear(); - } - - Ptr &operator=( const Ptr &rRhs ) - { - if( pCache && pData ) - pCache->decRef( kId ); - pCache = rRhs.pCache; - pData = rRhs.pData; - kId = rRhs.kId; - if( pCache && pData ) - pCache->incRef( kId ); - return *this; - } - - bool operator==( const Ptr &rRhs ) const - { - return pCache == rRhs.pCache && kId == rRhs.kId; - } - - bool operator!=( const Ptr &rRhs ) const - { - return pCache != rRhs.pCache || kId != rRhs.kId; - } - - private: - void checkPtr() const - { - if( pCache && !pData ) - { - pData = pCache->getRaw( kId ); - pCache->incRef( kId ); - } - } - - private: - Bu::Cache *pCache; - mutable obtype *pData; - mutable keytype kId; - }; - - private: - typedef Bu::CacheStore Store; - typedef Bu::List StoreList; - typedef Bu::CacheCalc Calc; - - typedef struct CacheEntry - { - obtype *pData; - int iRefs; - time_t tLastSync; - } CacheEntry; - - typedef Bu::Hash CidHash; - - public: - typedef keytype Key; - Cache( Calc *pCalc, Store *pStore ) : - pCalc( pCalc ), - pStore( pStore ) - { - TRACE(); - pCalc->setCache( this ); - } - - virtual ~Cache() - { - TRACE(); - - // Better safe than sorry, better try a sync before anything - // else happens. - sync(); - - // Cycle through and unload all objects from the system. - for( typename CidHash::iterator i = hEnt.begin(); - i != hEnt.end(); i++ ) - { - if( i.getValue().iRefs > 0 ) - { - // TODO: Throw an error in this case? iRefs != 0 for an - // object when the Cache is destroyed. - throw Bu::ExceptionBase("iRefs not zero."); - } - pStore->unload( - i.getValue().pData, - i.getKey() - ); - } - delete pCalc; - delete pStore; - } - - Ptr insert( obtype *pData ) - { - TRACE( pData ); - if( pStore->has( __cacheGetKey( pData ) ) ) - throw Bu::ExceptionBase("Key already exists in cache."); - CacheEntry e = {pData, 0, 0}; - keytype k = pStore->create( pData ); - hEnt.insert( k, e ); - - pCalc->onLoad( pData, k ); - - pStore->sync(); - - return Ptr( this, pData, k ); - } - - bool has( const keytype &cId ) - { - return hEnt.has( cId ) || pStore->has( cId ); - } - - /** - * Retrieve an object from the cache and return a pointer to it. - * The object returned may be loaded from backend storage if needed, - * or the currently live object will be returned. - *@param cId The id of the object to load. - *@returns A pointer to the object. - */ - Ptr get( const keytype &cId ) - { - TRACE( cId ); - try { - return Ptr( this, hEnt.get( cId ).pData, cId ); - } - catch( Bu::HashException &e ) { - CacheEntry e = {pStore->load( cId ), 0, time( NULL )}; - pCalc->onLoad( e.pData, cId ); - hEnt.insert( cId, e ); - return Ptr( this, e.pData, cId ); - } - } - - /** - * Retrieve a handle to an object without loading it now. This function - * will return a pointer that has not yet been "realized" but can be - * used normally. Upon initial use in any way the object will be - * loaded from the cache, either linking against the already loaded - * object or loading it fresh from the backend storage. The advantage - * of this is that you recieve a usable handle to the data, but it - * does not count as a reference yet, meaning that the data is loaded - * when you need it, not before. - */ - Ptr getLazy( const keytype &cId ) - { - TRACE( cId ); - return Ptr( this, cId ); - } - - int getRefCount( const keytype &cId ) - { - TRACE( cId ); - return hEnt.get( cId ).iRefs; - } - - void unload( const keytype &cId ) - { - TRACE( cId ); - try { - if( hEnt.get( cId ).iRefs > 0 ) - { - printf("Shouldn't unload, references still exist!\n"); - return; - } - } - catch( Bu::HashException &e ) { - // It's not here? Eh, return. - return; - } - obtype *pObj = hEnt.get( cId ).pData; - pCalc->onUnload( pObj, cId ); - hEnt.erase( cId ); - - // The unload has to happen last just in case cId is a reference - // to data that is about to be deleted from memory by the unload. - pStore->unload( pObj, cId ); - } - - void erase( const keytype &cId ) - { - TRACE( cId ); - try { - if( hEnt.get( cId ).iRefs > 0 ) - { - printf("Shouldn't erase, references still exist!\n"); - return; - } - - obtype *pObj = hEnt.get( cId ).pData; - pCalc->onDestroy( pObj, cId ); - hEnt.erase( cId ); - - pStore->destroy( pObj, cId ); - pStore->sync(); - } - catch( Bu::HashException &e ) { - pCalc->onDestroy( cId ); - - if( hEnt.has( cId ) ) - { - // The object was loaded by onDestroy - erase( cId ); - } - else - { - pStore->destroy( cId ); - pStore->sync(); - } - } - } - - typedef Bu::List KeyList; - KeyList getKeys() - { - return pStore->getKeys(); - } - - KeyList getActiveKeys() - { - return hEnt.getKeys(); - } - - int getSize() - { - return pStore->getSize(); - } - - /** - * Make sure all currently loaded but not-in-use objects are synced to - * the store. - */ - void sync() - { - TRACE(); - int iSynced = 0; - for( typename CidHash::iterator i = hEnt.begin(); - i != hEnt.end(); i++ ) - { - if( i.getValue().iRefs == 0 ) - { - if( pCalc->shouldSync( - i.getValue().pData, - i.getKey(), - i.getValue().tLastSync - ) ) - { - pStore->sync( - i.getValue().pData, - i.getKey() - ); - iSynced++; - i.getValue().tLastSync = time( NULL ); - } - } - } - if( iSynced > 0 ) - { - pStore->sync(); - } - } - - private: - void incRef( const keytype &cId ) - { - TRACE( cId ); - hEnt.get( cId ).iRefs++; - } - - void decRef( const keytype &cId ) - { - TRACE( cId ); - CacheEntry &e = hEnt.get( cId ); - e.iRefs--; - } - - obtype *getRaw( const keytype &cId ) - { - TRACE( cId ); - try { - return hEnt.get( cId ).pData; - } - catch( Bu::HashException &e ) { - CacheEntry e = {pStore->load( cId ), 0, time( NULL )}; - pCalc->onLoad( e.pData, cId ); - hEnt.insert( cId, e ); - return e.pData; - } - } - - private: - CidHash hEnt; - Calc *pCalc; - Store *pStore; - }; +// template +// keytype __cacheGetKey( obtype *&pObj ); + template + keytype __cacheGetKey( const obtype *pObj ) + { + return pObj->getKey(); + } + + template + class Cache + { + public: + /** + * Cache Pointer - Provides access to data that is held within the + * cache. This provides safe, refcounting access to data stored in + * the cache, with support for lazy loading. + */ + class Ptr + { + friend class Bu::Cache; + private: + Ptr( Cache *pCache, obtype *pData, + const keytype &kId ) : + pCache( pCache ), + pData( pData ), + kId( kId ) + { + if( pCache ) + pCache->incRef( kId ); + } + + Ptr( Cache *pCache, const keytype &kId ) : + pCache( pCache ), + pData( NULL ), + kId( kId ) + { + } + + public: + Ptr( const Ptr &rSrc ) : + pCache( rSrc.pCache ), + pData( rSrc.pData ), + kId( rSrc.kId ) + { + if( pCache && pData ) + pCache->incRef( kId ); + } + + Ptr() : + pCache( 0 ), + pData( 0 ) + { + } + + virtual ~Ptr() + { + if( pCache && pData ) + pCache->decRef( kId ); + } + + obtype &operator*() + { + checkPtr(); + return *pData; + } + + const obtype &operator*() const + { + checkPtr(); + return *pData; + } + + obtype *operator->() + { + checkPtr(); + return pData; + } + + const obtype *operator->() const + { + checkPtr(); + return pData; + } + + bool isValid() const + { + return pCache != NULL; + } + + bool isBound() const + { + return pData != NULL; + } + + bool isSet() const + { + return pCache != NULL; + } + + const keytype &getKey() const + { + return kId; + } + + void unbind() + { + if( pCache && pData ) + pCache->decRef( kId ); + pData = NULL; + } + + void clear() + { + unbind(); + pCache = NULL; + } + + void unset() + { + clear(); + } + + Ptr &operator=( const Ptr &rRhs ) + { + if( pCache && pData ) + pCache->decRef( kId ); + pCache = rRhs.pCache; + pData = rRhs.pData; + kId = rRhs.kId; + if( pCache && pData ) + pCache->incRef( kId ); + return *this; + } + + bool operator==( const Ptr &rRhs ) const + { + return pCache == rRhs.pCache && kId == rRhs.kId; + } + + bool operator!=( const Ptr &rRhs ) const + { + return pCache != rRhs.pCache || kId != rRhs.kId; + } + + private: + void checkPtr() const + { + if( pCache && !pData ) + { + pData = pCache->getRaw( kId ); + pCache->incRef( kId ); + } + } + + private: + Bu::Cache *pCache; + mutable obtype *pData; + mutable keytype kId; + }; + + private: + typedef Bu::CacheStore Store; + typedef Bu::List StoreList; + typedef Bu::CacheCalc Calc; + + typedef struct CacheEntry + { + obtype *pData; + int iRefs; + time_t tLastSync; + } CacheEntry; + + typedef Bu::Hash CidHash; + + public: + typedef keytype Key; + Cache( Calc *pCalc, Store *pStore ) : + pCalc( pCalc ), + pStore( pStore ) + { + TRACE(); + pCalc->setCache( this ); + } + + virtual ~Cache() + { + TRACE(); + + // Better safe than sorry, better try a sync before anything + // else happens. + sync(); + + // Cycle through and unload all objects from the system. + for( typename CidHash::iterator i = hEnt.begin(); + i != hEnt.end(); i++ ) + { + if( i.getValue().iRefs > 0 ) + { + // TODO: Throw an error in this case? iRefs != 0 for an + // object when the Cache is destroyed. + throw Bu::ExceptionBase("iRefs not zero."); + } + pStore->unload( + i.getValue().pData, + i.getKey() + ); + } + delete pCalc; + delete pStore; + } + + Ptr insert( obtype *pData ) + { + TRACE( pData ); + if( pStore->has( __cacheGetKey( pData ) ) ) + throw Bu::ExceptionBase("Key already exists in cache."); + CacheEntry e = {pData, 0, 0}; + keytype k = pStore->create( pData ); + hEnt.insert( k, e ); + + pCalc->onLoad( pData, k ); + + pStore->sync(); + + return Ptr( this, pData, k ); + } + + bool has( const keytype &cId ) + { + return hEnt.has( cId ) || pStore->has( cId ); + } + + /** + * Retrieve an object from the cache and return a pointer to it. + * The object returned may be loaded from backend storage if needed, + * or the currently live object will be returned. + *@param cId The id of the object to load. + *@returns A pointer to the object. + */ + Ptr get( const keytype &cId ) + { + TRACE( cId ); + try { + return Ptr( this, hEnt.get( cId ).pData, cId ); + } + catch( Bu::HashException &e ) { + CacheEntry e = {pStore->load( cId ), 0, time( NULL )}; + pCalc->onLoad( e.pData, cId ); + hEnt.insert( cId, e ); + return Ptr( this, e.pData, cId ); + } + } + + /** + * Retrieve a handle to an object without loading it now. This function + * will return a pointer that has not yet been "realized" but can be + * used normally. Upon initial use in any way the object will be + * loaded from the cache, either linking against the already loaded + * object or loading it fresh from the backend storage. The advantage + * of this is that you recieve a usable handle to the data, but it + * does not count as a reference yet, meaning that the data is loaded + * when you need it, not before. + */ + Ptr getLazy( const keytype &cId ) + { + TRACE( cId ); + return Ptr( this, cId ); + } + + int getRefCount( const keytype &cId ) + { + TRACE( cId ); + return hEnt.get( cId ).iRefs; + } + + void unload( const keytype &cId ) + { + TRACE( cId ); + try { + if( hEnt.get( cId ).iRefs > 0 ) + { + printf("Shouldn't unload, references still exist!\n"); + return; + } + } + catch( Bu::HashException &e ) { + // It's not here? Eh, return. + return; + } + obtype *pObj = hEnt.get( cId ).pData; + pCalc->onUnload( pObj, cId ); + hEnt.erase( cId ); + + // The unload has to happen last just in case cId is a reference + // to data that is about to be deleted from memory by the unload. + pStore->unload( pObj, cId ); + } + + void erase( const keytype &cId ) + { + TRACE( cId ); + try { + if( hEnt.get( cId ).iRefs > 0 ) + { + printf("Shouldn't erase, references still exist!\n"); + return; + } + + obtype *pObj = hEnt.get( cId ).pData; + pCalc->onDestroy( pObj, cId ); + hEnt.erase( cId ); + + pStore->destroy( pObj, cId ); + pStore->sync(); + } + catch( Bu::HashException &e ) { + pCalc->onDestroy( cId ); + + if( hEnt.has( cId ) ) + { + // The object was loaded by onDestroy + erase( cId ); + } + else + { + pStore->destroy( cId ); + pStore->sync(); + } + } + } + + typedef Bu::List KeyList; + KeyList getKeys() + { + return pStore->getKeys(); + } + + KeyList getActiveKeys() + { + return hEnt.getKeys(); + } + + int getSize() + { + return pStore->getSize(); + } + + /** + * Make sure all currently loaded but not-in-use objects are synced to + * the store. + */ + void sync() + { + TRACE(); + int iSynced = 0; + for( typename CidHash::iterator i = hEnt.begin(); + i != hEnt.end(); i++ ) + { + if( i.getValue().iRefs == 0 ) + { + if( pCalc->shouldSync( + i.getValue().pData, + i.getKey(), + i.getValue().tLastSync + ) ) + { + pStore->sync( + i.getValue().pData, + i.getKey() + ); + iSynced++; + i.getValue().tLastSync = time( NULL ); + } + } + } + if( iSynced > 0 ) + { + pStore->sync(); + } + } + + private: + void incRef( const keytype &cId ) + { + TRACE( cId ); + hEnt.get( cId ).iRefs++; + } + + void decRef( const keytype &cId ) + { + TRACE( cId ); + CacheEntry &e = hEnt.get( cId ); + e.iRefs--; + } + + obtype *getRaw( const keytype &cId ) + { + TRACE( cId ); + try { + return hEnt.get( cId ).pData; + } + catch( Bu::HashException &e ) { + CacheEntry e = {pStore->load( cId ), 0, time( NULL )}; + pCalc->onLoad( e.pData, cId ); + hEnt.insert( cId, e ); + return e.pData; + } + } + + private: + CidHash hEnt; + Calc *pCalc; + Store *pStore; + }; }; #endif diff --git a/src/experimental/cachecalc.h b/src/experimental/cachecalc.h index ecfa3f4..cb5c755 100644 --- a/src/experimental/cachecalc.h +++ b/src/experimental/cachecalc.h @@ -14,50 +14,50 @@ namespace Bu { - template class Cache; - - template - class CacheCalc - { - friend class Cache; - private: - typedef Cache MyCache; - public: - CacheCalc() : - pCache( (MyCache *)0 ) - { - TRACE(); - } - - virtual ~CacheCalc() - { - TRACE(); - } - - virtual void onLoad( obtype *pSrc, const keytype &key )=0; - virtual void onUnload( obtype *pSrc, const keytype &key )=0; - virtual void onDestroy( obtype *pSrc, const keytype &key )=0; - virtual void onDestroy( const keytype &key )=0; - virtual bool shouldSync( obtype *pSrc, const keytype &key, - time_t tLastSync )=0; - virtual void onTick() { }; - - protected: - MyCache *getCache() - { - TRACE(); - return pCache; - } - - private: - void setCache( MyCache *pCache ) - { - TRACE(); - this->pCache = pCache; - } - - MyCache *pCache; - }; + template class Cache; + + template + class CacheCalc + { + friend class Cache; + private: + typedef Cache MyCache; + public: + CacheCalc() : + pCache( (MyCache *)0 ) + { + TRACE(); + } + + virtual ~CacheCalc() + { + TRACE(); + } + + virtual void onLoad( obtype *pSrc, const keytype &key )=0; + virtual void onUnload( obtype *pSrc, const keytype &key )=0; + virtual void onDestroy( obtype *pSrc, const keytype &key )=0; + virtual void onDestroy( const keytype &key )=0; + virtual bool shouldSync( obtype *pSrc, const keytype &key, + time_t tLastSync )=0; + virtual void onTick() { }; + + protected: + MyCache *getCache() + { + TRACE(); + return pCache; + } + + private: + void setCache( MyCache *pCache ) + { + TRACE(); + this->pCache = pCache; + } + + MyCache *pCache; + }; }; #endif diff --git a/src/experimental/cachestore.h b/src/experimental/cachestore.h index a332e49..5052670 100644 --- a/src/experimental/cachestore.h +++ b/src/experimental/cachestore.h @@ -12,35 +12,35 @@ namespace Bu { - /** - * Handles I/O for data in the cache. This also assigns ID's to the newly - * created objects that are requested through this system. - */ - template - class CacheStore - { - public: - CacheStore() - { - } + /** + * Handles I/O for data in the cache. This also assigns ID's to the newly + * created objects that are requested through this system. + */ + template + class CacheStore + { + public: + CacheStore() + { + } - virtual ~CacheStore() - { - } + virtual ~CacheStore() + { + } - virtual obtype *load( const keytype &key )=0; - virtual void unload( obtype *pObj, const keytype &key )=0; - virtual keytype create( obtype *pSrc )=0; - virtual void sync()=0; - virtual void sync( obtype *pObj, const keytype &key )=0; - virtual void destroy( obtype *pObj, const keytype &key )=0; - virtual void destroy( const keytype &key )=0; - virtual bool has( const keytype &key )=0; - virtual Bu::List getKeys() { return Bu::List(); } - virtual int getSize() { return -1; } + virtual obtype *load( const keytype &key )=0; + virtual void unload( obtype *pObj, const keytype &key )=0; + virtual keytype create( obtype *pSrc )=0; + virtual void sync()=0; + virtual void sync( obtype *pObj, const keytype &key )=0; + virtual void destroy( obtype *pObj, const keytype &key )=0; + virtual void destroy( const keytype &key )=0; + virtual bool has( const keytype &key )=0; + virtual Bu::List getKeys() { return Bu::List(); } + virtual int getSize() { return -1; } - private: - }; + private: + }; }; #endif diff --git a/src/experimental/cachestorefiles.h b/src/experimental/cachestorefiles.h index d3a6894..0805e7b 100644 --- a/src/experimental/cachestorefiles.h +++ b/src/experimental/cachestorefiles.h @@ -23,188 +23,188 @@ namespace Bu { - template - keytype __cacheGetKey( const obtype *pObj ); - - template - obtype *__cacheStoreFilesAlloc( const keytype &key ) - { - return new obtype(); - } - - template - void __cacheStoreFilesStore( Bu::Stream &s, obtype &rObj, - const keytype & ) - { - Bu::Archive ar( s, Bu::Archive::save ); - ar << rObj; - } - - template - obtype *__cacheStoreFilesLoad( Bu::Stream &s, const keytype &key ) - { - obtype *pObj = __cacheStoreFilesAlloc( key ); - Bu::Archive ar( s, Bu::Archive::load ); - ar >> (*pObj); - return pObj; - } - - template - class CacheStoreFiles : public CacheStore - { - public: - CacheStoreFiles( const Bu::String &sPrefix ) : - sPrefix( sPrefix ) - { - if( access( sPrefix.getStr(), W_OK|R_OK|X_OK ) ) - { + template + keytype __cacheGetKey( const obtype *pObj ); + + template + obtype *__cacheStoreFilesAlloc( const keytype &key ) + { + return new obtype(); + } + + template + void __cacheStoreFilesStore( Bu::Stream &s, obtype &rObj, + const keytype & ) + { + Bu::Archive ar( s, Bu::Archive::save ); + ar << rObj; + } + + template + obtype *__cacheStoreFilesLoad( Bu::Stream &s, const keytype &key ) + { + obtype *pObj = __cacheStoreFilesAlloc( key ); + Bu::Archive ar( s, Bu::Archive::load ); + ar >> (*pObj); + return pObj; + } + + template + class CacheStoreFiles : public CacheStore + { + public: + CacheStoreFiles( const Bu::String &sPrefix ) : + sPrefix( sPrefix ) + { + if( access( sPrefix.getStr(), W_OK|R_OK|X_OK ) ) + { #ifdef WIN32 - mkdir( sPrefix.getStr() ); + mkdir( sPrefix.getStr() ); #else - mkdir( sPrefix.getStr(), 0755 ); + mkdir( sPrefix.getStr(), 0755 ); #endif - } - } - - virtual ~CacheStoreFiles() - { - } - - virtual obtype *load( const keytype &key ) - { -// try -// { - Bu::MemBuf mb; - Bu::Formatter f( mb ); - f << sPrefix << "/" << key; - Bu::File fIn( mb.getString(), Bu::File::Read ); - obtype *pOb = __cacheStoreFilesLoad( fIn, key ); - return pOb; -// } -// catch( std::exception &e ) -// { -// throw Bu::HashException( e.what() ); -// } - } - - virtual void unload( obtype *pObj, const keytype & ) - { - delete pObj; - } - - virtual keytype create( obtype *pSrc ) - { - keytype key = __cacheGetKey( pSrc ); - Bu::MemBuf mb; - Bu::Formatter f( mb ); - f << sPrefix << "/" << key; - - Bu::File fTouch( mb.getString(), Bu::File::WriteNew ); - - return key; - } - - virtual void sync() - { - } - - virtual void sync( obtype *pSrc, const keytype &key ) - { - Bu::MemBuf mb; - Bu::Formatter f( mb ); - f << sPrefix << "/" << key; - - Bu::File fOut( mb.getString(), Bu::File::WriteNew ); - __cacheStoreFilesStore( fOut, *pSrc, key ); - } - - virtual void destroy( obtype *pObj, const keytype &key ) - { - Bu::MemBuf mb; - Bu::Formatter f( mb ); - f << sPrefix << "/" << key; - - unlink( mb.getString().getStr() ); - delete pObj; - } - - virtual void destroy( const keytype &key ) - { - Bu::MemBuf mb; - Bu::Formatter f( mb ); - f << sPrefix << "/" << key; - - unlink( mb.getString().getStr() ); - } - - virtual bool has( const keytype &key ) - { - Bu::MemBuf mb; - Bu::Formatter f( mb ); - f << sPrefix << "/"; - Bu::String sBase = mb.getString(); - f << key; - - if( sBase == mb.getString() ) - return false; - - return access( mb.getString().getStr(), F_OK ) == 0; - } - - virtual Bu::List getKeys() - { - DIR *dir = opendir( sPrefix.getStr() ); - struct dirent *de; - Bu::List lKeys; - - while( (de = readdir( dir ) ) ) - { - if( de->d_type != DT_REG ) - continue; - - keytype tmp; - Bu::MemBuf mb( de->d_name ); - Bu::Formatter f( mb ); - try - { - Fmt fm; - fm.tokenize( false ); - f << fm; - f >> tmp; - } - catch( Bu::ExceptionBase &e ) - { - Bu::sio << "Parse error in dir-scan: " << e.what() - << Bu::sio.nl; - } - lKeys.append( tmp ); - } - closedir( dir ); - - return lKeys; - } - - virtual int getSize() - { - DIR *dir = opendir( sPrefix.getStr() ); - struct dirent *de; - int iCount = 0; - - while( (de = readdir( dir ) ) ) - { - if( de->d_type != DT_REG ) - continue; - - iCount++; - } - closedir( dir ); - - return iCount; - } - - private: - Bu::String sPrefix; - }; + } + } + + virtual ~CacheStoreFiles() + { + } + + virtual obtype *load( const keytype &key ) + { +// try +// { + Bu::MemBuf mb; + Bu::Formatter f( mb ); + f << sPrefix << "/" << key; + Bu::File fIn( mb.getString(), Bu::File::Read ); + obtype *pOb = __cacheStoreFilesLoad( fIn, key ); + return pOb; +// } +// catch( std::exception &e ) +// { +// throw Bu::HashException( e.what() ); +// } + } + + virtual void unload( obtype *pObj, const keytype & ) + { + delete pObj; + } + + virtual keytype create( obtype *pSrc ) + { + keytype key = __cacheGetKey( pSrc ); + Bu::MemBuf mb; + Bu::Formatter f( mb ); + f << sPrefix << "/" << key; + + Bu::File fTouch( mb.getString(), Bu::File::WriteNew ); + + return key; + } + + virtual void sync() + { + } + + virtual void sync( obtype *pSrc, const keytype &key ) + { + Bu::MemBuf mb; + Bu::Formatter f( mb ); + f << sPrefix << "/" << key; + + Bu::File fOut( mb.getString(), Bu::File::WriteNew ); + __cacheStoreFilesStore( fOut, *pSrc, key ); + } + + virtual void destroy( obtype *pObj, const keytype &key ) + { + Bu::MemBuf mb; + Bu::Formatter f( mb ); + f << sPrefix << "/" << key; + + unlink( mb.getString().getStr() ); + delete pObj; + } + + virtual void destroy( const keytype &key ) + { + Bu::MemBuf mb; + Bu::Formatter f( mb ); + f << sPrefix << "/" << key; + + unlink( mb.getString().getStr() ); + } + + virtual bool has( const keytype &key ) + { + Bu::MemBuf mb; + Bu::Formatter f( mb ); + f << sPrefix << "/"; + Bu::String sBase = mb.getString(); + f << key; + + if( sBase == mb.getString() ) + return false; + + return access( mb.getString().getStr(), F_OK ) == 0; + } + + virtual Bu::List getKeys() + { + DIR *dir = opendir( sPrefix.getStr() ); + struct dirent *de; + Bu::List lKeys; + + while( (de = readdir( dir ) ) ) + { + if( de->d_type != DT_REG ) + continue; + + keytype tmp; + Bu::MemBuf mb( de->d_name ); + Bu::Formatter f( mb ); + try + { + Fmt fm; + fm.tokenize( false ); + f << fm; + f >> tmp; + } + catch( Bu::ExceptionBase &e ) + { + Bu::sio << "Parse error in dir-scan: " << e.what() + << Bu::sio.nl; + } + lKeys.append( tmp ); + } + closedir( dir ); + + return lKeys; + } + + virtual int getSize() + { + DIR *dir = opendir( sPrefix.getStr() ); + struct dirent *de; + int iCount = 0; + + while( (de = readdir( dir ) ) ) + { + if( de->d_type != DT_REG ) + continue; + + iCount++; + } + closedir( dir ); + + return iCount; + } + + private: + Bu::String sPrefix; + }; }; diff --git a/src/experimental/cachestoremyriad.h b/src/experimental/cachestoremyriad.h index 1953b61..01fe307 100644 --- a/src/experimental/cachestoremyriad.h +++ b/src/experimental/cachestoremyriad.h @@ -18,141 +18,141 @@ namespace Bu { - template - keytype __cacheGetKey( const obtype *pObj ); - - template - obtype *__cacheStoreMyriadAlloc( const keytype &key ) - { - return new obtype(); - } - - template - void __cacheStoreMyriadStore( Bu::Stream &s, obtype &rObj, - const keytype & ) - { - Bu::Archive ar( s, Bu::Archive::save ); - ar << rObj; - } - - template - obtype *__cacheStoreMyriadLoad( Bu::Stream &s, const keytype &key ) - { - obtype *pObj = __cacheStoreMyriadAlloc( key ); - Bu::Archive ar( s, Bu::Archive::load ); - ar >> (*pObj); - return pObj; - } - - template - class CacheStoreMyriad : public CacheStore - { - public: - CacheStoreMyriad( Bu::Stream &sArch, - int iBlockSize=512, int iPreAllocate=8 ) : - mStore( sArch, iBlockSize, iPreAllocate ) - { - try - { - MyriadStream ns = mStore.openStream( 1 ); - Bu::Archive ar( ns, Bu::Archive::load ); - ar >> hId; - } - catch( Bu::MyriadException &e ) - { - int iStream = mStore.createStream(); - if( iStream != 1 ) - throw Bu::ExceptionBase("That's...horrible...id = %d.\n\n", - iStream ); - MyriadStream ns = mStore.openStream( 1 ); - Bu::Archive ar( ns, Bu::Archive::save ); - ar << hId; - } - } - - virtual ~CacheStoreMyriad() - { - MyriadStream ns = mStore.openStream( 1 ); - Bu::Archive ar( ns, Bu::Archive::save ); - ar << hId; - } - - virtual obtype *load( const keytype &key ) - { - int iStream = hId.get( key ); - MyriadStream ns = mStore.openStream( iStream ); - obtype *pOb = __cacheStoreMyriadLoad( ns, key ); - return pOb; - } - - virtual void unload( obtype *pObj, const keytype & ) - { - delete pObj; - } - - virtual keytype create( obtype *pSrc ) - { - keytype key = __cacheGetKey( pSrc ); - int iStream = mStore.createStream(); - hId.insert( key, iStream ); - MyriadStream ns = mStore.openStream( iStream ); - __cacheStoreMyriadStore( ns, *pSrc, key ); - ns.setSize( ns.tell() ); - return key; - } - - virtual void sync() - { - MyriadStream ns = mStore.openStream( 1 ); - Bu::Archive ar( ns, Bu::Archive::save ); - ar << hId; - ns.setSize( ns.tell() ); - mStore.sync(); - } - - virtual void sync( obtype *pSrc, const keytype &key ) - { - int iStream = hId.get( key ); - MyriadStream ns = mStore.openStream( iStream ); - __cacheStoreMyriadStore( ns, *pSrc, key ); - ns.setSize( ns.tell() ); - } - - virtual void destroy( obtype *pObj, const keytype &key ) - { - int iStream = hId.get( key ); - mStore.deleteStream( iStream ); - hId.erase( key ); - delete pObj; - } - - virtual void destroy( const keytype &key ) - { - int iStream = hId.get( key ); - mStore.deleteStream( iStream ); - hId.erase( key ); - } - - virtual bool has( const keytype &key ) - { - return hId.has( key ); - } - - virtual Bu::List getKeys() - { - return hId.getKeys(); - } - - virtual int getSize() - { - return hId.getSize(); - } - - private: - Myriad mStore; - typedef Bu::Hash StreamHash; - StreamHash hId; - }; + template + keytype __cacheGetKey( const obtype *pObj ); + + template + obtype *__cacheStoreMyriadAlloc( const keytype &key ) + { + return new obtype(); + } + + template + void __cacheStoreMyriadStore( Bu::Stream &s, obtype &rObj, + const keytype & ) + { + Bu::Archive ar( s, Bu::Archive::save ); + ar << rObj; + } + + template + obtype *__cacheStoreMyriadLoad( Bu::Stream &s, const keytype &key ) + { + obtype *pObj = __cacheStoreMyriadAlloc( key ); + Bu::Archive ar( s, Bu::Archive::load ); + ar >> (*pObj); + return pObj; + } + + template + class CacheStoreMyriad : public CacheStore + { + public: + CacheStoreMyriad( Bu::Stream &sArch, + int iBlockSize=512, int iPreAllocate=8 ) : + mStore( sArch, iBlockSize, iPreAllocate ) + { + try + { + MyriadStream ns = mStore.openStream( 1 ); + Bu::Archive ar( ns, Bu::Archive::load ); + ar >> hId; + } + catch( Bu::MyriadException &e ) + { + int iStream = mStore.createStream(); + if( iStream != 1 ) + throw Bu::ExceptionBase("That's...horrible...id = %d.\n\n", + iStream ); + MyriadStream ns = mStore.openStream( 1 ); + Bu::Archive ar( ns, Bu::Archive::save ); + ar << hId; + } + } + + virtual ~CacheStoreMyriad() + { + MyriadStream ns = mStore.openStream( 1 ); + Bu::Archive ar( ns, Bu::Archive::save ); + ar << hId; + } + + virtual obtype *load( const keytype &key ) + { + int iStream = hId.get( key ); + MyriadStream ns = mStore.openStream( iStream ); + obtype *pOb = __cacheStoreMyriadLoad( ns, key ); + return pOb; + } + + virtual void unload( obtype *pObj, const keytype & ) + { + delete pObj; + } + + virtual keytype create( obtype *pSrc ) + { + keytype key = __cacheGetKey( pSrc ); + int iStream = mStore.createStream(); + hId.insert( key, iStream ); + MyriadStream ns = mStore.openStream( iStream ); + __cacheStoreMyriadStore( ns, *pSrc, key ); + ns.setSize( ns.tell() ); + return key; + } + + virtual void sync() + { + MyriadStream ns = mStore.openStream( 1 ); + Bu::Archive ar( ns, Bu::Archive::save ); + ar << hId; + ns.setSize( ns.tell() ); + mStore.sync(); + } + + virtual void sync( obtype *pSrc, const keytype &key ) + { + int iStream = hId.get( key ); + MyriadStream ns = mStore.openStream( iStream ); + __cacheStoreMyriadStore( ns, *pSrc, key ); + ns.setSize( ns.tell() ); + } + + virtual void destroy( obtype *pObj, const keytype &key ) + { + int iStream = hId.get( key ); + mStore.deleteStream( iStream ); + hId.erase( key ); + delete pObj; + } + + virtual void destroy( const keytype &key ) + { + int iStream = hId.get( key ); + mStore.deleteStream( iStream ); + hId.erase( key ); + } + + virtual bool has( const keytype &key ) + { + return hId.has( key ); + } + + virtual Bu::List getKeys() + { + return hId.getKeys(); + } + + virtual int getSize() + { + return hId.getSize(); + } + + private: + Myriad mStore; + typedef Bu::Hash StreamHash; + StreamHash hId; + }; }; #endif diff --git a/src/experimental/cipher.h b/src/experimental/cipher.h index 5d5cb07..6e58613 100644 --- a/src/experimental/cipher.h +++ b/src/experimental/cipher.h @@ -13,115 +13,115 @@ namespace Bu { - template - class Cipher : public Bu::Filter - { - public: - Cipher( Bu::Stream &rNext ) : - Bu::Filter( rNext ), - iReadBufFill( 0 ), - iReadBufPos( 0 ), - iWriteBufFill( 0 ) - { - } - - virtual ~Cipher() - { - } - - virtual void start() - { - } - - virtual Bu::size stop() - { - flush(); - return 0; - } - - virtual Bu::size read( void *pBuf, Bu::size iBytes ) - { - Bu::size iRead = 0; - while( iRead < iBytes ) - { - if( iReadBufFill < iBlockSize ) - { - int iR = rNext.read( - aReadBuf+iReadBufFill, - iBlockSize-iReadBufFill - ); - if( iR == 0 ) - return iRead; - - iReadBufFill += iR; - - if( iReadBufFill == iBlockSize ) - decipher( aReadBuf ); - } - - if( iReadBufFill == iBlockSize ) - { - int iCpy = Bu::buMin( (int)(iBytes-iRead), iBlockSize-iReadBufPos ); - memcpy( ((char *)pBuf)+iRead, aReadBuf+iReadBufPos, iCpy ); - iRead += iCpy; - iReadBufPos += iCpy; - if( iReadBufPos == iBlockSize ) - { - iReadBufPos = iReadBufFill = 0; - } - } - } - - return iRead; - } - - virtual Bu::size write( const void *pBuf, Bu::size iBytes ) - { - Bu::size iPos = 0; - - while( iPos < iBytes ) - { - int iLeft = Bu::buMin((int)(iBytes-iPos),iBlockSize-iWriteBufFill); - memcpy( aWriteBuf+iWriteBufFill, (char *)pBuf+iPos, iLeft ); - iPos += iLeft; - iWriteBufFill += iLeft; - if( iWriteBufFill == iBlockSize ) - { - encipher( aWriteBuf ); - rNext.write( aWriteBuf, iBlockSize ); - iWriteBufFill = 0; - } - } - - return iPos; - } - - virtual void flush() - { - if( iWriteBufFill > 0 && iWriteBufFill < iBlockSize ) - { - memset( aWriteBuf+iWriteBufFill, 0, iBlockSize-iWriteBufFill ); - encipher( aWriteBuf ); - rNext.write( aWriteBuf, iBlockSize ); - iWriteBufFill = 0; - } - rNext.flush(); - } - - using Bu::Stream::read; - using Bu::Stream::write; - - protected: - virtual void encipher( void *pData )=0; - virtual void decipher( void *pData )=0; - - private: - char aReadBuf[iBlockSize]; - char aWriteBuf[iBlockSize]; - int iReadBufFill; - int iReadBufPos; - int iWriteBufFill; - }; + template + class Cipher : public Bu::Filter + { + public: + Cipher( Bu::Stream &rNext ) : + Bu::Filter( rNext ), + iReadBufFill( 0 ), + iReadBufPos( 0 ), + iWriteBufFill( 0 ) + { + } + + virtual ~Cipher() + { + } + + virtual void start() + { + } + + virtual Bu::size stop() + { + flush(); + return 0; + } + + virtual Bu::size read( void *pBuf, Bu::size iBytes ) + { + Bu::size iRead = 0; + while( iRead < iBytes ) + { + if( iReadBufFill < iBlockSize ) + { + int iR = rNext.read( + aReadBuf+iReadBufFill, + iBlockSize-iReadBufFill + ); + if( iR == 0 ) + return iRead; + + iReadBufFill += iR; + + if( iReadBufFill == iBlockSize ) + decipher( aReadBuf ); + } + + if( iReadBufFill == iBlockSize ) + { + int iCpy = Bu::buMin( (int)(iBytes-iRead), iBlockSize-iReadBufPos ); + memcpy( ((char *)pBuf)+iRead, aReadBuf+iReadBufPos, iCpy ); + iRead += iCpy; + iReadBufPos += iCpy; + if( iReadBufPos == iBlockSize ) + { + iReadBufPos = iReadBufFill = 0; + } + } + } + + return iRead; + } + + virtual Bu::size write( const void *pBuf, Bu::size iBytes ) + { + Bu::size iPos = 0; + + while( iPos < iBytes ) + { + int iLeft = Bu::buMin((int)(iBytes-iPos),iBlockSize-iWriteBufFill); + memcpy( aWriteBuf+iWriteBufFill, (char *)pBuf+iPos, iLeft ); + iPos += iLeft; + iWriteBufFill += iLeft; + if( iWriteBufFill == iBlockSize ) + { + encipher( aWriteBuf ); + rNext.write( aWriteBuf, iBlockSize ); + iWriteBufFill = 0; + } + } + + return iPos; + } + + virtual void flush() + { + if( iWriteBufFill > 0 && iWriteBufFill < iBlockSize ) + { + memset( aWriteBuf+iWriteBufFill, 0, iBlockSize-iWriteBufFill ); + encipher( aWriteBuf ); + rNext.write( aWriteBuf, iBlockSize ); + iWriteBufFill = 0; + } + rNext.flush(); + } + + using Bu::Stream::read; + using Bu::Stream::write; + + protected: + virtual void encipher( void *pData )=0; + virtual void decipher( void *pData )=0; + + private: + char aReadBuf[iBlockSize]; + char aWriteBuf[iBlockSize]; + int iReadBufFill; + int iReadBufPos; + int iWriteBufFill; + }; }; #endif diff --git a/src/experimental/ciphermodecbc.h b/src/experimental/ciphermodecbc.h index 8fbf9f6..b06a972 100644 --- a/src/experimental/ciphermodecbc.h +++ b/src/experimental/ciphermodecbc.h @@ -6,49 +6,49 @@ namespace Bu { - template - class CipherModeCbc : public CipherType - { - public: - CipherModeCbc(class Stream &rNext ) : - CipherType( rNext ), - bStart( true ) - { - memset( aVector, 0, iBlockSize ); - } - - virtual ~CipherModeCbc() - { - } - - void setIv( const Bu::String &sIv ) - { - memcpy( aVector, sIv.getStr(), iBlockSize ); - } - - protected: - void decipher( void *pBuf ) - { - uint8_t aTmp[iBlockSize]; - memcpy( aTmp, pBuf, iBlockSize ); - CipherType::decipher( pBuf ); - for( int j = 0; j < iBlockSize; j++ ) - ((uint8_t *)pBuf)[j] ^= aVector[j]; - memcpy( aVector, aTmp, iBlockSize ); - } - - void encipher( void *pBuf ) - { - for( int j = 0; j < iBlockSize; j++ ) - ((uint8_t *)pBuf)[j] ^= aVector[j]; - CipherType::encipher( pBuf ); - memcpy( aVector, pBuf, iBlockSize ); - } - - private: - bool bStart; - uint8_t aVector[iBlockSize]; - }; + template + class CipherModeCbc : public CipherType + { + public: + CipherModeCbc(class Stream &rNext ) : + CipherType( rNext ), + bStart( true ) + { + memset( aVector, 0, iBlockSize ); + } + + virtual ~CipherModeCbc() + { + } + + void setIv( const Bu::String &sIv ) + { + memcpy( aVector, sIv.getStr(), iBlockSize ); + } + + protected: + void decipher( void *pBuf ) + { + uint8_t aTmp[iBlockSize]; + memcpy( aTmp, pBuf, iBlockSize ); + CipherType::decipher( pBuf ); + for( int j = 0; j < iBlockSize; j++ ) + ((uint8_t *)pBuf)[j] ^= aVector[j]; + memcpy( aVector, aTmp, iBlockSize ); + } + + void encipher( void *pBuf ) + { + for( int j = 0; j < iBlockSize; j++ ) + ((uint8_t *)pBuf)[j] ^= aVector[j]; + CipherType::encipher( pBuf ); + memcpy( aVector, pBuf, iBlockSize ); + } + + private: + bool bStart; + uint8_t aVector[iBlockSize]; + }; }; #endif diff --git a/src/experimental/ciphermodecfb.h b/src/experimental/ciphermodecfb.h index dab6c2e..34c682f 100644 --- a/src/experimental/ciphermodecfb.h +++ b/src/experimental/ciphermodecfb.h @@ -6,48 +6,48 @@ namespace Bu { - template - class CipherModeCfb : public CipherType - { - public: - CipherModeCfb(class Stream &rNext ) : - CipherType( rNext ), - bStart( true ) - { - memset( aVector, 0, iBlockSize ); - } - - virtual ~CipherModeCfb() - { - } - - void setIv( const Bu::String &sIv ) - { - memcpy( aVector, sIv.getStr(), iBlockSize ); - } - - protected: - void decipher( void *pBuf ) - { - uint8_t aTmp[iBlockSize]; - memcpy( aTmp, pBuf, iBlockSize ); - CipherType::encipher( aVector ); - for( int j = 0; j < iBlockSize; j++ ) - ((uint8_t *)pBuf)[j] ^= aVector[j]; - memcpy( aVector, aTmp, iBlockSize ); - } - - void encipher( void *pBuf ) - { - CipherType::encipher( aVector ); - for( int j = 0; j < iBlockSize; j++ ) - aVector[j] = ((uint8_t *)pBuf)[j] ^= aVector[j]; - } - - private: - bool bStart; - uint8_t aVector[iBlockSize]; - }; + template + class CipherModeCfb : public CipherType + { + public: + CipherModeCfb(class Stream &rNext ) : + CipherType( rNext ), + bStart( true ) + { + memset( aVector, 0, iBlockSize ); + } + + virtual ~CipherModeCfb() + { + } + + void setIv( const Bu::String &sIv ) + { + memcpy( aVector, sIv.getStr(), iBlockSize ); + } + + protected: + void decipher( void *pBuf ) + { + uint8_t aTmp[iBlockSize]; + memcpy( aTmp, pBuf, iBlockSize ); + CipherType::encipher( aVector ); + for( int j = 0; j < iBlockSize; j++ ) + ((uint8_t *)pBuf)[j] ^= aVector[j]; + memcpy( aVector, aTmp, iBlockSize ); + } + + void encipher( void *pBuf ) + { + CipherType::encipher( aVector ); + for( int j = 0; j < iBlockSize; j++ ) + aVector[j] = ((uint8_t *)pBuf)[j] ^= aVector[j]; + } + + private: + bool bStart; + uint8_t aVector[iBlockSize]; + }; }; #endif diff --git a/src/experimental/ciphermodeecb.h b/src/experimental/ciphermodeecb.h index 006741a..cac2beb 100644 --- a/src/experimental/ciphermodeecb.h +++ b/src/experimental/ciphermodeecb.h @@ -3,30 +3,30 @@ namespace Bu { - template - class CipherModeEcb : public CipherType - { - public: - CipherModeEcb( class Stream &rNext ) : - CipherType( rNext ) - { - } + template + class CipherModeEcb : public CipherType + { + public: + CipherModeEcb( class Stream &rNext ) : + CipherType( rNext ) + { + } - virtual ~CipherModeEcb() - { - } - - protected: - virtual void decipher( void *pBuf ) - { - CipherType::decipher( pBuf ); - } + virtual ~CipherModeEcb() + { + } + + protected: + virtual void decipher( void *pBuf ) + { + CipherType::decipher( pBuf ); + } - virtual void encipher( void *pBuf ) - { - CipherType::encipher( pBuf ); - } - }; + virtual void encipher( void *pBuf ) + { + CipherType::encipher( pBuf ); + } + }; }; #endif diff --git a/src/experimental/ciphermodeofb.h b/src/experimental/ciphermodeofb.h index 8c2aa20..e1b5108 100644 --- a/src/experimental/ciphermodeofb.h +++ b/src/experimental/ciphermodeofb.h @@ -6,51 +6,51 @@ namespace Bu { - template - class CipherModeOfb : public CipherType - { - public: - CipherModeOfb(class Stream &rNext ) : - CipherType( rNext ), - bStart( true ) - { - memset( aVector, 0, iBlockSize ); - } - - virtual ~CipherModeOfb() - { - } - - void setIv( const Bu::String &sIv ) - { - memcpy( aVector, sIv.getStr(), iBlockSize ); - } - - protected: - void decipher( void *pBuf ) - { - CipherType::encipher( aVector ); - uint8_t aTmp[iBlockSize]; - memcpy( aTmp, aVector, iBlockSize ); - for( int j = 0; j < iBlockSize; j++ ) - ((uint8_t *)pBuf)[j] ^= aVector[j]; - memcpy( aVector, aTmp, iBlockSize ); - } - - void encipher( void *pBuf ) - { - CipherType::encipher( aVector ); - uint8_t aTmp[iBlockSize]; - memcpy( aTmp, aVector, iBlockSize ); - for( int j = 0; j < iBlockSize; j++ ) - ((uint8_t *)pBuf)[j] ^= aVector[j]; - memcpy( aVector, aTmp, iBlockSize ); - } - - private: - bool bStart; - uint8_t aVector[iBlockSize]; - }; + template + class CipherModeOfb : public CipherType + { + public: + CipherModeOfb(class Stream &rNext ) : + CipherType( rNext ), + bStart( true ) + { + memset( aVector, 0, iBlockSize ); + } + + virtual ~CipherModeOfb() + { + } + + void setIv( const Bu::String &sIv ) + { + memcpy( aVector, sIv.getStr(), iBlockSize ); + } + + protected: + void decipher( void *pBuf ) + { + CipherType::encipher( aVector ); + uint8_t aTmp[iBlockSize]; + memcpy( aTmp, aVector, iBlockSize ); + for( int j = 0; j < iBlockSize; j++ ) + ((uint8_t *)pBuf)[j] ^= aVector[j]; + memcpy( aVector, aTmp, iBlockSize ); + } + + void encipher( void *pBuf ) + { + CipherType::encipher( aVector ); + uint8_t aTmp[iBlockSize]; + memcpy( aTmp, aVector, iBlockSize ); + for( int j = 0; j < iBlockSize; j++ ) + ((uint8_t *)pBuf)[j] ^= aVector[j]; + memcpy( aVector, aTmp, iBlockSize ); + } + + private: + bool bStart; + uint8_t aVector[iBlockSize]; + }; }; #endif diff --git a/src/experimental/dir.h b/src/experimental/dir.h index 8e885d1..9e518eb 100644 --- a/src/experimental/dir.h +++ b/src/experimental/dir.h @@ -6,15 +6,15 @@ namespace Bu { - class Dir : public FileSystem - { - public: - Dir(); - Dir( const Bu::String &sPath ); - virtual ~Dir(); + class Dir : public FileSystem + { + public: + Dir(); + Dir( const Bu::String &sPath ); + virtual ~Dir(); - private: - }; + private: + }; }; #endif diff --git a/src/experimental/fastcgi.cpp b/src/experimental/fastcgi.cpp index 7068fa8..71426b9 100644 --- a/src/experimental/fastcgi.cpp +++ b/src/experimental/fastcgi.cpp @@ -8,7 +8,7 @@ #include "bu/fastcgi.h" #ifndef WIN32 - #include + #include #endif #include @@ -21,17 +21,17 @@ using Bu::sio; using Bu::Fmt; Bu::FastCgi::FastCgi() : - pSrv( NULL ), - bRunning( true ) + pSrv( NULL ), + bRunning( true ) { - pSrv = new Bu::TcpServerSocket( (Bu::TcpServerSocket::socket_t)STDIN_FILENO, false ); + pSrv = new Bu::TcpServerSocket( (Bu::TcpServerSocket::socket_t)STDIN_FILENO, false ); } Bu::FastCgi::FastCgi( int iPort ) : - pSrv( NULL ), - bRunning( true ) + pSrv( NULL ), + bRunning( true ) { - pSrv = new Bu::TcpServerSocket( iPort ); + pSrv = new Bu::TcpServerSocket( iPort ); } Bu::FastCgi::~FastCgi() @@ -41,332 +41,332 @@ Bu::FastCgi::~FastCgi() bool Bu::FastCgi::isEmbedded() { #ifndef WIN32 - struct sockaddr name; - socklen_t namelen = sizeof(name); - if( getpeername( STDIN_FILENO, &name, &namelen ) != 0 && - errno == ENOTCONN ) - { - sio << "errno = " << errno << " (" << strerror( errno ) << ")" << - sio.nl; - sio << "Socket found" << sio.nl; - return true; - } - else - { - sio << "errno = " << errno << " (" << strerror( errno ) << ")" << - sio.nl; - sio << "No socket detected, running in standalone mode" << sio.nl; - return false; - } + struct sockaddr name; + socklen_t namelen = sizeof(name); + if( getpeername( STDIN_FILENO, &name, &namelen ) != 0 && + errno == ENOTCONN ) + { + sio << "errno = " << errno << " (" << strerror( errno ) << ")" << + sio.nl; + sio << "Socket found" << sio.nl; + return true; + } + else + { + sio << "errno = " << errno << " (" << strerror( errno ) << ")" << + sio.nl; + sio << "No socket detected, running in standalone mode" << sio.nl; + return false; + } #else - #warning Bu::FastCgi::isEmbedded IS A STUB for WIN32!!!! - return false; + #warning Bu::FastCgi::isEmbedded IS A STUB for WIN32!!!! + return false; #endif } void Bu::FastCgi::read( Bu::TcpSocket &s, Bu::FastCgi::Record &r ) { - int iRead = s.read( &r, sizeof(Record) ); - if( iRead != sizeof(Record) ) - throw Bu::TcpSocketException("Hey, the size %d is wrong for Record. (%s)", - iRead, strerror( errno ) ); - r.uRequestId = ntohs( r.uRequestId ); - r.uContentLength = ntohs( r.uContentLength ); + int iRead = s.read( &r, sizeof(Record) ); + if( iRead != sizeof(Record) ) + throw Bu::TcpSocketException("Hey, the size %d is wrong for Record. (%s)", + iRead, strerror( errno ) ); + r.uRequestId = ntohs( r.uRequestId ); + r.uContentLength = ntohs( r.uContentLength ); } void Bu::FastCgi::write( Bu::TcpSocket &s, Bu::FastCgi::Record r ) { -// sio << "Out -> " << r << sio.nl; - r.uRequestId = htons( r.uRequestId ); - r.uContentLength = htons( r.uContentLength ); - s.write( &r, sizeof(Record) ); +// sio << "Out -> " << r << sio.nl; + r.uRequestId = htons( r.uRequestId ); + r.uContentLength = htons( r.uContentLength ); + s.write( &r, sizeof(Record) ); } void Bu::FastCgi::read( Bu::TcpSocket &s, Bu::FastCgi::BeginRequestBody &b ) { - s.read( &b, sizeof(BeginRequestBody) ); - b.uRole = ntohs( b.uRole ); + s.read( &b, sizeof(BeginRequestBody) ); + b.uRole = ntohs( b.uRole ); } void Bu::FastCgi::write( Bu::TcpSocket &s, Bu::FastCgi::EndRequestBody b ) { - b.uStatus = htonl( b.uStatus ); - s.write( &b, sizeof(b) ); + b.uStatus = htonl( b.uStatus ); + s.write( &b, sizeof(b) ); } uint32_t Bu::FastCgi::readLen( Bu::TcpSocket &s, uint16_t &uRead ) { - uint8_t uByte[4]; - s.read( uByte, 1 ); - uRead++; - if( uByte[0] >> 7 == 0 ) - return uByte[0]; - - s.read( uByte+1, 3 ); - uRead += 3; - return ((uByte[0]&0x7f)<<24)|(uByte[1]<<16)|(uByte[2]<<8)|(uByte[3]); + uint8_t uByte[4]; + s.read( uByte, 1 ); + uRead++; + if( uByte[0] >> 7 == 0 ) + return uByte[0]; + + s.read( uByte+1, 3 ); + uRead += 3; + return ((uByte[0]&0x7f)<<24)|(uByte[1]<<16)|(uByte[2]<<8)|(uByte[3]); } void Bu::FastCgi::readPair( Bu::TcpSocket &s, StrHash &hParams, uint16_t &uRead ) { - uint32_t uName = readLen( s, uRead ); - uint32_t uValue = readLen( s, uRead ); - uRead += uName + uValue; - unsigned char *sName = new unsigned char[uName]; - s.read( sName, uName ); - Bu::String fsName( (char *)sName, uName ); - delete[] sName; - - if( uValue > 0 ) - { - unsigned char *sValue = new unsigned char[uValue]; - s.read( sValue, uValue ); - Bu::String fsValue( (char *)sValue, uValue ); - hParams.insert( fsName, fsValue ); - delete[] sValue; - } - else - { - hParams.insert( fsName, "" ); - } + uint32_t uName = readLen( s, uRead ); + uint32_t uValue = readLen( s, uRead ); + uRead += uName + uValue; + unsigned char *sName = new unsigned char[uName]; + s.read( sName, uName ); + Bu::String fsName( (char *)sName, uName ); + delete[] sName; + + if( uValue > 0 ) + { + unsigned char *sValue = new unsigned char[uValue]; + s.read( sValue, uValue ); + Bu::String fsValue( (char *)sValue, uValue ); + hParams.insert( fsName, fsValue ); + delete[] sValue; + } + else + { + hParams.insert( fsName, "" ); + } } bool Bu::FastCgi::hasChannel( int iChan ) { - if( aChannel.getSize() < iChan ) - return false; - if( aChannel[iChan-1] == NULL ) - return false; - return true; + if( aChannel.getSize() < iChan ) + return false; + if( aChannel[iChan-1] == NULL ) + return false; + return true; } Bu::Formatter &Bu::operator<<( Bu::Formatter &f, const Bu::FastCgi::Record &r ) { - f << "[Ver=" << (uint32_t)r.uVersion << - ", Type=" << (uint32_t)r.uType << - ", Req=" << (uint32_t)r.uRequestId << - ", clen=" << (uint32_t)r.uContentLength << - ", plen=" << (uint32_t)r.uPaddingLength << - ", resv=" << (uint32_t)r.uReserved << - "]"; - return f; + f << "[Ver=" << (uint32_t)r.uVersion << + ", Type=" << (uint32_t)r.uType << + ", Req=" << (uint32_t)r.uRequestId << + ", clen=" << (uint32_t)r.uContentLength << + ", plen=" << (uint32_t)r.uPaddingLength << + ", resv=" << (uint32_t)r.uReserved << + "]"; + return f; } void Bu::FastCgi::run() { -// sio << "sizeof(Bu::FastCgi::Record) = " << sizeof(Record) << sio.nl; - bRunning = true; - while( bRunning ) - { - int iSock = pSrv->accept( 5 ); - if( iSock < 0 ) - continue; - - Bu::TcpSocket s( iSock ); - s.setBlocking( true ); -// sio << "Got connection, blocking? " << s.isBlocking() << sio.nl; - try - { - for(;;) - { - Record r; - memset( &r, 0, sizeof(r) ); -// try -// { - read( s, r ); -// } -// catch( Bu::ExceptionBase &e ) -// { -// sio << "Error: " << e.what() << ", " << s.isOpen() << -// sio.nl; -// continue; -// } - Channel *pChan = NULL; - if( r.uRequestId > 0 ) - { - if( !hasChannel( r.uRequestId ) && - r.uType != typeBeginRequest ) - { - sio << "Error, stream data without stream." << sio.nl; - sio << r << sio.nl; - if( r.uContentLength > 0 ) - { - char *buf = new char[r.uContentLength]; - sio << " (read " << s.read( buf, r.uContentLength ) - << "/" << r.uContentLength << "):" << sio.nl; - sio.write( buf, r.uContentLength ); - sio << sio.nl << sio.nl; - } - } - while( aChannel.getSize() < r.uRequestId ) - aChannel.append( NULL ); - if( r.uRequestId > 0 ) - pChan = aChannel[r.uRequestId-1]; - } - -// sio << "Record (id=" << r.uRequestId << ", len=" << -// r.uContentLength << ", pad=" << -// (unsigned int)r.uPaddingLength << "): "; -// fflush( stdout ); - - switch( (RequestType)r.uType ) - { - case typeBeginRequest: -// sio << "Begin Request."; - { - BeginRequestBody b; - read( s, b ); - if( pChan != NULL ) - { - sio << "Error!!!" << sio.nl; - return; - } - pChan = aChannel[r.uRequestId-1] = new Channel(); - } - break; - - case typeParams: -// sio << "Params."; - if( r.uContentLength == 0 ) - { - pChan->uFlags |= chflgParamsDone; - } - else - { - uint16_t uUsed = 0; - while( uUsed < r.uContentLength ) - { - readPair( s, pChan->hParams, uUsed ); - } - } - break; - - case typeStdIn: -// sio << "StdIn."; - if( r.uContentLength == 0 ) - { - pChan->uFlags |= chflgStdInDone; - } - else - { - char *buf = new char[r.uContentLength]; - int iTotal = 0; - do - { - size_t iRead = s.read( - buf, r.uContentLength-iTotal ); - iTotal += iRead; -// sio << " (read " << iRead << " " << iTotal -// << "/" << r.uContentLength << ")"; - pChan->sStdIn.append( buf, iRead ); - } while( iTotal < r.uContentLength ); - delete[] buf; - } - break; - - case typeData: -// sio << "Data."; - if( r.uContentLength == 0 ) - { - pChan->uFlags |= chflgDataDone; - } - else - { - char *buf = new char[r.uContentLength]; - s.read( buf, r.uContentLength ); - pChan->sData.append( buf, r.uContentLength ); - delete[] buf; - } - break; - - case typeStdOut: - case typeStdErr: - case typeEndRequest: - case typeAbortRequest: - case typeGetValuesResult: -// sio << "Scary."; - // ??? we shouldn't get these. - break; - - case typeGetValues: - break; - } - -// sio << sio.nl; - - if( pChan ) - { - if( pChan->uFlags == chflgAllDone ) - { -// sio << "All done, generating output." << sio.nl; - Bu::MemBuf mStdOut, mStdErr; - int iRet = onRequest( - pChan->hParams, pChan->sStdIn, - mStdOut, mStdErr - ); - - Bu::String &sStdOut = mStdOut.getString(); - Bu::String &sStdErr = mStdErr.getString(); - - Record rOut; - memset( &rOut, 0, sizeof(rOut) ); - rOut.uVersion = 1; - rOut.uRequestId = r.uRequestId; - rOut.uPaddingLength = 0; - rOut.uType = typeStdOut; - if( sStdOut.getSize() > 0 ) - { - for( int iPos = 0; iPos < sStdOut.getSize(); - iPos += 65528 ) - { - int iSize = sStdOut.getSize()-iPos; - if( iSize > 65528 ) - iSize = 65528; - rOut.uContentLength = iSize; - write( s, rOut ); - s.write( sStdOut.getStr()+iPos, iSize ); - } - } - rOut.uContentLength = 0; - write( s, rOut ); - - rOut.uType = typeStdErr; - if( sStdErr.getSize() > 0 ) - { - for( int iPos = 0; iPos < sStdErr.getSize(); - iPos += 65528 ) - { - int iSize = sStdErr.getSize()-iPos; - if( iSize > 65528 ) - iSize = 65528; - rOut.uContentLength = iSize; - write( s, rOut ); - s.write( sStdErr.getStr()+iPos, iSize ); - } - } - rOut.uContentLength = 0; - write( s, rOut ); - - rOut.uType = typeEndRequest; - rOut.uContentLength = 8; - write( s, rOut ); - - EndRequestBody b; - memset( &b, 0, sizeof(b) ); - b.uStatus = iRet; - write( s, b ); - - delete pChan; - aChannel[r.uRequestId-1] = NULL; - } - } - } - } - catch( Bu::TcpSocketException &e ) - { -// sio << "Bu::SocketException: " << e.what() << sio.nl << -// "\tSocket open: " << s.isOpen() << sio.nl; - } - } +// sio << "sizeof(Bu::FastCgi::Record) = " << sizeof(Record) << sio.nl; + bRunning = true; + while( bRunning ) + { + int iSock = pSrv->accept( 5 ); + if( iSock < 0 ) + continue; + + Bu::TcpSocket s( iSock ); + s.setBlocking( true ); +// sio << "Got connection, blocking? " << s.isBlocking() << sio.nl; + try + { + for(;;) + { + Record r; + memset( &r, 0, sizeof(r) ); +// try +// { + read( s, r ); +// } +// catch( Bu::ExceptionBase &e ) +// { +// sio << "Error: " << e.what() << ", " << s.isOpen() << +// sio.nl; +// continue; +// } + Channel *pChan = NULL; + if( r.uRequestId > 0 ) + { + if( !hasChannel( r.uRequestId ) && + r.uType != typeBeginRequest ) + { + sio << "Error, stream data without stream." << sio.nl; + sio << r << sio.nl; + if( r.uContentLength > 0 ) + { + char *buf = new char[r.uContentLength]; + sio << " (read " << s.read( buf, r.uContentLength ) + << "/" << r.uContentLength << "):" << sio.nl; + sio.write( buf, r.uContentLength ); + sio << sio.nl << sio.nl; + } + } + while( aChannel.getSize() < r.uRequestId ) + aChannel.append( NULL ); + if( r.uRequestId > 0 ) + pChan = aChannel[r.uRequestId-1]; + } + +// sio << "Record (id=" << r.uRequestId << ", len=" << +// r.uContentLength << ", pad=" << +// (unsigned int)r.uPaddingLength << "): "; +// fflush( stdout ); + + switch( (RequestType)r.uType ) + { + case typeBeginRequest: +// sio << "Begin Request."; + { + BeginRequestBody b; + read( s, b ); + if( pChan != NULL ) + { + sio << "Error!!!" << sio.nl; + return; + } + pChan = aChannel[r.uRequestId-1] = new Channel(); + } + break; + + case typeParams: +// sio << "Params."; + if( r.uContentLength == 0 ) + { + pChan->uFlags |= chflgParamsDone; + } + else + { + uint16_t uUsed = 0; + while( uUsed < r.uContentLength ) + { + readPair( s, pChan->hParams, uUsed ); + } + } + break; + + case typeStdIn: +// sio << "StdIn."; + if( r.uContentLength == 0 ) + { + pChan->uFlags |= chflgStdInDone; + } + else + { + char *buf = new char[r.uContentLength]; + int iTotal = 0; + do + { + size_t iRead = s.read( + buf, r.uContentLength-iTotal ); + iTotal += iRead; +// sio << " (read " << iRead << " " << iTotal +// << "/" << r.uContentLength << ")"; + pChan->sStdIn.append( buf, iRead ); + } while( iTotal < r.uContentLength ); + delete[] buf; + } + break; + + case typeData: +// sio << "Data."; + if( r.uContentLength == 0 ) + { + pChan->uFlags |= chflgDataDone; + } + else + { + char *buf = new char[r.uContentLength]; + s.read( buf, r.uContentLength ); + pChan->sData.append( buf, r.uContentLength ); + delete[] buf; + } + break; + + case typeStdOut: + case typeStdErr: + case typeEndRequest: + case typeAbortRequest: + case typeGetValuesResult: +// sio << "Scary."; + // ??? we shouldn't get these. + break; + + case typeGetValues: + break; + } + +// sio << sio.nl; + + if( pChan ) + { + if( pChan->uFlags == chflgAllDone ) + { +// sio << "All done, generating output." << sio.nl; + Bu::MemBuf mStdOut, mStdErr; + int iRet = onRequest( + pChan->hParams, pChan->sStdIn, + mStdOut, mStdErr + ); + + Bu::String &sStdOut = mStdOut.getString(); + Bu::String &sStdErr = mStdErr.getString(); + + Record rOut; + memset( &rOut, 0, sizeof(rOut) ); + rOut.uVersion = 1; + rOut.uRequestId = r.uRequestId; + rOut.uPaddingLength = 0; + rOut.uType = typeStdOut; + if( sStdOut.getSize() > 0 ) + { + for( int iPos = 0; iPos < sStdOut.getSize(); + iPos += 65528 ) + { + int iSize = sStdOut.getSize()-iPos; + if( iSize > 65528 ) + iSize = 65528; + rOut.uContentLength = iSize; + write( s, rOut ); + s.write( sStdOut.getStr()+iPos, iSize ); + } + } + rOut.uContentLength = 0; + write( s, rOut ); + + rOut.uType = typeStdErr; + if( sStdErr.getSize() > 0 ) + { + for( int iPos = 0; iPos < sStdErr.getSize(); + iPos += 65528 ) + { + int iSize = sStdErr.getSize()-iPos; + if( iSize > 65528 ) + iSize = 65528; + rOut.uContentLength = iSize; + write( s, rOut ); + s.write( sStdErr.getStr()+iPos, iSize ); + } + } + rOut.uContentLength = 0; + write( s, rOut ); + + rOut.uType = typeEndRequest; + rOut.uContentLength = 8; + write( s, rOut ); + + EndRequestBody b; + memset( &b, 0, sizeof(b) ); + b.uStatus = iRet; + write( s, b ); + + delete pChan; + aChannel[r.uRequestId-1] = NULL; + } + } + } + } + catch( Bu::TcpSocketException &e ) + { +// sio << "Bu::SocketException: " << e.what() << sio.nl << +// "\tSocket open: " << s.isOpen() << sio.nl; + } + } } diff --git a/src/experimental/fastcgi.h b/src/experimental/fastcgi.h index 63d975f..50b10f5 100644 --- a/src/experimental/fastcgi.h +++ b/src/experimental/fastcgi.h @@ -16,118 +16,118 @@ namespace Bu { - class Stream; - - class FastCgi - { - public: - FastCgi( int iPort ); - FastCgi(); - virtual ~FastCgi(); - - static bool isEmbedded(); - - typedef Bu::Hash StrHash; - enum RequestType - { - typeBeginRequest = 1, - typeAbortRequest = 2, - typeEndRequest = 3, - typeParams = 4, - typeStdIn = 5, - typeStdOut = 6, - typeStdErr = 7, - typeData = 8, - typeGetValues = 9, - typeGetValuesResult = 10 - }; - - enum Role - { - roleResponder = 1, - roleAuthorizer = 2, - roleFilter = 3 - }; - - enum Flags - { - flagsKeepConn = 1 - }; - - enum Status - { - statusRequestComplete = 0, - statusCantMpxConn = 1, - statusOverloaded = 2, - statusUnknownRole = 3 - }; - - typedef struct { - uint8_t uVersion; - uint8_t uType; - uint16_t uRequestId; - uint16_t uContentLength; - uint8_t uPaddingLength; - uint8_t uReserved; - } Record; - - typedef struct { - uint16_t uRole; - uint8_t uFlags; - uint8_t reserved[5]; - } BeginRequestBody; - - typedef struct { - uint32_t uStatus; - uint8_t uProtocolStatus; - uint8_t reserved[3]; - } EndRequestBody; - - typedef struct Channel { - Channel() : uFlags( 0 ) { } - StrHash hParams; - Bu::String sStdIn; - Bu::String sData; - uint8_t uFlags; - } Channel; - - enum ChannelFlags - { - chflgParamsDone = 0x01, - chflgStdInDone = 0x02, - chflgDataDone = 0x04, - - chflgAllDone = 0x03 - }; - - virtual void run(); - - void stopRunning() { bRunning = false; } - - virtual void onInit() { }; - virtual int onRequest( const StrHash &hParams, - const Bu::String &sStdIn, Bu::Stream &sStdOut, - Bu::Stream &sStdErr )=0; - virtual void onUninit() { }; - - private: - void read( Bu::TcpSocket &s, Record &r ); - void read( Bu::TcpSocket &s, BeginRequestBody &b ); - uint32_t readLen( Bu::TcpSocket &s, uint16_t &uUsed ); - void readPair( Bu::TcpSocket &s, StrHash &hParams, uint16_t &uUsed ); - - void write( Bu::TcpSocket &s, Record r ); - void write( Bu::TcpSocket &s, EndRequestBody b ); - - bool hasChannel( int iChan ); - - private: - Bu::TcpServerSocket *pSrv; - bool bRunning; - Bu::Array aChannel; - }; - - Bu::Formatter &operator<<( Bu::Formatter &f, const Bu::FastCgi::Record &r ); + class Stream; + + class FastCgi + { + public: + FastCgi( int iPort ); + FastCgi(); + virtual ~FastCgi(); + + static bool isEmbedded(); + + typedef Bu::Hash StrHash; + enum RequestType + { + typeBeginRequest = 1, + typeAbortRequest = 2, + typeEndRequest = 3, + typeParams = 4, + typeStdIn = 5, + typeStdOut = 6, + typeStdErr = 7, + typeData = 8, + typeGetValues = 9, + typeGetValuesResult = 10 + }; + + enum Role + { + roleResponder = 1, + roleAuthorizer = 2, + roleFilter = 3 + }; + + enum Flags + { + flagsKeepConn = 1 + }; + + enum Status + { + statusRequestComplete = 0, + statusCantMpxConn = 1, + statusOverloaded = 2, + statusUnknownRole = 3 + }; + + typedef struct { + uint8_t uVersion; + uint8_t uType; + uint16_t uRequestId; + uint16_t uContentLength; + uint8_t uPaddingLength; + uint8_t uReserved; + } Record; + + typedef struct { + uint16_t uRole; + uint8_t uFlags; + uint8_t reserved[5]; + } BeginRequestBody; + + typedef struct { + uint32_t uStatus; + uint8_t uProtocolStatus; + uint8_t reserved[3]; + } EndRequestBody; + + typedef struct Channel { + Channel() : uFlags( 0 ) { } + StrHash hParams; + Bu::String sStdIn; + Bu::String sData; + uint8_t uFlags; + } Channel; + + enum ChannelFlags + { + chflgParamsDone = 0x01, + chflgStdInDone = 0x02, + chflgDataDone = 0x04, + + chflgAllDone = 0x03 + }; + + virtual void run(); + + void stopRunning() { bRunning = false; } + + virtual void onInit() { }; + virtual int onRequest( const StrHash &hParams, + const Bu::String &sStdIn, Bu::Stream &sStdOut, + Bu::Stream &sStdErr )=0; + virtual void onUninit() { }; + + private: + void read( Bu::TcpSocket &s, Record &r ); + void read( Bu::TcpSocket &s, BeginRequestBody &b ); + uint32_t readLen( Bu::TcpSocket &s, uint16_t &uUsed ); + void readPair( Bu::TcpSocket &s, StrHash &hParams, uint16_t &uUsed ); + + void write( Bu::TcpSocket &s, Record r ); + void write( Bu::TcpSocket &s, EndRequestBody b ); + + bool hasChannel( int iChan ); + + private: + Bu::TcpServerSocket *pSrv; + bool bRunning; + Bu::Array aChannel; + }; + + Bu::Formatter &operator<<( Bu::Formatter &f, const Bu::FastCgi::Record &r ); }; #endif diff --git a/src/experimental/filesystem.h b/src/experimental/filesystem.h index 0c992a5..d25cb67 100644 --- a/src/experimental/filesystem.h +++ b/src/experimental/filesystem.h @@ -3,22 +3,22 @@ namespace Bu { - /** - * Represents an abstract baseclass for any file organization structure. - * If you're looking for acessing a local filesystem, try Bu::Dir. This - * is used to make switching between different types of filesystems - * seamless. FileSystems could be anything that organizes and grants - * access to file data, local filesystems, FTP servers, zip or myriadfs - * files, etc. - */ - class FileSystem - { - public: - FileSystem(); - virtual ~FileSystem(); + /** + * Represents an abstract baseclass for any file organization structure. + * If you're looking for acessing a local filesystem, try Bu::Dir. This + * is used to make switching between different types of filesystems + * seamless. FileSystems could be anything that organizes and grants + * access to file data, local filesystems, FTP servers, zip or myriadfs + * files, etc. + */ + class FileSystem + { + public: + FileSystem(); + virtual ~FileSystem(); - - }; + + }; }; #endif diff --git a/src/experimental/httpget.cpp b/src/experimental/httpget.cpp index 7a8a89a..70c722c 100644 --- a/src/experimental/httpget.cpp +++ b/src/experimental/httpget.cpp @@ -8,11 +8,11 @@ #include "bu/httpget.h" Bu::HttpGet::HttpGet( const Bu::Url &uSrc, const Bu::String &sMethod ) : - uSrc( uSrc ), - sMethod( sMethod ), - sSrv( uSrc.getHost(), uSrc.getPort() ) + uSrc( uSrc ), + sMethod( sMethod ), + sSrv( uSrc.getHost(), uSrc.getPort() ) { - sSrv.write( sMethod + " " + uSrc.getFullPath() + " HTTP/1.1\r\n" ); + sSrv.write( sMethod + " " + uSrc.getFullPath() + " HTTP/1.1\r\n" ); } Bu::HttpGet::~HttpGet() @@ -25,28 +25,28 @@ void Bu::HttpGet::close() void Bu::HttpGet::get() { - for( MimeHash::iterator i = hMimeOut.begin(); i; i++ ) - { - sSrv.write( i.getKey() + ": " + i.getValue() + "\r\n" ); - } - sSrv.write("\r\n", 2 ); + for( MimeHash::iterator i = hMimeOut.begin(); i; i++ ) + { + sSrv.write( i.getKey() + ": " + i.getValue() + "\r\n" ); + } + sSrv.write("\r\n", 2 ); -// sSrv.read( +// sSrv.read( } Bu::size Bu::HttpGet::read( void * /*pBuf*/, Bu::size /*nBytes*/ ) { - return 0; + return 0; } Bu::size Bu::HttpGet::write( const void * /*pBuf*/, Bu::size /*nBytes*/ ) { - return 0; + return 0; } Bu::size Bu::HttpGet::tell() { - return 0; + return 0; } void Bu::HttpGet::seek( Bu::size ) @@ -63,12 +63,12 @@ void Bu::HttpGet::setPosEnd( Bu::size ) bool Bu::HttpGet::isEos() { - return false; + return false; } bool Bu::HttpGet::isOpen() { - return true; + return true; } void Bu::HttpGet::flush() @@ -77,32 +77,32 @@ void Bu::HttpGet::flush() bool Bu::HttpGet::canRead() { - return true; + return true; } bool Bu::HttpGet::canWrite() { - return false; + return false; } bool Bu::HttpGet::isReadable() { - return true; + return true; } bool Bu::HttpGet::isWritable() { - return false; + return false; } bool Bu::HttpGet::isSeekable() { - return false; + return false; } bool Bu::HttpGet::isBlocking() { - return true; + return true; } void Bu::HttpGet::setBlocking( bool /*bBlocking*/ ) @@ -111,16 +111,16 @@ void Bu::HttpGet::setBlocking( bool /*bBlocking*/ ) Bu::size Bu::HttpGet::getSize() const { - return 0; + return 0; } Bu::size Bu::HttpGet::getBlockSize() const { - return 0; + return 0; } Bu::String Bu::HttpGet::getLocation() const { - return uSrc.getUrl(); + return uSrc.getUrl(); } diff --git a/src/experimental/httpget.h b/src/experimental/httpget.h index e8092e5..21e69d6 100644 --- a/src/experimental/httpget.h +++ b/src/experimental/httpget.h @@ -16,51 +16,51 @@ namespace Bu { - class HttpGet : public Bu::Stream - { - public: - HttpGet( const Bu::Url &uSrc, const Bu::String &sMethod="GET" ); - virtual ~HttpGet(); + class HttpGet : public Bu::Stream + { + public: + HttpGet( const Bu::Url &uSrc, const Bu::String &sMethod="GET" ); + virtual ~HttpGet(); - void get(); + void get(); - // From Bu::Stream - virtual void close(); - virtual Bu::size read( void *pBuf, Bu::size nBytes ); - virtual Bu::size write( const void *pBuf, Bu::size nBytes ); - using Stream::write; + // From Bu::Stream + virtual void close(); + virtual Bu::size read( void *pBuf, Bu::size nBytes ); + virtual Bu::size write( const void *pBuf, Bu::size nBytes ); + using Stream::write; - virtual Bu::size tell(); - virtual void seek( Bu::size offset ); - virtual void setPos( Bu::size pos ); - virtual void setPosEnd( Bu::size pos ); - virtual bool isEos(); - virtual bool isOpen(); + virtual Bu::size tell(); + virtual void seek( Bu::size offset ); + virtual void setPos( Bu::size pos ); + virtual void setPosEnd( Bu::size pos ); + virtual bool isEos(); + virtual bool isOpen(); - virtual void flush(); + virtual void flush(); - virtual bool canRead(); - virtual bool canWrite(); + virtual bool canRead(); + virtual bool canWrite(); - virtual bool isReadable(); - virtual bool isWritable(); - virtual bool isSeekable(); + virtual bool isReadable(); + virtual bool isWritable(); + virtual bool isSeekable(); - virtual bool isBlocking(); - virtual void setBlocking( bool bBlocking=true ); + virtual bool isBlocking(); + virtual void setBlocking( bool bBlocking=true ); - virtual size getSize() const; - virtual size getBlockSize() const; - virtual Bu::String getLocation() const; + virtual size getSize() const; + virtual size getBlockSize() const; + virtual Bu::String getLocation() const; - private: - Bu::Url uSrc; - Bu::String sMethod; - Bu::TcpSocket sSrv; - typedef Bu::Hash MimeHash; - MimeHash hMimeIn; - MimeHash hMimeOut; - }; + private: + Bu::Url uSrc; + Bu::String sMethod; + Bu::TcpSocket sSrv; + typedef Bu::Hash MimeHash; + MimeHash hMimeIn; + MimeHash hMimeOut; + }; }; #endif diff --git a/src/experimental/lexer.cpp b/src/experimental/lexer.cpp index 48ee017..ae95d09 100644 --- a/src/experimental/lexer.cpp +++ b/src/experimental/lexer.cpp @@ -18,23 +18,23 @@ Bu::Lexer::~Lexer() } Bu::Lexer::Token::Token() : - iToken( -1 ) + iToken( -1 ) { } Bu::Lexer::Token::Token( Bu::Lexer::TokenType iToken ) : - iToken( iToken ) + iToken( iToken ) { } Bu::String Bu::Lexer::tokenToString( const Bu::Lexer::Token &t ) { - Bu::MemBuf mb; - Bu::Formatter f( mb ); - f << "<" << t.iToken << ">"; - if( t.vExtra.isSet() ) - f << " (" << t.vExtra << ")"; + Bu::MemBuf mb; + Bu::Formatter f( mb ); + f << "<" << t.iToken << ">"; + if( t.vExtra.isSet() ) + f << " (" << t.vExtra << ")"; - return mb.getString(); + return mb.getString(); } diff --git a/src/experimental/lexer.h b/src/experimental/lexer.h index 69f4106..273f3cf 100644 --- a/src/experimental/lexer.h +++ b/src/experimental/lexer.h @@ -12,47 +12,47 @@ namespace Bu { - class Stream; - - /** - * The base class for creating a lexical analyzer. This is designed to work - * in tandem with the Bu::Parser class, which uses this to tokenize textual - * input. It can be used by just about anything that cares about tokens - * more than raw input, though. - */ - class Lexer - { - public: - Lexer(); - virtual ~Lexer(); - - typedef int TokenType; - - class Token - { - public: - Token(); - Token( TokenType iToken ); - - template - Token( TokenType iToken, const t &v ) : - iToken( iToken )//, -// vExtra( v ) - { - vExtra = v; - } - TokenType iToken; - Bu::Variant vExtra; - int iStartCol; - int iStartRow; - int iEndCol; - int iEndRow; - }; - - virtual Token *nextToken()=0; - - virtual Bu::String tokenToString( const Token &t ); - }; + class Stream; + + /** + * The base class for creating a lexical analyzer. This is designed to work + * in tandem with the Bu::Parser class, which uses this to tokenize textual + * input. It can be used by just about anything that cares about tokens + * more than raw input, though. + */ + class Lexer + { + public: + Lexer(); + virtual ~Lexer(); + + typedef int TokenType; + + class Token + { + public: + Token(); + Token( TokenType iToken ); + + template + Token( TokenType iToken, const t &v ) : + iToken( iToken )//, +// vExtra( v ) + { + vExtra = v; + } + TokenType iToken; + Bu::Variant vExtra; + int iStartCol; + int iStartRow; + int iEndCol; + int iEndRow; + }; + + virtual Token *nextToken()=0; + + virtual Bu::String tokenToString( const Token &t ); + }; }; #endif diff --git a/src/experimental/parser.cpp b/src/experimental/parser.cpp index 9f10256..5d0d7eb 100644 --- a/src/experimental/parser.cpp +++ b/src/experimental/parser.cpp @@ -21,231 +21,231 @@ Bu::Parser::~Parser() void Bu::Parser::pushLexer( Lexer *pLex ) { - sLexer.push( pLex ); + sLexer.push( pLex ); } void Bu::Parser::popLexer() { - delete sLexer.peekPop(); + delete sLexer.peekPop(); } Lexer::Token *Bu::Parser::popToken() { - return sToken.peekPop(); + return sToken.peekPop(); } void Bu::Parser::pushToken( Lexer::Token *pTok ) { - sToken.push( pTok ); + sToken.push( pTok ); } void Bu::Parser::parse() { - int iCurNt = iRootNonTerminal; - Lexer::Token *ptCur = sLexer.peek()->nextToken(); - sio << "Token(a): " << sLexer.peek()->tokenToString( *ptCur ) << sio.nl; - selectProduction( iCurNt, ptCur ); - - while( !sState.isEmpty() ) - { - switch( (*sState.peek()).eType ) - { - case State::typeTerminal: - sio << "terminal: " << ptCur->iToken << " == " - << (*sState.peek()).iIndex << sio.nl; - if( ptCur->iToken == (*sState.peek()).iIndex ) - { - advanceState(); - delete ptCur; - ptCur = sLexer.peek()->nextToken(); - sio << "Token(b): " << sLexer.peek()->tokenToString( *ptCur ) << sio.nl; - } - else - { - throw Bu::ExceptionBase("Error parsing code."); - } - break; - - case State::typeTerminalPush: - sio << "terminalpush: " << ptCur->iToken << " == " - << (*sState.peek()).iIndex << sio.nl; - if( ptCur->iToken == (*sState.peek()).iIndex ) - { - advanceState(); - sToken.push( ptCur ); - - ptCur = sLexer.peek()->nextToken(); - sio << "Token(c): " << sLexer.peek()->tokenToString( *ptCur ) << sio.nl; - } - else - { - throw Bu::ExceptionBase("Error parsing code."); - } - break; - - case State::typeNonTerminal: - sio << "nonterminal: " << ptCur->iToken << " --> " - << (*sState.peek()).iIndex << sio.nl; - { - int iNt = (*sState.peek()).iIndex; - sio << "Current state: " << *sState.peek() << sio.nl; - if( !selectProduction( iNt, ptCur ) ) - { - throw Bu::ExceptionBase("Error parsing code."); - } - } - break; - - case State::typeReduction: - sio << "reduction" << sio.nl; - aReduction[(*sState.peek()).iIndex]( *this ); - advanceState(); - break; - } - } + int iCurNt = iRootNonTerminal; + Lexer::Token *ptCur = sLexer.peek()->nextToken(); + sio << "Token(a): " << sLexer.peek()->tokenToString( *ptCur ) << sio.nl; + selectProduction( iCurNt, ptCur ); + + while( !sState.isEmpty() ) + { + switch( (*sState.peek()).eType ) + { + case State::typeTerminal: + sio << "terminal: " << ptCur->iToken << " == " + << (*sState.peek()).iIndex << sio.nl; + if( ptCur->iToken == (*sState.peek()).iIndex ) + { + advanceState(); + delete ptCur; + ptCur = sLexer.peek()->nextToken(); + sio << "Token(b): " << sLexer.peek()->tokenToString( *ptCur ) << sio.nl; + } + else + { + throw Bu::ExceptionBase("Error parsing code."); + } + break; + + case State::typeTerminalPush: + sio << "terminalpush: " << ptCur->iToken << " == " + << (*sState.peek()).iIndex << sio.nl; + if( ptCur->iToken == (*sState.peek()).iIndex ) + { + advanceState(); + sToken.push( ptCur ); + + ptCur = sLexer.peek()->nextToken(); + sio << "Token(c): " << sLexer.peek()->tokenToString( *ptCur ) << sio.nl; + } + else + { + throw Bu::ExceptionBase("Error parsing code."); + } + break; + + case State::typeNonTerminal: + sio << "nonterminal: " << ptCur->iToken << " --> " + << (*sState.peek()).iIndex << sio.nl; + { + int iNt = (*sState.peek()).iIndex; + sio << "Current state: " << *sState.peek() << sio.nl; + if( !selectProduction( iNt, ptCur ) ) + { + throw Bu::ExceptionBase("Error parsing code."); + } + } + break; + + case State::typeReduction: + sio << "reduction" << sio.nl; + aReduction[(*sState.peek()).iIndex]( *this ); + advanceState(); + break; + } + } } bool Bu::Parser::selectProduction( int iNt, Lexer::Token *ptCur ) { - NonTerminal &nt = aNonTerminal[iNt]; - int j = 0; - for( NonTerminal::ProductionList::iterator i = nt.lProduction.begin(); - i; i++,j++ ) - { - if( (*i).isEmpty() ) - continue; - sio << "-->(Attempting production " << iNt << ":" << j << ": " - << (*i).first() << ")" << sio.nl; - if( (*i).first().eType == State::typeTerminal || - (*i).first().eType == State::typeTerminalPush ) - { - if( (*i).first().iIndex == ptCur->iToken ) - { - sState.push( (*i).begin() ); - sio.incIndent(); - sio << "Pushing production " << j << " from nt " << iNt - << sio.nl; - return true; - } - } - else if( (*i).first().eType == State::typeNonTerminal ) - { - sState.push( (*i).begin() ); - sio.incIndent(); - sio << "Pushing production " << j << " from nt " << iNt - << " as test." << sio.nl; - if( !selectProduction( (*i).first().iIndex, ptCur ) ) - { - sio.decIndent(); - sState.pop(); - sio << "Production " << j << " from nt " << iNt - << " didn't work out." << sio.nl; - } - else - { - return true; - } - } - } - if( nt.bCanSkip ) - { - sio << "Nothing matches, skipping non-terminal." << sio.nl; - advanceState(); - return true; - } - sio << "-->(Found nothing)" << sio.nl; - return false; + NonTerminal &nt = aNonTerminal[iNt]; + int j = 0; + for( NonTerminal::ProductionList::iterator i = nt.lProduction.begin(); + i; i++,j++ ) + { + if( (*i).isEmpty() ) + continue; + sio << "-->(Attempting production " << iNt << ":" << j << ": " + << (*i).first() << ")" << sio.nl; + if( (*i).first().eType == State::typeTerminal || + (*i).first().eType == State::typeTerminalPush ) + { + if( (*i).first().iIndex == ptCur->iToken ) + { + sState.push( (*i).begin() ); + sio.incIndent(); + sio << "Pushing production " << j << " from nt " << iNt + << sio.nl; + return true; + } + } + else if( (*i).first().eType == State::typeNonTerminal ) + { + sState.push( (*i).begin() ); + sio.incIndent(); + sio << "Pushing production " << j << " from nt " << iNt + << " as test." << sio.nl; + if( !selectProduction( (*i).first().iIndex, ptCur ) ) + { + sio.decIndent(); + sState.pop(); + sio << "Production " << j << " from nt " << iNt + << " didn't work out." << sio.nl; + } + else + { + return true; + } + } + } + if( nt.bCanSkip ) + { + sio << "Nothing matches, skipping non-terminal." << sio.nl; + advanceState(); + return true; + } + sio << "-->(Found nothing)" << sio.nl; + return false; } void Bu::Parser::advanceState() { - if( sState.isEmpty() ) - return; - - sState.peek()++; - if( !sState.peek() ) - { - sio.decIndent(); - sState.pop(); - sio << "State advanced, End of production." << sio.nl; - advanceState(); - return; - } - sio << "State advanced, now: " << *(sState.peek()) << sio.nl; + if( sState.isEmpty() ) + return; + + sState.peek()++; + if( !sState.peek() ) + { + sio.decIndent(); + sState.pop(); + sio << "State advanced, End of production." << sio.nl; + advanceState(); + return; + } + sio << "State advanced, now: " << *(sState.peek()) << sio.nl; } void Bu::Parser::setRootNonTerminal( int iRoot ) { - iRootNonTerminal = iRoot; + iRootNonTerminal = iRoot; } void Bu::Parser::setRootNonTerminal( const Bu::String &sRoot ) { - setRootNonTerminal( hNonTerminalName.get( sRoot ) ); + setRootNonTerminal( hNonTerminalName.get( sRoot ) ); } int Bu::Parser::addNonTerminal( const Bu::String &sName, NonTerminal &nt ) { - int iId = aNonTerminal.getSize(); - aNonTerminal.append( nt ); - hNonTerminalName.insert( sName, iId ); - sio << "nt '" << sName << "' = " << iId << sio.nl; - return iId; + int iId = aNonTerminal.getSize(); + aNonTerminal.append( nt ); + hNonTerminalName.insert( sName, iId ); + sio << "nt '" << sName << "' = " << iId << sio.nl; + return iId; } int Bu::Parser::addNonTerminal( const Bu::String &sName ) { - int iId = aNonTerminal.getSize(); - aNonTerminal.append( NonTerminal() ); - hNonTerminalName.insert( sName, iId ); - sio << "nt '" << sName << "' = " << iId << sio.nl; - return iId; + int iId = aNonTerminal.getSize(); + aNonTerminal.append( NonTerminal() ); + hNonTerminalName.insert( sName, iId ); + sio << "nt '" << sName << "' = " << iId << sio.nl; + return iId; } void Bu::Parser::setNonTerminal( const Bu::String &sName, NonTerminal &nt ) { - aNonTerminal[hNonTerminalName.get(sName)] = nt; + aNonTerminal[hNonTerminalName.get(sName)] = nt; } int Bu::Parser::getNonTerminalId( const Bu::String &sName ) { - return hNonTerminalName.get( sName ); + return hNonTerminalName.get( sName ); } bool Bu::Parser::hasNonTerminal( const Bu::String &sName ) { - return hNonTerminalName.has( sName ); + return hNonTerminalName.has( sName ); } int Bu::Parser::addReduction( const Bu::String &sName, const Reduction &r ) { - int iId = aReduction.getSize(); - aReduction.append( r ); - hReductionName.insert( sName, iId ); - return iId; + int iId = aReduction.getSize(); + aReduction.append( r ); + hReductionName.insert( sName, iId ); + return iId; } int Bu::Parser::addReduction( const Bu::String &sName ) { - int iId = aReduction.getSize(); - aReduction.append( Reduction() ); - hReductionName.insert( sName, iId ); - return iId; + int iId = aReduction.getSize(); + aReduction.append( Reduction() ); + hReductionName.insert( sName, iId ); + return iId; } void Bu::Parser::setReduction( const Bu::String &sName, const Reduction &r ) { - aReduction[hReductionName.get(sName)] = r; + aReduction[hReductionName.get(sName)] = r; } int Bu::Parser::getReductionId( const Bu::String &sName ) { - return hReductionName.get( sName ); + return hReductionName.get( sName ); } bool Bu::Parser::hasReduction( const Bu::String &sName ) { - return hReductionName.has( sName ); + return hReductionName.has( sName ); } // @@ -253,8 +253,8 @@ bool Bu::Parser::hasReduction( const Bu::String &sName ) // Bu::Parser::State::State( Bu::Parser::State::Type eType, int iIndex ) : - eType( eType ), - iIndex( iIndex ) + eType( eType ), + iIndex( iIndex ) { } @@ -267,7 +267,7 @@ Bu::Parser::State::~State() // Bu::Parser::NonTerminal::NonTerminal() : - bCanSkip( false ) + bCanSkip( false ) { } @@ -277,35 +277,35 @@ Bu::Parser::NonTerminal::~NonTerminal() void Bu::Parser::NonTerminal::addProduction( Production p ) { - lProduction.append( p ); + lProduction.append( p ); } void Bu::Parser::NonTerminal::setCanSkip() { - bCanSkip = true; + bCanSkip = true; } Bu::Formatter &Bu::operator<<( Bu::Formatter &f, Bu::Parser::State::Type t ) { - switch( t ) - { - case Bu::Parser::State::typeTerminal: - return f << "typeTerminal"; + switch( t ) + { + case Bu::Parser::State::typeTerminal: + return f << "typeTerminal"; - case Bu::Parser::State::typeTerminalPush: - return f << "typeTerminalPush"; + case Bu::Parser::State::typeTerminalPush: + return f << "typeTerminalPush"; - case Bu::Parser::State::typeNonTerminal: - return f << "typeNonTerminal"; + case Bu::Parser::State::typeNonTerminal: + return f << "typeNonTerminal"; - case Bu::Parser::State::typeReduction: - return f << "typeReduction"; - } - return f << "***error***"; + case Bu::Parser::State::typeReduction: + return f << "typeReduction"; + } + return f << "***error***"; } Bu::Formatter &Bu::operator<<( Bu::Formatter &f, const Bu::Parser::State &s ) { - return f << "{" << s.eType << ": " << s.iIndex << "}"; + return f << "{" << s.eType << ": " << s.iIndex << "}"; } diff --git a/src/experimental/parser.h b/src/experimental/parser.h index 953202d..50b6afb 100644 --- a/src/experimental/parser.h +++ b/src/experimental/parser.h @@ -18,115 +18,115 @@ namespace Bu { - /** - * The base framework for a LR(1) grammar parser. Provided a proper set of - * ParserStates this will prase any input the lexer can provide. - */ - class Parser - { - public: - Parser(); - virtual ~Parser(); - - /** - * When a Lexer is pushed onto the stack it becomes the source for - * future tokens read by the parser until it is popped off the stack. - * The Parser takes ownership of every Lexer pushed onto the stack, - * and will delete it when it is popped off the stack. - */ - void pushLexer( Lexer *pLex ); - - /** - * Pop a lexer off the stack, and delete it. - */ - void popLexer(); - - Lexer::Token *popToken(); - void pushToken( Lexer::Token *pTok ); - - /** - * Execute a parse. - */ - void parse(); - - void setRootNonTerminal( int iRoot ); - void setRootNonTerminal( const Bu::String &sRoot ); - - typedef Bu::Signal1 Reduction; - - /** - * Represents a possible state, either a terminal or non-terminal symbol - * in a Production. - */ - class State - { - public: - enum Type - { - typeTerminal, - typeTerminalPush, - typeNonTerminal, - typeReduction - }; - - State( Type eType, int iIndex ); - virtual ~State(); - - //private: - Type eType; - int iIndex; - }; - - typedef Bu::List Production; - - class NonTerminal - { - public: - NonTerminal(); - virtual ~NonTerminal(); - - void addProduction( Production p ); - void setCanSkip(); - -// private: - typedef Bu::List ProductionList; - ProductionList lProduction; - bool bCanSkip; - }; - - int addNonTerminal( const Bu::String &sName, NonTerminal &nt ); - int addNonTerminal( const Bu::String &sName ); - void setNonTerminal( const Bu::String &sName, NonTerminal &nt ); - int getNonTerminalId( const Bu::String &sName ); - bool hasNonTerminal( const Bu::String &sName ); - - int addReduction( const Bu::String &sName, const Reduction &r ); - int addReduction( const Bu::String &sName ); - void setReduction( const Bu::String &sName, const Reduction &r ); - int getReductionId( const Bu::String &sName ); - bool hasReduction( const Bu::String &sName ); - - private: - bool selectProduction( int iNt, Lexer::Token *ptCur ); - void advanceState(); - - private: - typedef Bu::List LexerStack; - typedef Bu::List TokenStack; - typedef Bu::List StateStack; - typedef Bu::Array ReductionArray; - typedef Bu::Hash NameIndexHash; - typedef Bu::Array NonTerminalArray; - - LexerStack sLexer; - TokenStack sToken; - StateStack sState; - ReductionArray aReduction; - NameIndexHash hReductionName; - NonTerminalArray aNonTerminal; - NameIndexHash hNonTerminalName; - int iRootNonTerminal; - }; + /** + * The base framework for a LR(1) grammar parser. Provided a proper set of + * ParserStates this will prase any input the lexer can provide. + */ + class Parser + { + public: + Parser(); + virtual ~Parser(); + + /** + * When a Lexer is pushed onto the stack it becomes the source for + * future tokens read by the parser until it is popped off the stack. + * The Parser takes ownership of every Lexer pushed onto the stack, + * and will delete it when it is popped off the stack. + */ + void pushLexer( Lexer *pLex ); + + /** + * Pop a lexer off the stack, and delete it. + */ + void popLexer(); + + Lexer::Token *popToken(); + void pushToken( Lexer::Token *pTok ); + + /** + * Execute a parse. + */ + void parse(); + + void setRootNonTerminal( int iRoot ); + void setRootNonTerminal( const Bu::String &sRoot ); + + typedef Bu::Signal1 Reduction; + + /** + * Represents a possible state, either a terminal or non-terminal symbol + * in a Production. + */ + class State + { + public: + enum Type + { + typeTerminal, + typeTerminalPush, + typeNonTerminal, + typeReduction + }; + + State( Type eType, int iIndex ); + virtual ~State(); + + //private: + Type eType; + int iIndex; + }; + + typedef Bu::List Production; + + class NonTerminal + { + public: + NonTerminal(); + virtual ~NonTerminal(); + + void addProduction( Production p ); + void setCanSkip(); + +// private: + typedef Bu::List ProductionList; + ProductionList lProduction; + bool bCanSkip; + }; + + int addNonTerminal( const Bu::String &sName, NonTerminal &nt ); + int addNonTerminal( const Bu::String &sName ); + void setNonTerminal( const Bu::String &sName, NonTerminal &nt ); + int getNonTerminalId( const Bu::String &sName ); + bool hasNonTerminal( const Bu::String &sName ); + + int addReduction( const Bu::String &sName, const Reduction &r ); + int addReduction( const Bu::String &sName ); + void setReduction( const Bu::String &sName, const Reduction &r ); + int getReductionId( const Bu::String &sName ); + bool hasReduction( const Bu::String &sName ); + + private: + bool selectProduction( int iNt, Lexer::Token *ptCur ); + void advanceState(); + + private: + typedef Bu::List LexerStack; + typedef Bu::List TokenStack; + typedef Bu::List StateStack; + typedef Bu::Array ReductionArray; + typedef Bu::Hash NameIndexHash; + typedef Bu::Array NonTerminalArray; + + LexerStack sLexer; + TokenStack sToken; + StateStack sState; + ReductionArray aReduction; + NameIndexHash hReductionName; + NonTerminalArray aNonTerminal; + NameIndexHash hNonTerminalName; + int iRootNonTerminal; + }; Bu::Formatter &operator<<( Bu::Formatter &f, Bu::Parser::State::Type t ); Bu::Formatter &operator<<( Bu::Formatter &f, const Bu::Parser::State &s ); }; diff --git a/src/experimental/regex.cpp b/src/experimental/regex.cpp index de24935..dbe0e85 100644 --- a/src/experimental/regex.cpp +++ b/src/experimental/regex.cpp @@ -13,83 +13,83 @@ #define aSubStr ((regmatch_t *)paSubStr) Bu::RegEx::RegEx() : - pRegEx( NULL ), - bCompiled( false ), - paSubStr( NULL ) + pRegEx( NULL ), + bCompiled( false ), + paSubStr( NULL ) { } Bu::RegEx::RegEx( const Bu::String &sSrc ) : - pRegEx( NULL ), - bCompiled( false ), - paSubStr( NULL ) + pRegEx( NULL ), + bCompiled( false ), + paSubStr( NULL ) { - compile( sSrc ); + compile( sSrc ); } Bu::RegEx::~RegEx() { - if( bCompiled ) - { - regfree( re ); - delete re; - delete[] aSubStr; - } + if( bCompiled ) + { + regfree( re ); + delete re; + delete[] aSubStr; + } } void Bu::RegEx::compile( const Bu::String &sSrc ) { - if( bCompiled ) - { - regfree( re ); - delete re; - delete[] aSubStr; - bCompiled = false; - } - pRegEx = (void *)(new regex_t); + if( bCompiled ) + { + regfree( re ); + delete re; + delete[] aSubStr; + bCompiled = false; + } + pRegEx = (void *)(new regex_t); - int nErr = regcomp( re, sSrc.getStr(), REG_EXTENDED|REG_NEWLINE ); - if( nErr ) - { - size_t length = regerror( nErr, re, NULL, 0 ); - char *buffer = new char[length]; - (void) regerror( nErr, re, buffer, length ); - Bu::String s( buffer ); - delete[] buffer; - throw "???"; // BuildException( s.getStr() ); - } - bCompiled = true; - this->sSrc = sSrc; + int nErr = regcomp( re, sSrc.getStr(), REG_EXTENDED|REG_NEWLINE ); + if( nErr ) + { + size_t length = regerror( nErr, re, NULL, 0 ); + char *buffer = new char[length]; + (void) regerror( nErr, re, buffer, length ); + Bu::String s( buffer ); + delete[] buffer; + throw "???"; // BuildException( s.getStr() ); + } + bCompiled = true; + this->sSrc = sSrc; - nSubStr = re->re_nsub+1; - paSubStr = (void *)(new regmatch_t[nSubStr]); + nSubStr = re->re_nsub+1; + paSubStr = (void *)(new regmatch_t[nSubStr]); } int Bu::RegEx::getNumSubStrings() { - return nSubStr; + return nSubStr; } bool Bu::RegEx::execute( const Bu::String &sSrc ) { - sTest = sSrc; - if( regexec( re, sSrc.getStr(), nSubStr, aSubStr, 0 ) ) - return false; - return true; + sTest = sSrc; + if( regexec( re, sSrc.getStr(), nSubStr, aSubStr, 0 ) ) + return false; + return true; } void Bu::RegEx::getSubStringRange( int nIndex, int &iStart, int &iEnd ) { - iStart = aSubStr[nIndex].rm_so; - iEnd = aSubStr[nIndex].rm_eo; + iStart = aSubStr[nIndex].rm_so; + iEnd = aSubStr[nIndex].rm_eo; } Bu::String Bu::RegEx::getSubString( int nIndex ) { -// regmatch_t *Subs = aSubStr; - return Bu::String( - sTest.getStr()+aSubStr[nIndex].rm_so, - aSubStr[nIndex].rm_eo - aSubStr[nIndex].rm_so - ); +// regmatch_t *Subs = aSubStr; + return Bu::String( + sTest.getStr()+aSubStr[nIndex].rm_so, + aSubStr[nIndex].rm_eo - aSubStr[nIndex].rm_so + ); } diff --git a/src/experimental/regex.h b/src/experimental/regex.h index c83ebe8..e723450 100644 --- a/src/experimental/regex.h +++ b/src/experimental/regex.h @@ -14,31 +14,31 @@ namespace Bu { - class RegEx - { - public: - RegEx(); - RegEx( const Bu::String &sSrc ); - virtual ~RegEx(); + class RegEx + { + public: + RegEx(); + RegEx( const Bu::String &sSrc ); + virtual ~RegEx(); - void compile( const Bu::String &sSrc ); - int getNumSubStrings(); - bool execute( const Bu::String &sSrc ); - void getSubStringRange( int nIndex, int &iStart, int &iEnd ); - Bu::String getSubString( int nIndex ); - const Bu::String &getSource() - { - return sSrc; - } + void compile( const Bu::String &sSrc ); + int getNumSubStrings(); + bool execute( const Bu::String &sSrc ); + void getSubStringRange( int nIndex, int &iStart, int &iEnd ); + Bu::String getSubString( int nIndex ); + const Bu::String &getSource() + { + return sSrc; + } - private: - Bu::String sSrc; - Bu::String sTest; - void *pRegEx; - bool bCompiled; - int nSubStr; - void *paSubStr; - }; + private: + Bu::String sSrc; + Bu::String sTest; + void *pRegEx; + bool bCompiled; + int nSubStr; + void *paSubStr; + }; }; #endif diff --git a/src/experimental/regexengine.h b/src/experimental/regexengine.h index ec181c1..133d418 100644 --- a/src/experimental/regexengine.h +++ b/src/experimental/regexengine.h @@ -7,136 +7,136 @@ namespace Bu { - template class RegExEngine; - - template - class RegExEngineCore - { - friend class RegExEngine; - friend class SharedCore, RegExEngineCore >; - private: - RegExEngineCore() - { - } - - virtual ~RegExEngineCore() - { - } - - class Range - { - public: - Range( chr cLower, chr cUpper, int iTrgState ) : - cLower( cLower ), cUpper( cUpper ), iTrgState( iTrgState ) - { - } - - chr cLower; - chr cUpper; - int iTrgState; - }; - - class State - { - public: - Bu::Array aRange; - }; - - int addState() - { - aState.append( State() ); - return aState.getSize()-1; - } - - void addCompletion( int iState, chr cLower, chr cUpper, int iTrgState ) - { - aState[iState].aRange.append( Range( cLower, cUpper, iTrgState ) ); - } - - template - bool match( const str &sIn, int &iSize, int &iCompletion ) - { - bool bMatch; - int iState = 0; - iSize = 0; - for( typename str::const_iterator i = sIn.begin(); i; i++ ) - { - Bu::sio << "Finding char " << *i << " in state " << iState - << ":" << Bu::sio.nl; - bMatch = false; - for( typename Bu::Array::iterator j = - aState[iState].aRange.begin(); j; j++ ) - { - Bu::sio << " Testing range " << (*j).cLower << " - " << (*j).cUpper << Bu::sio.nl; - if( *i >= (*j).cLower && *i <= (*j).cUpper ) - { - iState = (*j).iTrgState; - bMatch = true; - iSize++; - if( iState < 0 ) - { - iCompletion = iState; - return true; - } - } - } - if( bMatch == false ) - { - return false; - } - } - - iCompletion = 0; - return true; - } - - typedef Bu::Array StateArray; - StateArray aState; - }; - - template - class RegExEngine : public SharedCore, - RegExEngineCore > - { - private: - typedef class RegExEngine MyType; - typedef class RegExEngineCore Core; - typedef class Core::Range Range; - typedef class Core::State State; - - protected: - using SharedCore::core; - using SharedCore::_hardCopy; - using SharedCore::_resetCore; - using SharedCore::_allocateCore; - - public: - RegExEngine() - { - } - - virtual ~RegExEngine() - { - } - - int addState() - { - return core->addState(); - } - - void addCompletion( int iState, chr cLower, chr cUpper, int iTrgState ) - { - core->addCompletion( iState, cLower, cUpper, iTrgState ); - } - - template - bool match( const str &sIn, int &iSize, int &iCompletion ) - { - return core->match( sIn, iSize, iCompletion ); - } - - private: - }; + template class RegExEngine; + + template + class RegExEngineCore + { + friend class RegExEngine; + friend class SharedCore, RegExEngineCore >; + private: + RegExEngineCore() + { + } + + virtual ~RegExEngineCore() + { + } + + class Range + { + public: + Range( chr cLower, chr cUpper, int iTrgState ) : + cLower( cLower ), cUpper( cUpper ), iTrgState( iTrgState ) + { + } + + chr cLower; + chr cUpper; + int iTrgState; + }; + + class State + { + public: + Bu::Array aRange; + }; + + int addState() + { + aState.append( State() ); + return aState.getSize()-1; + } + + void addCompletion( int iState, chr cLower, chr cUpper, int iTrgState ) + { + aState[iState].aRange.append( Range( cLower, cUpper, iTrgState ) ); + } + + template + bool match( const str &sIn, int &iSize, int &iCompletion ) + { + bool bMatch; + int iState = 0; + iSize = 0; + for( typename str::const_iterator i = sIn.begin(); i; i++ ) + { + Bu::sio << "Finding char " << *i << " in state " << iState + << ":" << Bu::sio.nl; + bMatch = false; + for( typename Bu::Array::iterator j = + aState[iState].aRange.begin(); j; j++ ) + { + Bu::sio << " Testing range " << (*j).cLower << " - " << (*j).cUpper << Bu::sio.nl; + if( *i >= (*j).cLower && *i <= (*j).cUpper ) + { + iState = (*j).iTrgState; + bMatch = true; + iSize++; + if( iState < 0 ) + { + iCompletion = iState; + return true; + } + } + } + if( bMatch == false ) + { + return false; + } + } + + iCompletion = 0; + return true; + } + + typedef Bu::Array StateArray; + StateArray aState; + }; + + template + class RegExEngine : public SharedCore, + RegExEngineCore > + { + private: + typedef class RegExEngine MyType; + typedef class RegExEngineCore Core; + typedef class Core::Range Range; + typedef class Core::State State; + + protected: + using SharedCore::core; + using SharedCore::_hardCopy; + using SharedCore::_resetCore; + using SharedCore::_allocateCore; + + public: + RegExEngine() + { + } + + virtual ~RegExEngine() + { + } + + int addState() + { + return core->addState(); + } + + void addCompletion( int iState, chr cLower, chr cUpper, int iTrgState ) + { + core->addCompletion( iState, cLower, cUpper, iTrgState ); + } + + template + bool match( const str &sIn, int &iSize, int &iCompletion ) + { + return core->match( sIn, iSize, iCompletion ); + } + + private: + }; }; #endif diff --git a/src/experimental/xmlreader.cpp b/src/experimental/xmlreader.cpp index f11ac04..82f4684 100644 --- a/src/experimental/xmlreader.cpp +++ b/src/experimental/xmlreader.cpp @@ -11,13 +11,13 @@ namespace Bu { subExceptionDef( XmlException ) } Bu::XmlReader::XmlReader( Stream &rInput ) : - rInput( rInput ), - iCurToken( 0 ), - iNextToken( 0 ), - bIgnoreWS( true ) + rInput( rInput ), + iCurToken( 0 ), + iNextToken( 0 ), + bIgnoreWS( true ) { - nextToken(); - stDocument(); + nextToken(); + stDocument(); } Bu::XmlReader::~XmlReader() @@ -26,148 +26,148 @@ Bu::XmlReader::~XmlReader() void Bu::XmlReader::fillBuffer() { - if( rInput.isEos() ) - return; - char buf[1024]; - int iSize = rInput.read( buf, 1024 ); - sBuf.append( buf, iSize ); + if( rInput.isEos() ) + return; + char buf[1024]; + int iSize = rInput.read( buf, 1024 ); + sBuf.append( buf, iSize ); } void Bu::XmlReader::cleanupBuffer( int iUsed ) { - for( int j = 0; j < iUsed; j++ ) - { - if( sBuf[j] == '\n' ) - { - spNextToken.iLine++; - spNextToken.iChar = 1; - } - else - { - spNextToken.iChar++; - } - } - - printf("--Deleting %d bytes from front of buffer.\n", iUsed ); - sBuf.trimFront( iUsed ); + for( int j = 0; j < iUsed; j++ ) + { + if( sBuf[j] == '\n' ) + { + spNextToken.iLine++; + spNextToken.iChar = 1; + } + else + { + spNextToken.iChar++; + } + } + + printf("--Deleting %d bytes from front of buffer.\n", iUsed ); + sBuf.trimFront( iUsed ); } int Bu::XmlReader::nextToken() { - fillBuffer(); - - int iUsed = 1; - - iCurToken = iNextToken; - spCurToken = spNextToken; - - switch( sBuf[0] ) - { - case '<': - if( !strncmp( sBuf.getStr(), "' ) - { - iNextToken = tokXmlDeclEnd; - iUsed = 2; - } - else - { - iNextToken = '?'; - } - break; - - case ' ': - case '\t': - case '\n': - case '\r': - for( int j = 1;; j++ ) - { - if( j == sBuf.getSize() ) - { - if( rInput.isEos() ) - error("Reached end of input while waiting for whitespace to end."); - - fillBuffer(); - } - if( sBuf[j] == ' ' || sBuf[j] == '\t' || - sBuf[j] == '\n' || sBuf[j] == '\r' ) - iUsed++; - else - break; - } - sStr.clear(); - sStr.append( sBuf, iUsed ); - iNextToken = tokWS; - break; - - case '=': - iNextToken = sBuf[0]; - break; - - default: - if( (sBuf[0] >= 'a' && sBuf[0] <= 'z') || - (sBuf[0] >= 'A' && sBuf[0] <= 'Z') ) - { - for( int j = 1;; j++ ) - { - if( j == sBuf.getSize() ) - { - if( rInput.isEos() ) - error("Reached end of input while waiting for a string to end."); - - fillBuffer(); - } - if( (sBuf[j] >= 'a' && sBuf[j] <= 'z') || - (sBuf[j] >= 'A' && sBuf[j] <= 'Z') ) - iUsed++; - else - break; - } - sStr.clear(); - sStr.append( sBuf, iUsed ); - iNextToken = tokIdent; - } - } - - cleanupBuffer( iUsed ); - - return iCurToken; + fillBuffer(); + + int iUsed = 1; + + iCurToken = iNextToken; + spCurToken = spNextToken; + + switch( sBuf[0] ) + { + case '<': + if( !strncmp( sBuf.getStr(), "' ) + { + iNextToken = tokXmlDeclEnd; + iUsed = 2; + } + else + { + iNextToken = '?'; + } + break; + + case ' ': + case '\t': + case '\n': + case '\r': + for( int j = 1;; j++ ) + { + if( j == sBuf.getSize() ) + { + if( rInput.isEos() ) + error("Reached end of input while waiting for whitespace to end."); + + fillBuffer(); + } + if( sBuf[j] == ' ' || sBuf[j] == '\t' || + sBuf[j] == '\n' || sBuf[j] == '\r' ) + iUsed++; + else + break; + } + sStr.clear(); + sStr.append( sBuf, iUsed ); + iNextToken = tokWS; + break; + + case '=': + iNextToken = sBuf[0]; + break; + + default: + if( (sBuf[0] >= 'a' && sBuf[0] <= 'z') || + (sBuf[0] >= 'A' && sBuf[0] <= 'Z') ) + { + for( int j = 1;; j++ ) + { + if( j == sBuf.getSize() ) + { + if( rInput.isEos() ) + error("Reached end of input while waiting for a string to end."); + + fillBuffer(); + } + if( (sBuf[j] >= 'a' && sBuf[j] <= 'z') || + (sBuf[j] >= 'A' && sBuf[j] <= 'Z') ) + iUsed++; + else + break; + } + sStr.clear(); + sStr.append( sBuf, iUsed ); + iNextToken = tokIdent; + } + } + + cleanupBuffer( iUsed ); + + return iCurToken; } void Bu::XmlReader::error( const char *sMessage ) { - throw Bu::XmlException("%d:%d: %s", - spCurToken.iLine, spCurToken.iChar, sMessage ); + throw Bu::XmlException("%d:%d: %s", + spCurToken.iLine, spCurToken.iChar, sMessage ); } void Bu::XmlReader::stDocument() { - stProlog(); + stProlog(); } void Bu::XmlReader::stProlog() { - stXmlDecl(); + stXmlDecl(); } void Bu::XmlReader::stXmlDecl() { - if( nextToken() != tokXmlDeclHead ) - error("You must begin your xml file with a declaration: "); - if( nextToken() != tokIdent ) - error("A version comes first!"); - if( sStr != "version" ) - error("No, a version!"); + if( nextToken() != tokXmlDeclHead ) + error("You must begin your xml file with a declaration: "); + if( nextToken() != tokIdent ) + error("A version comes first!"); + if( sStr != "version" ) + error("No, a version!"); } diff --git a/src/experimental/xmlreader.h b/src/experimental/xmlreader.h index d4bad1e..9615cfb 100644 --- a/src/experimental/xmlreader.h +++ b/src/experimental/xmlreader.h @@ -13,52 +13,52 @@ namespace Bu { - class Stream; + class Stream; - subExceptionDecl( XmlException ); + subExceptionDecl( XmlException ); - class XmlReader - { - public: - XmlReader( Stream &rInput ); - virtual ~XmlReader(); + class XmlReader + { + public: + XmlReader( Stream &rInput ); + virtual ~XmlReader(); - private: - Stream &rInput; - int iCurToken; - int iNextToken; - Bu::String sBuf; - Bu::String sStr; - bool bIgnoreWS; - typedef struct StreamPos - { - StreamPos() : iLine( 1 ), iChar( 1 ) { } - int iLine; - int iChar; - } StreamPos; - StreamPos spCurToken; - StreamPos spNextToken; + private: + Stream &rInput; + int iCurToken; + int iNextToken; + Bu::String sBuf; + Bu::String sStr; + bool bIgnoreWS; + typedef struct StreamPos + { + StreamPos() : iLine( 1 ), iChar( 1 ) { } + int iLine; + int iChar; + } StreamPos; + StreamPos spCurToken; + StreamPos spNextToken; - enum - { - tokXmlDeclHead = 0x100, - tokXmlDeclEnd, - tokWS, - tokIdent, - tokString - }; + enum + { + tokXmlDeclHead = 0x100, + tokXmlDeclEnd, + tokWS, + tokIdent, + tokString + }; - void fillBuffer(); - void cleanupBuffer( int iUsed ); - int nextToken(); + void fillBuffer(); + void cleanupBuffer( int iUsed ); + int nextToken(); - void stDocument(); - void stProlog(); - void stXmlDecl(); + void stDocument(); + void stProlog(); + void stXmlDecl(); - void error( const char *sMessage ); - }; + void error( const char *sMessage ); + }; }; #endif -- cgit v1.2.3