├── README.md
└── crack.py


/README.md:
--------------------------------------------------------------------------------
  1 | # crack-yakpro-po    
  2 | 破解由 `YAK Pro - Php Obfuscator` 混淆PHP代码的手段    
  3 | 
  4 | ## 说明   
  5 | 
  6 | 本脚本执行恢复还原度80%，剩下20%可手工还原，如:排版和逻辑等效替换，非全自动破解
  7 | 
  8 | ## 环境
  9 | 
 10 | ``` 
 11 | Windows 系统
 12 | Python2.7.x
 13 | ```
 14 | 
 15 | ## 依赖
 16 | 
 17 | ``` sh
 18 | pip install pickle
 19 | pip install pyperclip
 20 | pip install optparse
 21 | ```
 22 | 
 23 | ## 命令
 24 | 
 25 | ```
 26 | [USAGE]
 27 | python crack.py [options]
 28 | 
 29 | [OPTION]
 30 | -s --savedatafn <filename>  #指定临时文件名，该临时文件存储临时态的代码数据
 31 | -o --cache                  #是否关闭读取缓存，第一次使用必须关闭，每次指明则会重新训练数据
 32 | -f --mktplfile              #生成破解模板文件
 33 | -c --cachefn    <filename>  #指定缓存保存的文件，该缓存文件存储了序列化训练好的数据
 34 | -t --target     <filename>  #指定需要破解的文件，该文件被 Yak Pro 混淆说加密
 35 | 
 36 | ```
 37 | 
 38 | ## 解释
 39 | 
 40 | crack.py 的代码可读性比较差，编写的时候注意力全放在如何将代码混淆的还原度和效率提高，减少人工成本
 41 | 
 42 | 所以没遵守任何编码规范，逻辑也看起来比较乱几乎很难一眼读懂。最底下有对破解的思路简单说明，如果有想
 43 | 
 44 | 把代码完善度和可读性进行化优化或者重构想法的朋友可以联系我交流交流: 920248921@qq.com
 45 | 
 46 | 
 47 | ## 使用方法:
 48 | 
 49 |   1. 生成缓存文件（必须）:
 50 |   ``` bash
 51 |   python crack.py -t your_encode_file.php -o
 52 |   ```
 53 |   your_encode_file 改为你的加密文件名，需要放在同一目录下，生成缓存文件名这一步很关键，后面的命令
 54 |   都依赖此条，请务必先执行，如果文件大的话，计算时间也会比较久，请耐心等待，生成一次后，就无需在执行
 55 |   此命令了。一次生成，无限使用
 56 |   
 57 |   
 58 |   2. 生成破解模板文件(可选):
 59 |   ```
 60 |   python crack.py -f
 61 |   ```
 62 |   执行后本地会生成 你的文件名.dec.php 的文件模板，可以打开看看
 63 |   
 64 |   
 65 |   3. 破解标签（核心）
 66 |   
 67 |   > 打开php代码，找到你想破解的块，然后复制第一个goto 如:
 68 |   
 69 |   ``` php
 70 |   public function xxx{ goto abcde; ...后面省略n个字}
 71 |   ```
 72 |   > 复制如上 abcde标签，到命令行进行代码解码
 73 |   ``` bash
 74 |   python crack.py abcde
 75 |   ```
 76 |   > 然后就会返回破解后的结果，结果看起来有点怪，需要第四步手工排版和逻辑等效替换调整一下
 77 |   
 78 |   
 79 |   4. 逻辑等效替换
 80 |   破解的代码中会经常看到如下形式
 81 |   
 82 |   ```php
 83 |   /*if epAfl */
 84 |   if (!($uid < 1)) {
 85 |   $card_id = intval($_GPC["card_id"]);
 86 |   /*if m0FKM */
 87 | 
 88 |   }
 89 |   return $this->result(1, "非法进入");
 90 |   gs0uX: $card_id = intval($_GPC["card_id"]);
 91 |   /*if m0FKM */
 92 |   ```
 93 |   
 94 |   其中 /\*if xxxxx \*/ 表示下一行代码的标签 xxxxx 会是一个if判断语句，之所以不采用全自动替换if代码
 95 |   是因为 yakpro 加密方法将 while 循环使用 if 替换了， 自动替换会导致解码工具死循环输出
 96 |   
 97 |   所谓等效替换就是，尽可能让代码量变少，以还原出最有可能性的代码，上面的PHP就可以等效替换成如下
 98 |   ```php
 99 |   if ($uid < 1) {
100 |      return $this->result(1, "非法进入");
101 |   }
102 |   $card_id = intval($_GPC["card_id"]);
103 |   /*if m0FKM */
104 |   ```
105 |   类似的还有很多，此处不一一举例了
106 |   
107 | 
108 | 
109 | 
110 | ## 太麻烦了？
111 | 联系主人，有偿破解代码:  920248921@qq.com
112 |    
113 |  
114 | 
115 | ## 破解思路: 
116 | 
117 | ##### 0x00 Yarkpo 混淆代码的特征主要有两个
118 | 1. goto 代替流程
119 | 2. 字符串用10进制、16进制编码
120 | 
121 | `这两个特征在文本中特别明显，如下`
122 | 
123 | ``` php
124 | 
125 | <?php
126 | goto xmr59; xmr59: defined("\111\x4e\137\111\x41") or exit("\101\x63\143\x65\x73\163\x20\x64\145\156\151\x65\x64"); 
127 | goto a5gDB; Tk8Vg: require_once ROOT_PATH . "\x6d\x6f\144\145\x6c\x2f\143\x6f\x6d\x6d\x6f\x6e\x2e\160\150\160"; 
128 | goto j7igX; MRNIE: require_once ROOT_PATH . "\x6d\x6f\x64\x65\154\57\156\157\x74\x69\143\x65\56\160\x68\x70"; 
129 | goto YiQux; a5gDB: !defined("\122\x4f\117\x54\x5f\x50\101\x54\110") && 
130 | define("\x52\x4f\117\124\137\x50\101\x54\110", 
131 | IA_ROOT . "\57\x61\144\x64\x6f\156\x73\x2f\153\165\156\144\x69\x61\156\137\146\141\x72\155\57"); 
132 | goto EpukA; EpukA: 
133 | include ROOT_PATH . "\151\156\x63\x2f\x77\x65\x62\x2f\146\x75\156\143\x74\x69\157\156\56\151\x6e\143\56\160\x68\160"; 
134 | goto Tk8Vg; j7igX: require_once ROOT_PATH . "\155\157\144\x65\x6c\57\x75\163\x65\x72\x2e\x70\x68\160"; 
135 | goto MRNIE; YiQux: class Farm_Distribution { ...
136 | ```
137 | 
138 | ##### 0x01 先说说第2个特征，字符串编码的破解思路
139 | 
140 | 其实这个字符串编码严格意义都不算是什么加密手段，只不过把汉字或者ASCII符号转换成 `8进制` 或 `16进制` 这两种数字编码
141 | 
142 | 仔细观察下面这一串，不难发现这一串有的是8进制编码，如 `\101`，有的是16进制编码如 `\x6f` ，也就是8进制和16进制的混合编码
143 | 
144 | `\101\x63\143\x65\x73\163\x20\x64\145\156\151\x65\x64`
145 | 
146 | 对于这种编码，在 python 中直接黏贴就可以解析出对应的 ASCII 字符， 但如果是中文， python 的交互式shell还直接解析不出来
147 | 
148 | 可以写 py 脚本头部加上 #coding:utf-8 然后一个最简单的反编码器就出来了
149 | 
150 | ``` python
151 | #coding: utf-8
152 | #python2.7
153 | #解析英文
154 | print "\101\x63\143\x65\x73\163\x20\x64\145\156\151\x65\x64"
155 | #解析中文
156 | print "\344\277\235\345\xad\230\xe6\x88\x90\345\x8a\x9f"
157 | ```
158 | 
159 | 但如果是对于一整篇密文，这里就不能直接print了，最起码需要使用正则把他们匹配出来，然后
160 | 
161 | 在结合 char() 等函数进行解码， 代码如下:
162 | 
163 | ``` python
164 | #将数字编码转成字符
165 | def changeStrcode(inpCode):
166 |     inpCode = re.sub(r"\\\\",r"\\",inpCode);  #如果是双斜杠，这替换成单斜杆
167 | 
168 |     strlist = re.findall(r"\\\d{2,3}",inpCode); #匹配2-3个数字，2个是16进制 3个是8进制
169 | 
170 |     for string in strlist:
171 |         repStr = strdecode(string);
172 |         inpCode = inpCode.replace(string, repStr);
173 |     return inpCode;
174 | 
175 | def strdecode(string):
176 |     strlist = string.split("\\")[1:];
177 |     res = ""
178 |     try:
179 |         for i in strlist:
180 |             if "x" in i:
181 |                 num = int(i[1:],16);        #使用16进制解码
182 |             else :
183 |                 num = int(i,8);             #使用8进制解码
184 |             res += chr(num);
185 |     except:
186 |         pass
187 |     return res;
188 | ```
189 | 
190 | 跑完上面两个函数，前面的明文也就变成了如下，是不是舒服了一点
191 | ``` PHP
192 | <?php
193 | goto xmr59; xmr59: defined("IN_IA") or exit("Access denied"); 
194 | goto a5gDB; Tk8Vg: require_once ROOT_PATH . "model/common.php"; 
195 | goto j7igX; MRNIE: require_once ROOT_PATH . "model/notice.php"; 
196 | goto YiQux; a5gDB: !defined("ROOT_PATH") && define("ROOT_PATH", IA_ROOT . "/addons/kundian_farm/"); 
197 | goto EpukA; EpukA: include ROOT_PATH . "inc/web/function.inc.php"; 
198 | goto Tk8Vg; j7igX: require_once ROOT_PATH . "model/user.php"; 
199 | goto MRNIE; 
200 | YiQux: class Farm_Distribution { ...
201 | ```
202 | 
203 | ##### 0x02 下面说说第二个goto特征
204 | 
205 | 现在流行的编程语言基本不会再用goto了，goto越多代码越乱
206 | 
207 | . 首先研究一下 PHP 中goto 的运作原理
208 | 
209 | ```PHP
210 | <?php
211 | 
212 | foo: goto coo;
213 | doo: echo "doo";
214 | coo: echo "coo";
215 | goto eoo;
216 | eoo:
217 | ?>
218 | ```
219 | 执行结果就是
220 | > coo
221 | 
222 | 其中的执行顺序：
223 | 1. goto coo;
224 | 2. echo 'coo';
225 | 3. goto eoo;
226 | 
227 | 
228 | 两个特点：
229 | 1. 执行到标签时，标签身后代码会被执行，不一定非要goto才触发
230 | 2. goto 跳过去后就算执行完了所有代码不会回溯之前的位置，除非是用goto跳回来的
231 | 
232 | 
233 | 然后使用深度优先替换： 见到一个goto就替换一个
234 | 
235 | ``` python
236 | labelList = re.findall(r"([a-zA-Z0-9_]{5}): ",srcCode);
237 | for labelName in labelList:
238 |     labelValue = re.findall(r""+labelName+": (.*?)\s+[a-zA-Z0-9_]{5}:", srcCode)[0];
239 |     srcCode.replace("goto "+labelName+";", labelValue);
240 | ```
241 | 
242 | 上面指摘去了部分核心代码，运行结果如下
243 | ``` PHP
244 | <?php
245 | defined("IN_IA") or exit("Access denied");
246 | !defined("ROOT_PATH") && define("ROOT_PATH", IA_ROOT . "/addons/kundian_farm/");
247 | include ROOT_PATH . "inc/web/function.inc.php";
248 | require_once ROOT_PATH . "model/common.php";
249 | require_once ROOT_PATH . "model/user.php";
250 | require_once ROOT_PATH . "model/notice.php";
251 | ```
252 | 
253 | 


