SmaliParser.js

  1. const _fs_ = require('fs');
  2. const _es_ = require('event-stream');
  5. var ut = require("./Utils.js"); 
  6. var OPCODE = require("./Opcode.js");
  7. var CONST = require("./CoreConst.js");
  8. const CLASS = require("./CoreClass.js");
  9. const Event = require("./Event.js");
  10. const Logger = require("./Logger.js")();
  11. const Accessor = require("./AccessFlags");
  13. const SML_MAIN=0;
  14. const SML_METH=1;
  15. const SML_ANNO=2;
  16. const SML_PSWITCH=3;
  18. const ERR_PARSE=0;
  19. const LOG_DBG = false;
  21. var LEX = CONST.LEX;
  23. // todo voir WABT, square attack, mesh
  25. var LOG = {
  26.     DEBUG: function(txt){
  27.         if(LOG_DBG) console.log(txt); 
  28.     }
  29. };
  31. // end of core class
  33. var Checker = {
  34.     isBasicType: function(c){
  35.         return (CONST.TYPES[c] != undefined);
  36.     },
  37.     isObjectType: function(c){
  38.         return c=="L";
  39.     },
  40.     makeFnHashcode: function(modif,cls,name,args,ret){
  41.         let xargs = "";
  42.         for(let i in args) xargs+="<"+args[i]._hashcode+">";
  43.         return modif._name+"|"+cls.name+"|"+name+"|"+xargs+"|"+ret._hashcode;
  44.     },
  45.     makeFieldHashcode: function(modif,cls,name,type){
  46.         //console.log(type);
  47.         return modif._name+"|"+cls.name+"|"+name+"|"+type._hashcode;
  48.     }
  49. };
  52. /** 
  53.  * Represent the Smali parser 
  54.  * @class
  55.  */
  56. class SmaliParser
  57. {
  58.     constructor(context=null){
  59.         this.ctx = context;
  60.         this.state = null; //  state of the parser
  61.         this.subject = null; // parsed smali file
  62.         
  63.         this.obj = null;
  64.         this.objReady = false;
  66.         this.__tmp_meth = null;
  67.         this.__tmp_block = null;
  69.         this.__instr_ctr = null;
  70.         this.__instr_line = null;
  72.         this.currentLine = null;
  74.         let self = this;
  75.         this.__appendBlock_callback = {
  76.             // disabled for perform reasons
  77.             /*basicblock: function(meth,block){
  78.                 this.ctx.bus.send(new Event.Event({
  79.                     type: "disass.bb.new" 
  80.                 }));
  81.             },*/
  82.             datablock: function(meth,block){
  83.                 self.ctx.bus.send(new Event.Event({
  84.                     type: "disass.datablock.new",
  85.                     data: block 
  86.                 }));
  87.             }
  88.         };
  89.     }
  91.     setContext(context){
  92.         this.ctx = context;
  93.     }
  95.     isModifier(name){
  96.         for(let i in LEX.MODIFIER) 
  97.             if(LEX.MODIFIER[i]==name) 
  98.                 return true;
  99.         return false;
  100.     }
  102.     modifier(src){
  103.         if(src instanceof String) src=src.split(LEX.TOKEN.SPACE);
  104.         let mod = new Accessor.AccessFlags() , next=true;
  106.         //if(src.length<2) return ERR_PARSE;
  107.         for(let i=0; i<src.length && next; i++){
  108.             mod._match++;
  109.             switch(ut.trim(src[i])){
  110.                 case LEX.MODIFIER.PRIVATE:
  111.                     mod.private = true;
  112.                     break;
  113.                 case LEX.MODIFIER.PROTECTED:
  114.                     mod.protected = true;
  115.                     break;
  116.                 case LEX.MODIFIER.PUBLIC:
  117.                     mod.public = true;
  118.                     break;
  119.                 case LEX.MODIFIER.STATIC:
  120.                     mod.static = true;
  121.                     break;
  122.                 case LEX.MODIFIER.VOLATILE:
  123.                     mod.volatile = true;
  124.                     break;
  125.                 case LEX.MODIFIER.ABSTRACT:
  126.                     mod.abstract = true;
  127.                     break;
  128.                 case LEX.MODIFIER.FINAL:
  129.                     mod.final = true;
  130.                     break;
  131.                 case LEX.MODIFIER.CONSTR:
  132.                     mod.construct = true;
  133.                     break;
  134.                 case LEX.MODIFIER.SYNTHETIC:
  135.                     mod.synth = true;
  136.                     break;
  137.                 case LEX.MODIFIER.ENUM:
  138.                     mod.enum = true;
  139.                     break;
  140.                 case LEX.MODIFIER.TRANSIENT:
  141.                     mod.transient = true;
  142.                     break;
  143.                 case LEX.MODIFIER.DECLSYNC:
  144.                     mod.declsync = true;
  145.                     break;
  146.                 case LEX.MODIFIER.BRIDGE:
  147.                     mod.bridge = true;
  148.                     break;
  149.                 case LEX.MODIFIER.VARARG:
  150.                     mod.varargs = true;
  151.                     break;
  152.                 case LEX.MODIFIER.NATIVE:
  153.                     mod.native = true;
  154.                     break;
  155.                 case LEX.MODIFIER.INTERFACE:
  156.                     mod.interface = true;
  157.                     break;
  158.                 case LEX.MODIFIER.ANNOTATION:
  159.                     mod.annotation = true;
  160.                     break;
  161.                 case LEX.MODIFIER.STRICTFP:
  162.                     mod.strictfp = true;
  163.                     break;
  164.                 case LEX.MODIFIER.SYNCHRONIZED:
  165.                     mod.synchronized = true;
  166.                     break;
  167.                 default:
  168.                     next=false;
  169.                     mod._match--;
  170.                     break;
  171.             }
  172.         }
  174.         if(LOG_DBG){
  175.             LOG.DEBUG("[parser::modifier] "+mod.sprint());
  176.         }
  177.         return mod;
  178.     }
  180.     fqcn(src){
  181.         if(src.length==0) return ERR_PARSE;
  182.         let raw="";
  183.         raw = (src instanceof Array)? src[0] : src;
  185.         // remove additional chars : "L"  at begin and ";" at end. 
  186.         // console.log("PARSER::FQCN > ",src);
  187.         let s=raw.substr(1,raw.length-2);
  188.         while(s.indexOf("/")>-1) s=s.replace("/",".");
  189.         
  190.         LOG.DEBUG("[parser::fqcn] "+s);
  191.         return s; 
  192.     }
  194.     fspath(src){
  195.         let s=src;
  196.         s = s.substr(s.indexOf(LEX.TOKEN.DELIMITER)+1);
  197.         s = s.substr(0,s.indexOf(LEX.TOKEN.DELIMITER));
  198.         LOG.DEBUG("[parser::fspath] "+s);
  199.         return s;
  200.     }
  202.     // char 
  203.     basicTypes(c){
  204.         return CONST.TYPES[c];
  205.     }
  207.     class(src){
  208.         let fqcn=null,end=-1;
  209.         LOG.DEBUG("---------------------------------------------\n[parser::class] Start ");
  211.         //console.log("[?] Instruction parsed : "+OPCODE.CTR);
  212.         if(src instanceof String)
  213.             src=ut.trim(src).split(LEX.STRUCT.SPACE); 
  214.         
  215.         if(src[0]==LEX.STRUCT.CLASS)   src.shift();
  217.         this.obj = new CLASS.Class();
  218.         //console.log(src);
  219.         // parse modifiers
  220.         this.obj.modifiers = this.modifier(src);
  221.         //console.log(src);
  223.         // clean src with identified modifier
  224.         for(let i=0; i<this.obj.modifiers._match; i++) src.shift();
  226.         // console.log(src);
  227.         // parse nam
  228.         fqcn = this.fqcn(src);
  229.         end = fqcn.lastIndexOf(".");
  230.         this.obj.fqcn = this.obj.name = fqcn;
  231.         this.obj.package = fqcn.substr(0,end); 
  232.         this.obj.simpleName = fqcn.substr(end+1); 
  233.         if(this.obj.name.indexOf(LEX.TOKEN.INNER_FQCN)>-1){
  234.             this.obj.simpleName = this.obj.simpleName.substr(this.obj.simpleName.indexOf(LEX.TOKEN.INNER_FQCN)+1);
  235.             this.obj.innerClass = true;
  236.             this.obj.enclosingClass = this.obj.name.substr(0,this.obj.name.indexOf(LEX.TOKEN.INNER_FQCN));
  237.         } 
  239.         this.obj._hashcode = this.obj.hashCode();
  241.         LOG.DEBUG("[parser::class] End\n---------------------------------------------");
  242.         return this.obj;
  243.     }
  246.     type(src){
  247.         let i=0,l=-1,types=[],s=src,fqn=null,isArray=false;
  249.         while(i<src.length){
  250.             if(src[i]==LEX.TOKEN.ARRAY){
  251.                 isArray=true;
  252.                 i++;
  253.                 continue;
  254.             }
  256.             if(src[i]==LEX.TOKEN.OBJREF){
  257.                 l=src.indexOf(";",i);
  258.                 fqn=this.fqcn(src.substr(i,l-i+1));
  259.                 //console.log(fqn);
  260.                 types.push(new CLASS.ObjectType(fqn, isArray));
  261.                 i=l+1;
  262.                 isArray=false;
  263.                 continue;
  265.             }else if(Checker.isBasicType(src[i])){
  266.                 types.push(new CLASS.BasicType(src[i], isArray));
  267.                 i++;
  268.                 isArray = false;
  269.                 continue;
  270.             }
  271.             else{
  272.                 console.log("[!] Unknow type : "+src[i]+" (in "+src+")");
  273.                 break;
  274.             }
  275.         }
  277.         return types;
  278.     }
  281.     /**
  282.      * To parse a method header
  283.      */
  284.     methodHeader(src){
  285.         let mod = this.modifier(src), raw=null, tmp=null, args=null, ret=null, sa=0, ea=0;
  286.         let argTypes = null;
  287.         // clean src with identified modifier
  288.         for(let i=0; i<mod._match; i++) src.shift();
  290.         if(src.length > 1){
  291.             console.log(src,mod);
  292.             console.log("[!] Method has more modifiers");
  293.         }
  295.         this.__tmp_meth.modifiers = mod;
  296.         raw = ut.trim(src[src.length-1]);
  298.         // risque d'UTF8 / autre dans le nom, quid des regexp;
  299.         tmp = raw.substr(0,sa=raw.indexOf(LEX.TOKEN.METH_ARG_B));  
  300.         this.__tmp_meth.name = tmp;
  301.         
  302.         args = raw.substr(sa+1,(ea=raw.indexOf(LEX.TOKEN.METH_ARG_E))-sa-1)
  303.         argTypes = this.type(ut.trim(args));
  304.         this.__tmp_meth.args = argTypes;
  305.         this.__tmp_meth.argsNb = this.__tmp_meth.args.length;
  307.         ret=raw.substr(ea+1);
  308.         ret = this.type(ut.trim(ret))
  309.         if(ret.length == 0)
  310.             console.log("[!] this.method error : return type of '"+tmp+"("+args+")' cannot be parsed.")
  311.             //exit(0);
  313.         this.__tmp_meth.enclosingClass = this.obj;
  314.         this.__tmp_meth.ret = ret[0];
  316.         this.__tmp_meth._hashcode = this.__tmp_meth.hashCode();
  317.     }
  319.     instr(src, raw_src, src_line){
  320.         let inst = null;//new Instruction();
  322.         inst = OPCODE.parse(src,raw_src, src_line);
  324.         if(inst != null){
  325.             //console.log(inst);
  326.         }
  327.         //inst.operands = inst.opcode.parse(src);
  328.         //console.log('"'+src[0]+'"',inst.opcode);
  329.         // todo
  330.         return inst;
  331.     }
  333.     field(src_arr, src_line){
  334.         let f=new CLASS.Field(), type=null, tmp=null;
  336.         // parse modifiers
  337.         f.modifiers = this.modifier(src_arr);
  338.         //console.log(f.modifiers);
  340.         // clean src with identified modifier
  341.         for(let i=0; i<f.modifiers._match; i++) src_arr.shift();
  342.         // parse name and type
  343.         tmp=src_arr[0].split(":");
  344.         
  345.         f.name=tmp[0];
  347.         type=this.type(tmp[1]);
  348.         if(type.length>0) f.type=type[0];
  350.         //console.log(type.type[0]._hashcode);
  352.         f.enclosingClass = this.obj;
  353.         f._hashcode = f.hashCode();//Checker.makeFieldHashcode(f.modifiers,this.obj,f.name,f.type);
  354.         
  355.         f.signature();
  356.         f.oline = src_line;
  358.         LOG.DEBUG("[parser::field] Hashcode : "+f._hashcode);
  360.         src_arr.shift();
  362.         // parse value if available
  363.         if(src_arr.length>0){
  364.             // TODO : parse value
  365.             f.value = src_arr.pop();
  366.         }
  367.         return f;
  368.     }
  371.     method(src, raw_src, src_line){
  372.         if(this.state != SML_METH) return null;
  373.         
  374.         let sml=src, hdl=null, catchStmt=null, tmp=null;
  377.         switch(ut.trim(sml[0])){
  378.             case LEX.STRUCT.METHOD_BEG:
  379.                 LOG.DEBUG("---------------------------------------------\n[parser::method] Start ");    
  380.                 this.__tmp_meth = new CLASS.Method();
  381.                 sml.shift();
  383.                 this.methodHeader(sml,src_line);  
  384.             
  385.                 this.__tmp_meth.__$in_annot = false;
  386.                 this.__tmp_block = new CLASS.BasicBlock();
  387.                 this.__instr_ctr = 0;
  388.                 break;
  389.             case LEX.STRUCT.LOCALS:
  390.                 this.__tmp_meth.locals = parseInt(sml[1],10);
  391.                 break;
  392.             case LEX.STRUCT.PARAMS:
  393.                 // this.__tmp_meth.params = parseInt(sml[1],10);
  394.                 this.__tmp_meth.params.push(
  395.                     OPCODE.parseParam(sml[1],raw_src)
  396.                 );
  397.                 
  398.                 break;
  399.             case LEX.STRUCT.REG:
  400.                 this.__tmp_meth.registers = parseInt(sml[1],10);
  401.                 break;
  402.             case ".prologue":
  403.                 break;
  404.             case LEX.STRUCT.LINE:
  405.                 
  406.                 // .line is just a metadata associated to an instruction
  407.                 /*if(this.__tmp_block != null && this.__tmp_block.stack.length > 0){
  409.                     this.__tmp_meth.appendBlock(this.__tmp_block, this.__appendBlock_callback);
  410.                     this.__tmp_block = new CLASS.BasicBlock();
  411.                 }*/
  412.                 //  && this.__tmp_block.line != null
  413.                 this.__tmp_block.line = parseInt(sml[1],10);
  414.                 this.currentLine = parseInt(sml[1],10);
  416.                 // source line number
  417.                 this.__tmp_block.srcln = parseInt(sml[1],10);
  418.                 
  419.                 break;
  420.             case LEX.STRUCT.PSWITCH:
  421.                 
  422.                 if(sml[1] != undefined){
  423.                     this.__tmp_block.setupPackedSwitchStatement(parseInt(sml[1],16));
  424.                 }
  426.                 break;
  427.             case LEX.STRUCT.SSWITCH:
  428.                 
  429.                 this.__tmp_block.setupSparseSwitchStatement();
  430.                 
  431.                 break;
  432.             case LEX.STRUCT.ARRAY:
  433.                 this.__tmp_block.setDataWidth(parseInt(sml[1],10));
  434.                 
  435.                 break;
  436.             case LEX.STRUCT.END:
  438.                 if(sml[1]!=undefined && sml[1]==LEX.STRUCT.METHOD_NAME){
  439.                     //hdl = this.__tmp_meth._hashcode;
  440.                     this.state=SML_MAIN;   
  441.                     this.__tmp_meth.appendBlock(this.__tmp_block, this.__appendBlock_callback);   
  442.                     
  443.                     this.obj.methods[ this.__tmp_meth.signature()] = this.__tmp_meth;
  444.                     this.obj._methCount++;
  445.                     LOG.DEBUG("[parser::method] End\n---------------------------------------------");
  446.                 }else if(sml[1]!=undefined && sml[1]==LEX.STRUCT.ANNOTATION_NAME){
  447.                     this.__tmp_meth.__$in_annot = false;
  448.                 }/*
  449.                 else if(sml[1]!=undefined && sml[1]==LEX.STRUCT.PSWITCH_NAME){
  450.                     // nothing to do
  451.                     //console.log("End of packed switch");
  452.                 }xs
  453.                 else if(sml[1]!=undefined && sml[1]==LEX.STRUCT.ARRAY_NAME){
  455.                 }*/
  456.                 break;
  457.             case LEX.STRUCT.ANNOT_BEG:
  458.                 // ignore
  459.                 this.__tmp_meth.__$in_annot = true;
  460.                 break;
  461.             default: 
  462.                 if(this.__tmp_meth.__$in_annot){
  463.                     // ignore
  464.                     break;
  465.                 }
  467.                 if(sml[0].indexOf(':cond_')>-1){
  468.                     if(this.__tmp_block instanceof CLASS.DataBlock || this.__tmp_block.stack.length>0){
  469.                         this.__tmp_meth.appendBlock(this.__tmp_block, this.__appendBlock_callback);
  470.                         this.__tmp_block = new CLASS.BasicBlock();
  471.                     }
  473.                     //this.__tmp_block.tag = sml[0];
  474.                     this.__tmp_block.setAsConditionalBlock(sml[0].split('_')[1]);
  476.                 }else if(sml[0].indexOf(':goto_')>-1){
  477.                     if(this.__tmp_block instanceof CLASS.DataBlock || this.__tmp_block.stack.length>0){
  478.                         this.__tmp_meth.appendBlock(this.__tmp_block, this.__appendBlock_callback);
  479.                         this.__tmp_block = new CLASS.BasicBlock();
  480.                     }
  481.                     //this.__tmp_block.tag = sml[0];
  482.                     this.__tmp_block.setAsGotoBlock(sml[0].split('_')[1]);
  484.                 }
  485.                 else if(sml[0].indexOf(':try_start')>-1){
  486.                     if(this.__tmp_block instanceof CLASS.DataBlock || this.__tmp_block.stack.length>0){
  487.                         this.__tmp_meth.appendBlock(this.__tmp_block, this.__appendBlock_callback);
  488.                         this.__tmp_block = new CLASS.BasicBlock();
  489.                     }
  490.                     //   this.__tmp_block.tag = sml[0];
  491.                     this.__tmp_block.setAsTryBlock(sml[0]);
  492.                     
  493.                 }
  494.                 else if(sml[0].indexOf(':try_end')>-1){
  495.                     this.__tmp_block.setTryEndName(sml[0]);
  497.                     if(this.__tmp_block != null){
  498.                         this.__tmp_meth.appendBlock(this.__tmp_block, this.__appendBlock_callback);
  499.                         this.__tmp_block = new CLASS.BasicBlock();
  500.                     }
  501.                 }
  502.                 // >-1
  503.                 else if(sml[0].indexOf(LEX.LABEL.PSWITCH_DATA)==0 || sml[0].indexOf(LEX.LABEL.SSWITCH_DATA)==0){
  505.                     if(this.__tmp_block != null){
  506.                         this.__tmp_meth.appendBlock(this.__tmp_block, this.__appendBlock_callback);
  507.                         this.__tmp_block = new CLASS.BasicBlock();
  508.                     }
  509.                     
  510.                     this.__tmp_block.setAsSwitchStatement(sml[0]);
  511.                 }
  512.                 // >-1
  513.                 else if(sml[0].indexOf(LEX.LABEL.PSWITCH)==0){
  514.     
  515.                     if(this.__tmp_block.isSwitchStatement()){
  516.                             this.__tmp_block.switch.appendCase(sml[0]);
  517.                     }else{  
  518.                         this.__tmp_block.setAsSwitchCase(sml[0]);
  519.                     }   
  521.                 }
  522.                 // >-1 
  523.                 else if(sml[0].indexOf(LEX.LABEL.SSWITCH)==0){
  525.                     if(this.__tmp_block != null
  526.                         && (this.__tmp_block instanceof CLASS.DataBlock 
  527.                             || this.__tmp_block.stack.length > 0)){
  528.                         this.__tmp_meth.appendBlock(this.__tmp_block, this.__appendBlock_callback);
  529.                         this.__tmp_block = new CLASS.BasicBlock();
  530.                     }
  531.                         
  532.                     this.__tmp_block.setAsSwitchCase(sml[0]);
  533.                 }
  534.                 else if(sml.length > 2 && sml[2].indexOf(LEX.LABEL.SSWITCH)>-1 && sml[0].indexOf("p")==-1){
  535.                     if(this.__tmp_block.isSwitchStatement()){
  536.                      //   console.log(sml);
  537.                         this.__tmp_block.switch.appendCase(sml[0],sml[2]);
  538.                     } 
  540.                 }
  541.                 else if(sml[0].indexOf(LEX.LABEL.ARRAY)>-1){
  542.                     // check if tmp block not empty (data or bb)
  543.                     if(this.__tmp_block != null){
  544.                         this.__tmp_meth.appendBlock(this.__tmp_block, this.__appendBlock_callback);
  545.                     }
  546.                     this.__tmp_block = new CLASS.DataBlock();
  547.                     this.__tmp_block.name = sml[0];
  548.                 }
  549.                 else if(sml[0].indexOf(LEX.STRUCT.CATCH_ALL)>-1){
  550.                     catchStmt = new CLASS.CatchStatement();
  551.                     catchStmt.setTryStart(sml[1].substr(1,sml[1].length));
  552.                     catchStmt.setTryEnd(sml[3].substr(0,sml[3].length-1));
  553.                     catchStmt.setTarget(sml[4]);
  556.                     tmp = this.__tmp_meth.getBasicBlocks();
  557.                     tmp[tmp.length-1].addCatchStatement(catchStmt);
  559.                     //this.__tmp_block.addCatchStatement(catchStmt);
  560.                 }
  561.                 else if(sml[0].indexOf(LEX.STRUCT.CATCH)>-1){
  562.                     catchStmt = new CLASS.CatchStatement();
  563.                     catchStmt.setException(this.type(sml[1])[0]);
  564.                     catchStmt.setTryStart(sml[2].substr(1,sml[2].length));
  565.                     catchStmt.setTryEnd(sml[4].substr(0,sml[4].length-1));
  566.                     catchStmt.setTarget(sml[5]);
  568.                     //console.log(sml);
  569.                     tmp = this.__tmp_meth.getBasicBlocks();
  570.                     tmp[tmp.length-1].addCatchStatement(catchStmt);
  571.                     /*if(this.__tmp_block != null){
  572.                         this.__tmp_meth.appendBlock(this.__tmp_block, this.__appendBlock_callback);
  573.                         this.__tmp_block = new CLASS.BasicBlock();
  574.                     }
  576.                     this.__tmp_block.addCatchStatement(catchStmt);*/
  577.                 }
  578.                 else if(sml[0].indexOf(LEX.LABEL.CATCH)>-1){
  579.                     if(this.__tmp_block != null 
  580.                         && ( this.__tmp_block instanceof CLASS.DataBlock 
  581.                             || this.__tmp_block.stack.length > 0 )){
  582.                         this.__tmp_meth.appendBlock(this.__tmp_block, this.__appendBlock_callback);              
  583.                         this.__tmp_block = new CLASS.BasicBlock();
  584.                     }
  586.                     this.__tmp_block.setCatchCond(raw_src);
  587.                 }
  588.                 else if(sml[0].indexOf(':catchall')>-1){
  590.                     if(this.__tmp_block != null 
  591.                         && ( this.__tmp_block instanceof CLASS.DataBlock 
  592.                             || this.__tmp_block.stack.length > 0 )){
  593.                         this.__tmp_meth.appendBlock(this.__tmp_block, this.__appendBlock_callback);              
  594.                         this.__tmp_block = new CLASS.BasicBlock();
  595.                     }
  596.                     this.__tmp_block.setAsCatchBlock(sml[0]);
  598.                 }
  599.                 else if(this.__tmp_block instanceof CLASS.DataBlock){
  601.                     hdl = CONST.RE.ARRAY_VALUE.exec(sml[0]);
  602.                     if(hdl ==null) break; 
  603.                     this.__tmp_block.pushData("0x"+hdl[2], (hdl[1] != undefined), (hdl[3]=='s'));
  604.                 }
  605.                 else{
  607.                     if(this.__tmp_block instanceof CLASS.DataBlock) console.log("Error : DataBlock instead of BasicBlock",this.__tmp_meth);
  608.                     if(this.__tmp_block == null) console.log("Error : tmpBlock is null",this.__tmp_meth);
  609.                     hdl = this.instr(sml,raw_src,src_line);
  612.                     if(hdl !== null){
  614.                         this.__instr_ctr++;
  615.                         hdl.offset = this.__instr_ctr;
  616.                         hdl.oline = this.__instr_ctr;
  617.                         if(this.currentLine != null){
  618.                             hdl.iline = this.currentLine;
  619.                             this.currentLine = null;
  620.                         }
  621.                         this.__tmp_block.stack.push(hdl);
  623.                         if(hdl.opcode.type == CONST.INSTR_TYPE.IF || hdl.opcode.type == CONST.INSTR_TYPE.GOTO ) {
  625.                             
  626.                             if(this.__tmp_block instanceof CLASS.DataBlock || this.__tmp_block.stack.length>0){
  627.                                 this.__tmp_meth.appendBlock(this.__tmp_block, this.__appendBlock_callback);
  628.                                 this.__tmp_block = new CLASS.BasicBlock();
  629.                             }
  631.                         }
  632.                     }
  635.                     // add end of basic block on If / Goto
  636. /*                    else if(this.isJumpInstruction(sml)){
  637.                         if(this.__tmp_block instanceof CLASS.DataBlock || this.__tmp_block.stack.length>0){
  638.                             this.__tmp_meth.appendBlock(this.__tmp_block, this.__appendBlock_callback);
  639.                             this.__tmp_block = new CLASS.BasicBlock();
  640.                         }
  642.                         if(this.__tmp_block == null) console.log("Error : tmpBlock is null",this.__tmp_meth);
  643.                         hdl = this.instr(sml,raw_src,src_line);
  645.                         if(hdl !== null){
  646.                             this.__instr_ctr++;
  647.                             hdl.offset = this.__instr_ctr;
  648.                             hdl.oline = this.__instr_ctr;
  649.                             this.__tmp_block.stack.push(hdl);
  650.                         }
  651.                         //this.__tmp_block.tag = sml[0];
  652.                         //this.__tmp_block.setAsGotoBlock(sml[0].split('_')[1]);
  653.                     }*/
  654.                     
  655.                 }
  659.                 break;
  660.         }
  662.         return true;
  663.     }
  665.     annotation(src){
  666.         if(this.state != SML_ANNO) return null;
  668.         let sml=[], hdl=null;
  670.         sml=(src instanceof String)? src.split(LEX.TOKEN.SPACE) : src ;
  671.         
  672.         // search lexeme
  673.         switch(ut.trim(sml[0])){
  674.             case LEX.STRUCT.END:
  675.                 if(sml[1]!=undefined && sml[1]=="annotation"){
  676.                     this.state=SML_MAIN;    
  677.                 }
  678.                 break;
  679.         }
  680.         //console.log("[!] this.annotation not implemented");
  681.     }
  683.     parse(src){
  684.         let ls=src.split("\n"), ln=null, sml=null, obj=null;
  685.     
  686.         //console.log(ls);
  687.         for(let l=0; l<ls.length; l++){
  688.             ln=ut.trim(ls[l]);
  689.             if(ln.length==0){
  690.                 continue;
  691.             }
  692.             sml=ln.split(LEX.TOKEN.SPACE);
  693.             switch(sml[0]){
  694.                 case LEX.STRUCT.CLASS:
  695.                     sml.shift();
  696.                     this.class(sml);
  697.                     break;
  698.                 case LEX.STRUCT.IMPLEMENTS:
  699.                     sml.shift();
  700.                     this.obj.implements.push(this.fqcn(sml[0]));
  701.                     break;
  702.                 case LEX.STRUCT.SUPER:
  703.                     sml.shift();
  704.                     this.obj.extends = this.fqcn(sml[0]);
  705.                     break;
  706.                 case LEX.STRUCT.SRC: 
  707.                     this.obj.source = this.fspath(sml[1]);
  708.                     break;
  709.                 case LEX.STRUCT.FIELD:
  710.                     sml.shift();
  711.                     obj=this.field(sml,l);
  712.                     // use an internal name which combine visibility and field name
  713.                     //this.obj.fields[obj._hashcode] = obj;
  714.                     this.obj.fields[obj.signature()] = obj;
  715.                     this.obj._fieldCount++;
  716.                     
  717.                     break;
  718.                 case LEX.STRUCT.METHOD_BEG:
  719.                     this.state = SML_METH;
  720.                     this.method(sml,ln,l);
  721.                     break;
  722.                 case LEX.STRUCT.ANNOT_BEG:
  723.                     if(this.state != SML_METH){
  724.                         this.state = SML_ANNO;
  725.                         this.annotation(sml);
  726.                     }
  727.                     break;
  728.                 default:
  729.                     switch(this.state){
  730.                         case SML_METH:
  731.                             this.method(sml,ln,l);
  732.                             break;
  733.                         case SML_PSWITCH:
  734.                             this.pswitch(sml,ln,l);
  735.                             break;
  736.                         case SML_ANNO:
  737.                             this.annotation(sml);
  738.                             break;
  739.                     }
  740.                     break;
  741.             }
  742.         }
  743.         //console.log(this.obj);
  744.         //this.obj.dump();
  745.         return this.obj;
  746.     }
  748.     parseStream( pFilePath, pEncoding, pCallback){
  750.         let _self = this, rs=null, stream=null;
  751.         _self.obj = null;
  752.         _self.objReady = false;
  754.         stream =_fs_.createReadStream(pFilePath)
  755.         .pipe(_es_.split())
  756.         .pipe(_es_.mapSync(function(line){
  757.     
  758.                 // pause the readstream
  759.                 stream.pause();
  760.         
  761.                 
  762.                 // process line here and call s.resume() when rdy
  763.                 // function below was for logging memory usage
  764.                 console.log(line);
  765.         
  766.                 // resume the readstream, possibly from a callback
  767.                 stream.resume();
  768.             })
  769.             .on('error', function(err){
  770.                 console.log('Error while reading file.', err);
  771.             })
  772.             .on('end', function(){
  773.                 console.log('Read entire file.')
  774.             })
  775.         );
  777.         //stream = _fs_.createReadStream(pFilePath,{ encoding: 'utf8' });
  779.         //stream = LineStream(stream);
  781.         /*
  782.         stream.on('resume', function(){
  783.             console.log('resume');
  784.         });*/
  786.      
  787.         
  788. /*
  789.         stream.on('pause', function(){
  790.             console.log('paused');
  791.         });
  793.         stream.on('close', function(){
  794.             console.log("close", _self.obj)
  795.             pCallback(_self.obj);
  796.         });
  798.         stream.on('data', function(pLine){
  799.             let ln=null, sml=null, obj=null;
  801.             console.log(pLine);
  803.             ln=ut.trim(pLine);
  804.             if(ln.length==0){
  805.                 return;
  806.             }
  808.             sml=ln.split(LEX.TOKEN.SPACE);
  809.             switch(sml[0]){
  810.                 case LEX.STRUCT.CLASS:
  811.                     sml.shift();
  812.                     _self.class(sml);
  813.                     break;
  814.                 case LEX.STRUCT.IMPLEMENTS:
  815.                     sml.shift();
  816.                     _self.obj.implements.push(_self.fqcn(sml[0]));
  817.                     break;
  818.                 case LEX.STRUCT.SUPER:
  819.                     sml.shift();
  820.                     _self.obj.extends = _self.fqcn(sml[0]);
  821.                     break;
  822.                 case LEX.STRUCT.SRC: 
  823.                     _self.obj.source = _self.fspath(sml[1]);
  824.                     break;
  825.                 case LEX.STRUCT.FIELD:
  826.                     sml.shift();
  827.                     obj=_self.field(sml,l);
  828.                     // use an internal name which combine visibility and field name
  829.                     //this.obj.fields[obj._hashcode] = obj;
  830.                     _self.obj.fields[obj.signature()] = obj;
  831.                     _self.obj._fieldCount++;
  832.                     
  833.                     break;
  834.                 case LEX.STRUCT.METHOD_BEG:
  835.                     _self.state = SML_METH;
  836.                     _self.method(sml,ln,l);
  837.                     break;
  838.                 case LEX.STRUCT.ANNOT_BEG:
  839.                     if(_self.state != SML_METH){
  840.                         _self.state = SML_ANNO;
  841.                         _self.annotation(sml);
  842.                     }
  843.                     break;
  844.                 default:
  845.                     switch(_self.state){
  846.                         case SML_METH:
  847.                             _self.method(sml,ln,l);
  848.                             break;
  849.                         case SML_PSWITCH:
  850.                             _self.pswitch(sml,ln,l);
  851.                             break;
  852.                         case SML_ANNO:
  853.                             _self.annotation(sml);
  854.                             break;
  855.                     }
  856.                     break;
  857.             }
  858.         });*/
  859.     }
  860. }
  863. module.exports = SmaliParser;