waflib/Task.py

   1 #! /usr/bin/env python
   2 # encoding: utf-8
   3 # WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file
   4
   5 import os,shutil,re,tempfile
   6 from waflib import Utils,Logs,Errors
   7 NOT_RUN=0
   8 MISSING=1
   9 CRASHED=2
  10 EXCEPTION=3
  11 SKIPPED=8
  12 SUCCESS=9
  13 ASK_LATER=-1
  14 SKIP_ME=-2
  15 RUN_ME=-3
  16 COMPILE_TEMPLATE_SHELL='''
  17 def f(tsk):
  18         env = tsk.env
  19         gen = tsk.generator
  20         bld = gen.bld
  21         wd = getattr(tsk, 'cwd', None)
  22         p = env.get_flat
  23         tsk.last_cmd = cmd = \'\'\' %s \'\'\' % s
  24         return tsk.exec_command(cmd, cwd=wd, env=env.env or None)
  25 '''
  26 COMPILE_TEMPLATE_NOSHELL='''
  27 def f(tsk):
  28         env = tsk.env
  29         gen = tsk.generator
  30         bld = gen.bld
  31         wd = getattr(tsk, 'cwd', None)
  32         def to_list(xx):
  33                 if isinstance(xx, str): return [xx]
  34                 return xx
  35         tsk.last_cmd = lst = []
  36         %s
  37         lst = [x for x in lst if x]
  38         return tsk.exec_command(lst, cwd=wd, env=env.env or None)
  39 '''
  40 def cache_outputs(cls):
  41         m1=cls.run
  42         def run(self):
  43                 bld=self.generator.bld
  44                 if bld.cache_global and not bld.nocache:
  45                         if self.can_retrieve_cache():
  46                                 return 0
  47                 return m1(self)
  48         cls.run=run
  49         m2=cls.post_run
  50         def post_run(self):
  51                 bld=self.generator.bld
  52                 ret=m2(self)
  53                 if bld.cache_global and not bld.nocache:
  54                         self.put_files_cache()
  55                 return ret
  56         cls.post_run=post_run
  57         return cls
  58 classes={}
  59 class store_task_type(type):
  60         def __init__(cls,name,bases,dict):
  61                 super(store_task_type,cls).__init__(name,bases,dict)
  62                 name=cls.__name__
  63                 if name.endswith('_task'):
  64                         name=name.replace('_task','')
  65                 if name!='evil'and name!='TaskBase':
  66                         global classes
  67                         if getattr(cls,'run_str',None):
  68                                 (f,dvars)=compile_fun(cls.run_str,cls.shell)
  69                                 cls.hcode=cls.run_str
  70                                 cls.run_str=None
  71                                 cls.run=f
  72                                 cls.vars=list(set(cls.vars+dvars))
  73                                 cls.vars.sort()
  74                         elif getattr(cls,'run',None)and not'hcode'in cls.__dict__:
  75                                 cls.hcode=Utils.h_fun(cls.run)
  76                         if not getattr(cls,'nocache',None):
  77                                 cls=cache_outputs(cls)
  78                         getattr(cls,'register',classes)[name]=cls
  79 evil=store_task_type('evil',(object,),{})
  80 class TaskBase(evil):
  81         color='GREEN'
  82         ext_in=[]
  83         ext_out=[]
  84         before=[]
  85         after=[]
  86         hcode=''
  87         def __init__(self,*k,**kw):
  88                 self.hasrun=NOT_RUN
  89                 try:
  90                         self.generator=kw['generator']
  91                 except KeyError:
  92                         self.generator=self
  93         def __repr__(self):
  94                 return'\n\t{task %r: %s %s}'%(self.__class__.__name__,id(self),str(getattr(self,'fun','')))
  95         def __str__(self):
  96                 if hasattr(self,'fun'):
  97                         return'executing: %s\n'%self.fun.__name__
  98                 return self.__class__.__name__+'\n'
  99         def __hash__(self):
 100                 return id(self)
 101         def exec_command(self,cmd,**kw):
 102                 bld=self.generator.bld
 103                 try:
 104                         if not kw.get('cwd',None):
 105                                 kw['cwd']=bld.cwd
 106                 except AttributeError:
 107                         bld.cwd=kw['cwd']=bld.variant_dir
 108                 return bld.exec_command(cmd,**kw)
 109         def runnable_status(self):
 110                 return RUN_ME
 111         def process(self):
 112                 m=self.master
 113                 if m.stop:
 114                         m.out.put(self)
 115                         return
 116                 try:
 117                         del self.generator.bld.task_sigs[self.uid()]
 118                 except KeyError:
 119                         pass
 120                 try:
 121                         self.generator.bld.returned_tasks.append(self)
 122                         self.log_display(self.generator.bld)
 123                         ret=self.run()
 124                 except Exception:
 125                         self.err_msg=Utils.ex_stack()
 126                         self.hasrun=EXCEPTION
 127                         m.error_handler(self)
 128                         m.out.put(self)
 129                         return
 130                 if ret:
 131                         self.err_code=ret
 132                         self.hasrun=CRASHED
 133                 else:
 134                         try:
 135                                 self.post_run()
 136                         except Errors.WafError:
 137                                 pass
 138                         except Exception:
 139                                 self.err_msg=Utils.ex_stack()
 140                                 self.hasrun=EXCEPTION
 141                         else:
 142                                 self.hasrun=SUCCESS
 143                 if self.hasrun!=SUCCESS:
 144                         m.error_handler(self)
 145                 m.out.put(self)
 146         def run(self):
 147                 if hasattr(self,'fun'):
 148                         return self.fun(self)
 149                 return 0
 150         def post_run(self):
 151                 pass
 152         def log_display(self,bld):
 153                 bld.to_log(self.display())
 154         def display(self):
 155                 col1=Logs.colors(self.color)
 156                 col2=Logs.colors.NORMAL
 157                 master=self.master
 158                 def cur():
 159                         tmp=-1
 160                         if hasattr(master,'ready'):
 161                                 tmp-=master.ready.qsize()
 162                         return master.processed+tmp
 163                 if self.generator.bld.progress_bar==1:
 164                         return self.generator.bld.progress_line(cur(),master.total,col1,col2)
 165                 if self.generator.bld.progress_bar==2:
 166                         ela=str(self.generator.bld.timer)
 167                         try:
 168                                 ins=','.join([n.name for n in self.inputs])
 169                         except AttributeError:
 170                                 ins=''
 171                         try:
 172                                 outs=','.join([n.name for n in self.outputs])
 173                         except AttributeError:
 174                                 outs=''
 175                         return'|Total %s|Current %s|Inputs %s|Outputs %s|Time %s|\n'%(master.total,cur(),ins,outs,ela)
 176                 s=str(self)
 177                 if not s:
 178                         return None
 179                 total=master.total
 180                 n=len(str(total))
 181                 fs='[%%%dd/%%%dd] %%s%%s%%s'%(n,n)
 182                 return fs%(cur(),total,col1,s,col2)
 183         def attr(self,att,default=None):
 184                 ret=getattr(self,att,self)
 185                 if ret is self:return getattr(self.__class__,att,default)
 186                 return ret
 187         def hash_constraints(self):
 188                 cls=self.__class__
 189                 tup=(str(cls.before),str(cls.after),str(cls.ext_in),str(cls.ext_out),cls.__name__,cls.hcode)
 190                 h=hash(tup)
 191                 return h
 192         def format_error(self):
 193                 msg=getattr(self,'last_cmd','')
 194                 name=getattr(self.generator,'name','')
 195                 if getattr(self,"err_msg",None):
 196                         return self.err_msg
 197                 elif not self.hasrun:
 198                         return'task in %r was not executed for some reason: %r'%(name,self)
 199                 elif self.hasrun==CRASHED:
 200                         try:
 201                                 return' -> task in %r failed (exit status %r): %r\n%r'%(name,self.err_code,self,msg)
 202                         except AttributeError:
 203                                 return' -> task in %r failed: %r\n%r'%(name,self,msg)
 204                 elif self.hasrun==MISSING:
 205                         return' -> missing files in %r: %r\n%r'%(name,self,msg)
 206                 else:
 207                         return'invalid status for task in %r: %r'%(name,self.hasrun)
 208         def colon(self,var1,var2):
 209                 tmp=self.env[var1]
 210                 if isinstance(var2,str):
 211                         it=self.env[var2]
 212                 else:
 213                         it=var2
 214                 if isinstance(tmp,str):
 215                         return[tmp%x for x in it]
 216                 else:
 217                         if Logs.verbose and not tmp and it:
 218                                 Logs.warn('Missing env variable %r for task %r (generator %r)'%(var1,self,self.generator))
 219                         lst=[]
 220                         for y in it:
 221                                 lst.extend(tmp)
 222                                 lst.append(y)
 223                         return lst
 224 class Task(TaskBase):
 225         vars=[]
 226         shell=False
 227         def __init__(self,*k,**kw):
 228                 TaskBase.__init__(self,*k,**kw)
 229                 self.env=kw['env']
 230                 self.inputs=[]
 231                 self.outputs=[]
 232                 self.dep_nodes=[]
 233                 self.run_after=set([])
 234         def __str__(self):
 235                 env=self.env
 236                 src_str=' '.join([a.nice_path()for a in self.inputs])
 237                 tgt_str=' '.join([a.nice_path()for a in self.outputs])
 238                 if self.outputs:sep=' -> '
 239                 else:sep=''
 240                 return'%s: %s%s%s\n'%(self.__class__.__name__.replace('_task',''),src_str,sep,tgt_str)
 241         def __repr__(self):
 242                 try:
 243                         ins=",".join([x.name for x in self.inputs])
 244                         outs=",".join([x.name for x in self.outputs])
 245                 except AttributeError:
 246                         ins=",".join([str(x)for x in self.inputs])
 247                         outs=",".join([str(x)for x in self.outputs])
 248                 return"".join(['\n\t{task %r: '%id(self),self.__class__.__name__," ",ins," -> ",outs,'}'])
 249         def uid(self):
 250                 try:
 251                         return self.uid_
 252                 except AttributeError:
 253                         m=Utils.md5()
 254                         up=m.update
 255                         up(self.__class__.__name__)
 256                         for x in self.inputs+self.outputs:
 257                                 up(x.abspath())
 258                         self.uid_=m.digest()
 259                         return self.uid_
 260         def set_inputs(self,inp):
 261                 if isinstance(inp,list):self.inputs+=inp
 262                 else:self.inputs.append(inp)
 263         def set_outputs(self,out):
 264                 if isinstance(out,list):self.outputs+=out
 265                 else:self.outputs.append(out)
 266         def set_run_after(self,task):
 267                 assert isinstance(task,TaskBase)
 268                 self.run_after.add(task)
 269         def signature(self):
 270                 try:return self.cache_sig
 271                 except AttributeError:pass
 272                 self.m=Utils.md5()
 273                 self.m.update(self.hcode)
 274                 self.sig_explicit_deps()
 275                 self.sig_vars()
 276                 if self.scan:
 277                         try:
 278                                 self.sig_implicit_deps()
 279                         except Errors.TaskRescan:
 280                                 return self.signature()
 281                 ret=self.cache_sig=self.m.digest()
 282                 return ret
 283         def runnable_status(self):
 284                 for t in self.run_after:
 285                         if not t.hasrun:
 286                                 return ASK_LATER
 287                 bld=self.generator.bld
 288                 try:
 289                         new_sig=self.signature()
 290                 except Errors.TaskNotReady:
 291                         return ASK_LATER
 292                 key=self.uid()
 293                 try:
 294                         prev_sig=bld.task_sigs[key]
 295                 except KeyError:
 296                         Logs.debug("task: task %r must run as it was never run before or the task code changed"%self)
 297                         return RUN_ME
 298                 for node in self.outputs:
 299                         try:
 300                                 if node.sig!=new_sig:
 301                                         return RUN_ME
 302                         except AttributeError:
 303                                 Logs.debug("task: task %r must run as the output nodes do not exist"%self)
 304                                 return RUN_ME
 305                 if new_sig!=prev_sig:
 306                         return RUN_ME
 307                 return SKIP_ME
 308         def post_run(self):
 309                 bld=self.generator.bld
 310                 sig=self.signature()
 311                 for node in self.outputs:
 312                         try:
 313                                 os.stat(node.abspath())
 314                         except OSError:
 315                                 self.hasrun=MISSING
 316                                 self.err_msg='-> missing file: %r'%node.abspath()
 317                                 raise Errors.WafError(self.err_msg)
 318                         node.sig=sig
 319                 bld.task_sigs[self.uid()]=self.cache_sig
 320         def sig_explicit_deps(self):
 321                 bld=self.generator.bld
 322                 upd=self.m.update
 323                 for x in self.inputs+self.dep_nodes:
 324                         try:
 325                                 upd(x.get_bld_sig())
 326                         except(AttributeError,TypeError):
 327                                 raise Errors.WafError('Missing node signature for %r (required by %r)'%(x,self))
 328                 if bld.deps_man:
 329                         additional_deps=bld.deps_man
 330                         for x in self.inputs+self.outputs:
 331                                 try:
 332                                         d=additional_deps[id(x)]
 333                                 except KeyError:
 334                                         continue
 335                                 for v in d:
 336                                         if isinstance(v,bld.root.__class__):
 337                                                 try:
 338                                                         v=v.get_bld_sig()
 339                                                 except AttributeError:
 340                                                         raise Errors.WafError('Missing node signature for %r (required by %r)'%(v,self))
 341                                         elif hasattr(v,'__call__'):
 342                                                 v=v()
 343                                         upd(v)
 344                 return self.m.digest()
 345         def sig_vars(self):
 346                 bld=self.generator.bld
 347                 env=self.env
 348                 upd=self.m.update
 349                 act_sig=bld.hash_env_vars(env,self.__class__.vars)
 350                 upd(act_sig)
 351                 dep_vars=getattr(self,'dep_vars',None)
 352                 if dep_vars:
 353                         upd(bld.hash_env_vars(env,dep_vars))
 354                 return self.m.digest()
 355         scan=None
 356         def sig_implicit_deps(self):
 357                 bld=self.generator.bld
 358                 key=self.uid()
 359                 prev=bld.task_sigs.get((key,'imp'),[])
 360                 if prev:
 361                         try:
 362                                 if prev==self.compute_sig_implicit_deps():
 363                                         return prev
 364                         except Exception:
 365                                 for x in bld.node_deps.get(self.uid(),[]):
 366                                         if x.is_child_of(bld.srcnode):
 367                                                 try:
 368                                                         os.stat(x.abspath())
 369                                                 except OSError:
 370                                                         try:
 371                                                                 del x.parent.children[x.name]
 372                                                         except KeyError:
 373                                                                 pass
 374                         del bld.task_sigs[(key,'imp')]
 375                         raise Errors.TaskRescan('rescan')
 376                 (nodes,names)=self.scan()
 377                 if Logs.verbose:
 378                         Logs.debug('deps: scanner for %s returned %s %s'%(str(self),str(nodes),str(names)))
 379                 bld.node_deps[key]=nodes
 380                 bld.raw_deps[key]=names
 381                 self.are_implicit_nodes_ready()
 382                 try:
 383                         bld.task_sigs[(key,'imp')]=sig=self.compute_sig_implicit_deps()
 384                 except Exception:
 385                         if Logs.verbose:
 386                                 for k in bld.node_deps.get(self.uid(),[]):
 387                                         try:
 388                                                 k.get_bld_sig()
 389                                         except Exception:
 390                                                 Logs.warn('Missing signature for node %r (may cause rebuilds)'%k)
 391                 else:
 392                         return sig
 393         def compute_sig_implicit_deps(self):
 394                 upd=self.m.update
 395                 bld=self.generator.bld
 396                 self.are_implicit_nodes_ready()
 397                 for k in bld.node_deps.get(self.uid(),[]):
 398                         upd(k.get_bld_sig())
 399                 return self.m.digest()
 400         def are_implicit_nodes_ready(self):
 401                 bld=self.generator.bld
 402                 try:
 403                         cache=bld.dct_implicit_nodes
 404                 except AttributeError:
 405                         bld.dct_implicit_nodes=cache={}
 406                 try:
 407                         dct=cache[bld.cur]
 408                 except KeyError:
 409                         dct=cache[bld.cur]={}
 410                         for tsk in bld.cur_tasks:
 411                                 for x in tsk.outputs:
 412                                         dct[x]=tsk
 413                 modified=False
 414                 for x in bld.node_deps.get(self.uid(),[]):
 415                         if x in dct:
 416                                 self.run_after.add(dct[x])
 417                                 modified=True
 418                 if modified:
 419                         for tsk in self.run_after:
 420                                 if not tsk.hasrun:
 421                                         raise Errors.TaskNotReady('not ready')
 422         def can_retrieve_cache(self):
 423                 if not getattr(self,'outputs',None):
 424                         return None
 425                 sig=self.signature()
 426                 ssig=Utils.to_hex(self.uid())+Utils.to_hex(sig)
 427                 dname=os.path.join(self.generator.bld.cache_global,ssig)
 428                 try:
 429                         t1=os.stat(dname).st_mtime
 430                 except OSError:
 431                         return None
 432                 for node in self.outputs:
 433                         orig=os.path.join(dname,node.name)
 434                         try:
 435                                 shutil.copy2(orig,node.abspath())
 436                                 os.utime(orig,None)
 437                         except(OSError,IOError):
 438                                 Logs.debug('task: failed retrieving file')
 439                                 return None
 440                 try:
 441                         t2=os.stat(dname).st_mtime
 442                 except OSError:
 443                         return None
 444                 if t1!=t2:
 445                         return None
 446                 for node in self.outputs:
 447                         node.sig=sig
 448                         if self.generator.bld.progress_bar<1:
 449                                 self.generator.bld.to_log('restoring from cache %r\n'%node.abspath())
 450                 self.cached=True
 451                 return True
 452         def put_files_cache(self):
 453                 if getattr(self,'cached',None):
 454                         return None
 455                 if not getattr(self,'outputs',None):
 456                         return None
 457                 sig=self.signature()
 458                 ssig=Utils.to_hex(self.uid())+Utils.to_hex(sig)
 459                 dname=os.path.join(self.generator.bld.cache_global,ssig)
 460                 tmpdir=tempfile.mkdtemp(prefix=self.generator.bld.cache_global+os.sep+'waf')
 461                 try:
 462                         shutil.rmtree(dname)
 463                 except Exception:
 464                         pass
 465                 try:
 466                         for node in self.outputs:
 467                                 dest=os.path.join(tmpdir,node.name)
 468                                 shutil.copy2(node.abspath(),dest)
 469                 except(OSError,IOError):
 470                         try:
 471                                 shutil.rmtree(tmpdir)
 472                         except Exception:
 473                                 pass
 474                 else:
 475                         try:
 476                                 os.rename(tmpdir,dname)
 477                         except OSError:
 478                                 try:
 479                                         shutil.rmtree(tmpdir)
 480                                 except Exception:
 481                                         pass
 482                         else:
 483                                 try:
 484                                         os.chmod(dname,Utils.O755)
 485                                 except Exception:
 486                                         pass
 487 def is_before(t1,t2):
 488         to_list=Utils.to_list
 489         for k in to_list(t2.ext_in):
 490                 if k in to_list(t1.ext_out):
 491                         return 1
 492         if t1.__class__.__name__ in to_list(t2.after):
 493                 return 1
 494         if t2.__class__.__name__ in to_list(t1.before):
 495                 return 1
 496         return 0
 497 def set_file_constraints(tasks):
 498         ins=Utils.defaultdict(set)
 499         outs=Utils.defaultdict(set)
 500         for x in tasks:
 501                 for a in getattr(x,'inputs',[])+getattr(x,'dep_nodes',[]):
 502                         ins[id(a)].add(x)
 503                 for a in getattr(x,'outputs',[]):
 504                         outs[id(a)].add(x)
 505         links=set(ins.keys()).intersection(outs.keys())
 506         for k in links:
 507                 for a in ins[k]:
 508                         a.run_after.update(outs[k])
 509 def set_precedence_constraints(tasks):
 510         cstr_groups=Utils.defaultdict(list)
 511         for x in tasks:
 512                 h=x.hash_constraints()
 513                 cstr_groups[h].append(x)
 514         keys=list(cstr_groups.keys())
 515         maxi=len(keys)
 516         for i in range(maxi):
 517                 t1=cstr_groups[keys[i]][0]
 518                 for j in range(i+1,maxi):
 519                         t2=cstr_groups[keys[j]][0]
 520                         if is_before(t1,t2):
 521                                 a=i
 522                                 b=j
 523                         elif is_before(t2,t1):
 524                                 a=j
 525                                 b=i
 526                         else:
 527                                 continue
 528                         aval=set(cstr_groups[keys[a]])
 529                         for x in cstr_groups[keys[b]]:
 530                                 x.run_after.update(aval)
 531 def funex(c):
 532         dc={}
 533         exec(c,dc)
 534         return dc['f']
 535 reg_act=re.compile(r"(?P<backslash>\\)|(?P<dollar>\$\$)|(?P<subst>\$\{(?P<var>\w+)(?P<code>.*?)\})",re.M)
 536 def compile_fun_shell(line):
 537         extr=[]
 538         def repl(match):
 539                 g=match.group
 540                 if g('dollar'):return"$"
 541                 elif g('backslash'):return'\\\\'
 542                 elif g('subst'):extr.append((g('var'),g('code')));return"%s"
 543                 return None
 544         line=reg_act.sub(repl,line)or line
 545         parm=[]
 546         dvars=[]
 547         app=parm.append
 548         for(var,meth)in extr:
 549                 if var=='SRC':
 550                         if meth:app('tsk.inputs%s'%meth)
 551                         else:app('" ".join([a.path_from(bld.bldnode) for a in tsk.inputs])')
 552                 elif var=='TGT':
 553                         if meth:app('tsk.outputs%s'%meth)
 554                         else:app('" ".join([a.path_from(bld.bldnode) for a in tsk.outputs])')
 555                 elif meth:
 556                         if meth.startswith(':'):
 557                                 m=meth[1:]
 558                                 if m=='SRC':
 559                                         m='[a.path_from(bld.bldnode) for a in tsk.inputs]'
 560                                 elif m=='TGT':
 561                                         m='[a.path_from(bld.bldnode) for a in tsk.outputs]'
 562                                 elif m[:3]not in('tsk','gen','bld'):
 563                                         dvars.extend([var,meth[1:]])
 564                                         m='%r'%m
 565                                 app('" ".join(tsk.colon(%r, %s))'%(var,m))
 566                         else:
 567                                 app('%s%s'%(var,meth))
 568                 else:
 569                         if not var in dvars:dvars.append(var)
 570                         app("p('%s')"%var)
 571         if parm:parm="%% (%s) "%(',\n\t\t'.join(parm))
 572         else:parm=''
 573         c=COMPILE_TEMPLATE_SHELL%(line,parm)
 574         Logs.debug('action: %s'%c.strip().splitlines())
 575         return(funex(c),dvars)
 576 def compile_fun_noshell(line):
 577         extr=[]
 578         def repl(match):
 579                 g=match.group
 580                 if g('dollar'):return"$"
 581                 elif g('subst'):extr.append((g('var'),g('code')));return"<<|@|>>"
 582                 return None
 583         line2=reg_act.sub(repl,line)
 584         params=line2.split('<<|@|>>')
 585         assert(extr)
 586         buf=[]
 587         dvars=[]
 588         app=buf.append
 589         for x in range(len(extr)):
 590                 params[x]=params[x].strip()
 591                 if params[x]:
 592                         app("lst.extend(%r)"%params[x].split())
 593                 (var,meth)=extr[x]
 594                 if var=='SRC':
 595                         if meth:app('lst.append(tsk.inputs%s)'%meth)
 596                         else:app("lst.extend([a.path_from(bld.bldnode) for a in tsk.inputs])")
 597                 elif var=='TGT':
 598                         if meth:app('lst.append(tsk.outputs%s)'%meth)
 599                         else:app("lst.extend([a.path_from(bld.bldnode) for a in tsk.outputs])")
 600                 elif meth:
 601                         if meth.startswith(':'):
 602                                 m=meth[1:]
 603                                 if m=='SRC':
 604                                         m='[a.path_from(bld.bldnode) for a in tsk.inputs]'
 605                                 elif m=='TGT':
 606                                         m='[a.path_from(bld.bldnode) for a in tsk.outputs]'
 607                                 elif m[:3]not in('tsk','gen','bld'):
 608                                         dvars.extend([var,m])
 609                                         m='%r'%m
 610                                 app('lst.extend(tsk.colon(%r, %s))'%(var,m))
 611                         else:
 612                                 app('lst.extend(gen.to_list(%s%s))'%(var,meth))
 613                 else:
 614                         app('lst.extend(to_list(env[%r]))'%var)
 615                         if not var in dvars:dvars.append(var)
 616         if extr:
 617                 if params[-1]:
 618                         app("lst.extend(%r)"%params[-1].split())
 619         fun=COMPILE_TEMPLATE_NOSHELL%"\n\t".join(buf)
 620         Logs.debug('action: %s'%fun.strip().splitlines())
 621         return(funex(fun),dvars)
 622 def compile_fun(line,shell=False):
 623         if line.find('<')>0 or line.find('>')>0 or line.find('&&')>0:
 624                 shell=True
 625         if shell:
 626                 return compile_fun_shell(line)
 627         else:
 628                 return compile_fun_noshell(line)
 629 def task_factory(name,func=None,vars=None,color='GREEN',ext_in=[],ext_out=[],before=[],after=[],shell=False,scan=None):
 630         params={'vars':vars or[],'color':color,'name':name,'ext_in':Utils.to_list(ext_in),'ext_out':Utils.to_list(ext_out),'before':Utils.to_list(before),'after':Utils.to_list(after),'shell':shell,'scan':scan,}
 631         if isinstance(func,str):
 632                 params['run_str']=func
 633         else:
 634                 params['run']=func
 635         cls=type(Task)(name,(Task,),params)
 636         global classes
 637         classes[name]=cls
 638         return cls
 639 def always_run(cls):
 640         old=cls.runnable_status
 641         def always(self):
 642                 ret=old(self)
 643                 if ret==SKIP_ME:
 644                         ret=RUN_ME
 645                 return ret
 646         cls.runnable_status=always
 647         return cls
 648 def update_outputs(cls):
 649         old_post_run=cls.post_run
 650         def post_run(self):
 651                 old_post_run(self)
 652                 for node in self.outputs:
 653                         node.sig=Utils.h_file(node.abspath())
 654                         self.generator.bld.task_sigs[node.abspath()]=self.uid()
 655         cls.post_run=post_run
 656         old_runnable_status=cls.runnable_status
 657         def runnable_status(self):
 658                 status=old_runnable_status(self)
 659                 if status!=RUN_ME:
 660                         return status
 661                 try:
 662                         bld=self.generator.bld
 663                         prev_sig=bld.task_sigs[self.uid()]
 664                         if prev_sig==self.signature():
 665                                 for x in self.outputs:
 666                                         if not x.sig or bld.task_sigs[x.abspath()]!=self.uid():
 667                                                 return RUN_ME
 668                                 return SKIP_ME
 669                 except KeyError:
 670                         pass
 671                 except IndexError:
 672                         pass
 673                 except AttributeError:
 674                         pass
 675                 return RUN_ME
 676         cls.runnable_status=runnable_status
 677         return cls