--------------------------------------------------------------------------------
/crack.py:
--------------------------------------------------------------------------------
  1 | #!coding: utf-8
  2 | import re
  3 | import os
  4 | import sys
  5 | import pickle
  6 | import pyperclip
  7 | reload(sys);
  8 | sys.setdefaultencoding('utf8');
  9 | from optparse import OptionParser
 10 | 
 11 | #复制剪切板
 12 | #if模板
 13 | 
 14 | #是否开启缓存加快运行速度,重刷缓存请设置为0
 15 | openCache = 1
 16 | 
 17 | #目标文件名
 18 | targetfn = "test.php"
 19 | 
 20 | #缓存数据文件名
 21 | cachefn = "cache.txt"
 22 | 
 23 | #目的文件名存储content
 24 | savedatafn = "tmp.php"
 25 | 
 26 | #目的破解模板文件
 27 | tpldatafn = targetfn.split(".")[0] + ".dec.php"
 28 | 
 29 | #核心数据结构
 30 | """
 31 | labelData:{
 32 |     'type': labelType,
 33 |     'dict': labelDict,
 34 | }
 35 | 
 36 | labelDict : {
 37 |     'labe1': {value:'xxx', type:'if', access:True},
 38 |     'labe2': {value:'xxx', type:'fe', access:False},
 39 | }
 40 | 
 41 | labelType : {
 42 |     'if': [labe1, labe2],
 43 |     'fe': [labe3, labe4],
 44 |     'od': [labe5, labe6],
 45 | }
 46 | """
 47 | 
 48 | #将数字编码转成字符
 49 | def changeStrcode(inpCode):
 50 |     inpCode = re.sub(r"\\\\",r"\\",inpCode);
 51 | 
 52 |     strlist = re.findall(r"\\\w{2,3}",inpCode);
 53 | 
 54 |     for string in strlist:
 55 |         repStr = strdecode(string);
 56 |         inpCode = inpCode.replace(string, repStr);
 57 | 
 58 |     inpCode = inpCode.replace("\n", "\\n");
 59 |     return inpCode;
 60 | 
 61 | #单字符判断是八进制还是十六进制
 62 | def strdecode(string):
 63 |     strlist = string.split("\\")[1:];
 64 |     res = ""
 65 |     try:
 66 |         for i in strlist:
 67 |             if "x" in i:
 68 |                 num = int(i[1:],16);
 69 |             else :
 70 |                 num = int(i,8);
 71 |             res += chr(num);
 72 |     except:
 73 |         pass
 74 |     return res;
 75 | 
 76 | 
 77 | 
 78 | #去除单标签
 79 | def removeLabel(content):
 80 |     labelLists = re.findall(r"\s+([a-zA-Z0-9_]{5}):",content);
 81 | 
 82 |     for label in labelLists:
 83 |         matches = re.findall(r"goto "+label+";", content);
 84 | 
 85 |         if len(matches) == 0:
 86 |             content = re.sub(r""+label+":", "", content);
 87 |     return content;
 88 | 
 89 | 
 90 | #去除双重连续goto
 91 | def removeGoto(value):
 92 |     doubleGoto = re.findall("(goto \w{5};).*?(goto \w{5};)" , value);
 93 |     if len(doubleGoto) != 0:
 94 |         rmLable = doubleGoto[0][1];
 95 |         value = value.replace(rmLable,'');
 96 |     return value;
 97 | 
 98 | 
 99 | #简单排版
