API tools faq
paste
View difference between Paste ID: piFaSULT and 6dRUqpr0
SHOW: | | - or go back to the newest paste.
1
?package
2
{
3
4
    public class GACodec extends Object

5
    {

6
        private static var SHIFT:Number = 60;

7
        private static var CAPS_ON:Number = 61;

8
        private static var CAPS_OFF:Number = 62;

9
        private static var UNICODE:Number = 63;

10
        private static var PADLENGTH:Number = 64;

11
        private static var BASELENGTH:Number = 128;

12
        private static var INVALID:Number = -1;

13
        private static var bDebug:Boolean = false;

14
        private static var s_cLPad:Array = new Array(" ", "!", "\"", "#", "$", "\'", "(", ")", "*", "+", ",", "-", ".", "/", "&", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", ":", ";", "<", "=", ">", "@", "[", "]", "_", "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z");

15
        private static var s_bReverseLPad:Array = new Array(BASELENGTH);

16
        private static var s_cUPad:Array = new Array("A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z");

17
        private static var s_bReverseUPad:Array = new Array(BASELENGTH);

18
        private static var s_cEncodePad:Array = new Array("A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "+", "/");

19
        private static var s_bDecodePad:Array = new Array(BASELENGTH);

20
21
        public function GACodec()

22
        {

23
            var _loc_1:* = NaN;

24
            _loc_1 = 0;

25
            while (_loc_1 < BASELENGTH)

26
            {

27
                

28
                s_bReverseLPad[_loc_1] = INVALID;

29
                s_bReverseUPad[_loc_1] = INVALID;

30
                s_bDecodePad[_loc_1] = INVALID;

31
                _loc_1 = _loc_1 + 1;

32
            }

33
            _loc_1 = 0;

34
            while (_loc_1 < PADLENGTH)

35
            {

36
                

37
                if (_loc_1 < s_cLPad.length)

38
                {

39
                    s_bReverseLPad[s_cLPad[_loc_1].charCodeAt(0)] = _loc_1;

40
                }

41
                if (_loc_1 < s_cUPad.length)

42
                {

43
                    s_bReverseUPad[s_cUPad[_loc_1].charCodeAt(0)] = _loc_1;

44
                }

45
                s_bDecodePad[s_cEncodePad[_loc_1].charCodeAt(0)] = _loc_1;

46
                _loc_1 = _loc_1 + 1;

47
            }

48
            return;

49
        }// end function

50
51
        private function toCharArray(param1:String) : Array

52
        {

53
            var _loc_2:* = new Array();

54
            var _loc_3:* = 0;

55
            while (_loc_3 <= (param1.length - 1))

56
            {

57
                

58
                _loc_2.push(param1.charCodeAt(_loc_3));

59
                _loc_3++;

60
            }

61
            return _loc_2;

62
        }// end function

63
64
        public function isWhiteSpace(param1:Number) : Boolean

65
        {

66
            return param1 == 32 || param1 == 13 || param1 == 10 || param1 == 9;

67
        }// end function

68
69
        private function removeWhiteSpace(param1:Array) : Number

70
        {

71
            if (param1 == null)

72
            {

73
                return 0;

74
            }

75
            var _loc_2:* = 0;

76
            var _loc_3:* = param1.length;

77
            var _loc_4:* = 0;

78
            while (_loc_4 < _loc_3)

79
            {

80
                

81
                if (!isWhiteSpace(param1[_loc_4]))

82
                {

83
                    param1[++_loc_2] = param1[_loc_4];

84
                }

85
                _loc_4++;

86
            }

87
            return _loc_2;

88
        }// end function

89
90
        private function convertToBytes(param1:String) : Array

91
        {

92
            var _loc_5:* = NaN;

93
            if (param1 == null)

94
            {

95
                return null;

96
            }

97
            var _loc_2:* = toCharArray(param1);

98
            var _loc_3:* = removeWhiteSpace(_loc_2);

99
            var _loc_4:* = new Array(_loc_3);

100
            var _loc_6:* = 0;

101
            while (_loc_6 < _loc_3)

102
            {

103
                

104
                _loc_5 = s_bDecodePad[_loc_2[_loc_6]];

105
                if (_loc_5 != INVALID)

106
                {

107
                    _loc_4[_loc_6] = _loc_5;

108
                }

109
                else

110
                {

111
                    throw new Error("Bad char (=" + _loc_2[_loc_6] + "\') at pos " + _loc_6);

112
                }

113
                _loc_6++;

114
            }

115
            return _loc_4;

116
        }// end function

117
118
        private function convertToString(param1:Array) : String

119
        {

120
            var _loc_2:* = "";

121
            if (param1 == null)

122
            {

123
                return null;

124
            }

125
            var _loc_3:* = new Array(param1.length);

126
            var _loc_4:* = 0;

127
            while (_loc_4 < param1.length)

128
            {

129
                

130
                if (param1[_loc_4] > PADLENGTH || param1[_loc_4] < 0)

131
                {

132
                    throw new Error("Bad byte (=" + param1[_loc_4] + ") at pos " + _loc_4);

133
                }

134
                _loc_3[_loc_4] = s_cEncodePad[param1[_loc_4]];

135
                _loc_2 = _loc_2 + _loc_3[_loc_4];

136
                _loc_4++;

137
            }

138
            return _loc_2;

139
        }// end function

140
141
        public function decode(param1:String) : String

142
        {

143
            var bUnicode:Array;

144
            var strInput:* = param1;

145
            if (strInput == null)

146
            {

147
                return null;

148
            }

149
            var aData:* = convertToBytes(strInput);

150
            if (bDebug)

151
            {

152
                trace("Pre encode [" + aData.toString() + "]");

153
            }

154
            var sbOut:* = new String("");

155
            var bShift:Boolean;

156
            var i:int;

157
            while (i < aData.length)

158
            {

159
                

160
                switch(aData[i])

161
                {

162
                    case CAPS_ON:

163
                    {

164
                        bShift;

165
                        break;

166
                    }

167
                    case CAPS_OFF:

168
                    {

169
                        bShift;

170
                        break;

171
                    }

172
                    case SHIFT:

173
                    {

174
                        i = (i + 1);

175
                        sbOut = sbOut + s_cUPad[aData[(i + 1)]];

176
                        break;

177
                    }

178
                    case UNICODE:

179
                    {

180
                        bUnicode = new Array(2);

181
                        i = (i + 1);

182
                        i = (i + 1);

183
                        bUnicode[0] = aData[(i + 1)] << 2 | aData[(i + 1)] >> 4;

184
                        i = (i + 1);

185
                        bUnicode[1] = aData[i] << 4 | aData[(i + 1)] >> 2;

186
                        try

187
                        {

188
                            sbOut = sbOut + String.fromCharCode(bUnicode[0] + bUnicode[1]);

189
                        }

190
                        catch (err:Error)

191
                        {

192
                            throw new Error("Cannot decode");

193
                        }

194
                        break;

195
                    }

196
                    default:

197
                    {

198
                        if (!bShift)

199
                        {

200
                            sbOut = sbOut + s_cLPad[aData[i]];

201
                        }

202
                        else

203
                        {

204
                            sbOut = sbOut + s_cUPad[aData[i]];

205
                        }

206
                        break;

207
                    }

208
                }

209
                i = (i + 1);

210
            }

211
            return sbOut;

212
        }// end function

213
214
        public function encode(param1:String) : String

215
        {

216
            var c:Number;

217
            var bL:Number;

218
            var bU:Number;

219
            var n1:Number;

220
            var n2:Number;

221
            var strInput:* = param1;

222
            if (strInput == null)

223
            {

224
                return null;

225
            }

226
            var aData:* = toCharArray(strInput);

227
            var bOut:* = new Array();

228
            var bShift:Boolean;

229
            var i:int;

230
            while (i < aData.length)

231
            {

232
                

233
                c = aData[i];

234
                if (isWhiteSpace(c))

235
                {

236
                    c;

237
                }

238
                bL = c > BASELENGTH ? (INVALID) : (s_bReverseLPad[c]);

239
                bU = c > BASELENGTH ? (INVALID) : (s_bReverseUPad[c]);

240
                if (bL != INVALID)

241
                {

242
                    if (bShift)

243
                    {

244
                        bOut.push(CAPS_OFF);

245
                        bShift;

246
                    }

247
                    bOut.push(bL);

248
                }

249
                else if (bU != INVALID)

250
                {

251
                    if (!bShift)

252
                    {

253
                        if ((i + 1) < aData.length && s_bReverseUPad[aData[(i + 1)]] != INVALID)

254
                        {

255
                            bOut.push(CAPS_ON);

256
                            bShift;

257
                        }

258
                        else

259
                        {

260
                            bOut.push(SHIFT);

261
                        }

262
                    }

263
                    bOut.push(bU);

264
                }

265
                else

266
                {

267
                    bOut.push(UNICODE);

268
                    try

269
                    {

270
                        n1;

271
                        n2 = c < 0 ? (c + 256) : (c);

272
                        bOut.push(n1 >> 2 & 63);

273
                        bOut.push((n1 << 4 | n2 >> 4) & 63);

274
                        bOut.push(n2 << 2 & 63);

275
                    }

276
                    catch (err:Error)

277
                    {

278
                        throw new Error("Cannot encode");

279
                    }

280
                }

281
                i = (i + 1);

282
            }

283
            if (bDebug)

284
            {

285
                trace("Pre decode [" + bOut.toString() + "]");

286
            }

287
            return convertToString(bOut);

288
        }// end function

289
290
    }

291
}
        

    


            


                                


        

            



                
    

        Public Pastes
    

    
            

    

                    

        

    





    


    
    
    
    
    
    
    
    




    


    



                

            We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.             OK, I Understand
        

    
                

            

                
                    
                
            

            

                Not a member of Pastebin yet?

                Sign Up, it unlocks many cool features!