100 | def simpleFormat(content):
101 |     for key in re.findall(r"\w{5}: ",content):
102 |         content = content.replace(key, "\n"+key);
103 |     for pub in re.findall(r"public function",content):
104 |         content = content.replace(pub, "\n"+pub);
105 |     for pub in re.findall(r"private function",content):
106 |         content = content.replace(pub, "\n"+pub);
107 |     return content
108 | 
109 | 
110 | #导出标签键值
111 | def getLabel(content):
112 |     labelDict = { };
113 |     labelType = {
114 |         'od': [],
115 |         'if': [],
116 |         'fe': [],
117 |         'sw': []
118 |     };
119 | 
120 |     labelList = re.findall(r"([a-zA-Z0-9_]{5}): ",content);
121 |     for name in labelList:
122 | 
123 |         #获取所有标签对应的值;
124 |         value = re.findall(r""+name+":\s+(.*?)\s+\w{5}:", content);
125 | 
126 |         #重新调整最后一个标签的正则
127 |         if len(value) == 0:
128 |             #value = re.findall(r""+name+": (.*?)$", content);
129 |             value = ""
130 |         else:
131 |             value = value[0];
132 | 
133 |         #循环次数
134 |         i=30;
135 |         #动态正则
136 |         mlb = ".*?}";
137 | 
138 | 
139 |         #收录foreach标签
140 |         if "foreach " in value:
141 |             while i>0:
142 |                 i-=1;
143 |                 value = re.findall(r""+name+": (foreach .*?{"+mlb+".*?goto \w{5};)",content, re.S);
144 |                 rbraces = value[0].count("}");
145 |                 lbraces = value[0].count("{");
146 |                 if lbraces > rbraces:
147 |                     mlb = mlb + mlb * (lbraces - rbraces)
148 |                 elif lbraces == rbraces:
149 |                     break;
150 | 
151 |             if len(value) != 0:
152 |                 value = value[0].replace('\n','')
153 |                 gotoList = re.findall(r"goto \w{5};", value);
154 |                 if len(gotoList) > 1:
155 |                     prefix = value.split('{')[0];
156 |                     lastGoto = gotoList.pop();
157 |                     firstGoto = gotoList[0];
158 |                     value = prefix + '{' + firstGoto + '}' + lastGoto;
159 |                 labelDict[name] = {'type':'fe', 'value':value, 'access':False};
160 |                 labelType['fe'].append(name);
161 | 
162 |         #收录switch
163 |         elif "switch (" in value :
164 |             while i>0:
165 |                 i-=1;
166 |                 value = re.findall(r""+name+": (switch .*?{"+mlb+".*?goto \w{5};)",content, re.S);
167 |                 if value:
168 |                     rbraces = value[0].count("}");
169 |                     lbraces = value[0].count("{");
170 |                     if lbraces > rbraces:
171 |                         mlb = mlb + mlb * (lbraces - rbraces)
172 |                     elif lbraces == rbraces:
173 |                         break;
174 | 
175 |             if len(value) != 0:
176 |                 value = value[0].replace('\\n','');
177 |                 lpos = value.find('{');
178 |                 rpos = value.rfind('}');
179 |                 inner = value[lpos:rpos];
180 |                 prefix = value[:lpos];
181 |                 caseList = re.findall(r"(case .*?goto \w{5};)", inner);
182 | 
183 |                 #default 情况复杂暂不处理
184 |                 #defaList = re.findall(r"(default: .*?goto \w{5};)",value);
185 |                 #if not defaList:
186 |                 #    defaStr = '';
187 |                 #else:
188 |                 #    defaStr = defaList[0];
189 | 
190 |                 value = prefix + '{\n' + '\n'.join(caseList) + '\n}'
191 |                 labelDict[name] = {'type':'sw', 'value':value, 'access':False};
192 |                 labelType['sw'].append(name);
193 | 
194 |         #收录if标签
195 |         elif "if " in value:
196 |             while i>0:
197 |                 i-=1;
198 |                 value = re.findall(r""+name+": (if.*?{"+mlb+".*?goto \w{5};)", content, re.S);
199 |                 rbraces = value[0].count("}");
200 |                 lbraces = value[0].count("{");
201 |                 if lbraces > rbraces:
202 |                     mlb = mlb + mlb * (lbraces - rbraces)
203 |                 elif lbraces == rbraces:
204 |                     break;
205 | 
206 |             if len(value) != 0:
207 |                 value = value[0].replace('\n','')
208 |                 gotoList = re.findall(r"goto \w{5};", value);
209 |                 if len(gotoList) > 1:
210 |                     prefix = value.split('{')[0];
211 |                     lastGoto = gotoList.pop();
212 |                     firstGoto = gotoList[0];
213 |                     value = prefix + '{' + firstGoto + '}' + lastGoto;
214 |                 labelDict[name] = {'type':'if', 'value':value, 'access':False};
215 |                 labelType['if'].append(name);
216 | 
217 |         #收录普通标签
218 |         else:
219 |             #去除双重goto
220 |             value = removeGoto(value)
221 |             if value and value[0] == '}':
222 |                 value = '';
223 |             labelDict[name] = {'type':'od', 'value':value, 'access':False};
224 |             labelType['od'].append(name);
225 | 
226 |     labelData = {
227 |        'dict': labelDict,
228 |        'type': labelType,
229 |     }
230 |     return labelData;
231 | 
232 | 
233 | #训练各类标签
234 | def trainLabel(labelData):
235 | 
236 |     labelDict = labelData['dict'];
237 |     labelType = labelData['type'];
238 | 
239 |     def train(dictType):
240 |         for lbidx in labelType[dictType]:
241 |             lbvalue = labelDict[lbidx]['value'];
242 | 
243 |             while "goto" in lbvalue:
244 |                 lbnxt = re.findall(r"goto (\w{5});", lbvalue)[0];
245 |                 lbtype = labelDict[lbnxt]['type'];
246 | 
247 |                 if lbtype == 'fe':
248 |                     rpstr = "/*foreach "+lbnxt+" */\n";
249 |                     if not labelDict[lbnxt]['access']:
250 |                         labelDict[lbnxt]['access'] = True;
251 |                         rpstr += labelDict[lbnxt]['value'];
252 | 
253 |                 elif lbtype == 'sw':
254 |                     rpstr = "/*switch "+lbnxt+" */\n";
255 |                     if not labelDict[lbnxt]['access']:
256 |                         labelDict[lbnxt]['access'] = True;
257 |                         rpstr += labelDict[lbnxt]['value'];
258 | 
259 |                 elif lbtype == 'if':
260 |                     rpstr = "/*if "+lbnxt+" */\n";
261 |                     if not labelDict[lbnxt]['access']:
262 |                         labelDict[lbnxt]['access'] = True;
263 |                         rpstr += labelDict[lbnxt]['value'];
264 | 
265 |                 elif lbtype == 'od':
266 |                     rpstr = labelDict[lbnxt]['value'];
267 | 
268 |                 else:
269 |                     print "UNKNOW TYPE"
270 |                     sys.exit();
271 | 
272 |                 lbvalue = lbvalue.replace("goto "+lbnxt+";", rpstr);
273 | 
274 |             labelDict[lbidx]['value'] = lbvalue;
275 |     
276 | 
277 |     train('od');
278 |     train('if');
279 |     train('fe');
280 |     train('sw');
281 | 
282 |     return {'type':labelType, 'dict':labelDict};
283 | 
284 | #交换条件if
285 | def switchIf(labelData):
286 |     for iflb in labelData['type']['if']:
287 | 
288 |         ifvl = labelData['dict'][iflb]['value'];
289 | 
290 |         condition = re.findall(r"if \(!(\(.*?\))\)", ifvl);
291 | 
292 |         if condition:
293 | 
294 |             gotoList = re.findall(r"(goto \w{5};)", ifvl);
295 | 
296 |             if len(gotoList) == 2:
297 | 
298 |                 newifvl = 'if '+ condition[0] + '{ ' + gotoList[1] + ' } ' + gotoList[0];
299 |                 labelData['dict'][iflb]['value'] = newifvl;
300 | 
301 |     return labelData;
302 | 
303 | #去除return 后面的goto
304 | def returnRm(labelData):
305 |     for odlb in labelData['type']['od']:
306 |         odvl = labelData['dict'][odlb]['value'];
307 | 
308 |         rtncode = re.findall(r"(return .*?;)",odvl);
309 |         if rtncode:
310 |             labelData['dict'][odlb]['value'] = rtncode[0];
311 | 
312 |     return labelData;
313 |     
314 | #格式化输出结果
315 | def formatRes(string):
316 | 
317 |     if ";" in string:
318 |         string = string.replace(";",";\n");
319 | 
320 |     if "{" in string:
321 |         string = string.replace("{","{\n");
322 | 
323 |     if "}" in string:
324 |         string = string.replace("}","\n}\n");
325 | 
326 |     res = ""
327 | 
328 |     for s in string.split("\n"):
329 |         res += s.strip() + "\n";
330 | 
331 |     print res;
332 |     pyperclip.copy(res.encode("utf-8"));
333 | 
334 | 
335 | #生成手工破解框架文件
336 | def mktplFile(content, labelDict):
337 | 
338 |     incres = "<?php\n\n";
339 |     topcode = re.findall(r".*?class", content)[0] + "\n";
340 | 
341 |     if re.findall(r"goto (\w{5});",topcode):
342 |         topcode = labelDict[re.findall(r"goto (\w{5});",topcode)[0]]['value'];
343 |         incres += topcode.replace(";", ";\n");
344 | 
345 |     incres += re.findall(r"class.*?{", content)[0] + "\n";
346 | 
347 |     for func in re.findall(r"(public function.*?){", content):
348 |         incres += "    "+func + "{\n\n    }//pub\n\n"
349 |     for func in re.findall(r"(private function.*?){", content):
350 |         incres += "    "+func + "{\n\n    }//pri\n\n"
351 |     incres += "}//class"
352 |     print tpldatafn;
353 |     open(tpldatafn,"w").write(incres);
354 | 
355 | 
356 | #main
357 | if __name__ == "__main__":
358 |     usage = "Usage: %prog ";
359 | 
360 |     parser = OptionParser(usage=usage);
361 | 
362 |     parser.add_option('-o','--cache', action='store_true', dest='openCache');
363 |     parser.add_option('-f','--mktplfile',action='store_true', dest='mktplfile');
364 |     parser.add_option('-c','--cachefn', type='string', dest='cachefn');
365 |     parser.add_option('-t','--target', type='string', dest='targetfn');
366 |     parser.add_option('-s','--savedatafn', type='string', dest='savedatafn');
367 | 
368 |     (options, args) = parser.parse_args();
369 |     #print options;
370 | 
371 |     if options.openCache:
372 |         openCache = 0;
373 | 
374 |     if options.targetfn:
375 |         targetfn = options.targetfn;
376 | 
377 |     if options.cachefn:
378 |         cachefn = options.cachefn;
379 | 
380 |     if options.savedatafn:
381 |         savedatafn = options.savedatafn;
382 | 
383 |     if openCache:
384 |         if not os.path.exists(savedatafn):
385 |             print savedatafn + 'is not found';
386 |             sys.exit();
387 | 
388 |         if not os.path.exists(cachefn):
389 |             print cachefn + 'is not found';
390 |             sys.exit();
391 | 
392 |         content = open(savedatafn, 'r').read();
393 |         labelData = pickle.loads(open(cachefn,'r').read());
394 |         
395 |     else:
396 |         content = open(targetfn).read();
397 |         content = removeLabel(content);
398 |         content = changeStrcode(content);
399 |         content = simpleFormat(content);
400 |         content = content.replace("\n\n\n", "\n");
401 | 
402 |         open(savedatafn,"w").write(content);
403 |         print "dump content ok";
404 |         labelData = getLabel(content);
405 |         labelData = switchIf(labelData);
406 |         labelData = returnRm(labelData);
407 |         labelData = trainLabel(labelData);
408 |         open(cachefn,"w").write(pickle.dumps(labelData));
409 |         print "dump labelData ok";
410 |     
411 | 
412 |     if options.mktplfile:
413 |         mktplFile(content,labelData['dict']);
414 |     elif len(args)>0:
415 |         label = args[0]
416 |         formatRes(labelData['dict'][label]['value']);
417 | 
418 | 


--------------------------------------------------------------------------------