Code covered by the BSD License  

Highlights from
fdep: a pedestrian function dependencies finder

image thumbnail

fdep: a pedestrian function dependencies finder

by

 

01 Nov 2007 (Updated )

FDEP dissects ML files and iteratively looks for all user defined functions used during runtime

Editor's Notes:

This file was selected as MATLAB Central Pick of the Week

fdep.m
%FDEP	to show a function's dependencies
%
%	FDEP dissects a MATLAB (ML) file and iteratively looks for
%	all user defined functions (modules), which are used
%	during runtime
%
%	FDEP retrieves for each module the exacty syntax of its
%		- main function
%		- subfunctions
%		- nested functions
%		- anonymous functions
%		- eval class calls
%		- unresolved calls
%	   and all
%		- ML stock functions
%		- ML built-in functions
%		- ML classes
%		- ML toolboxes
%	   that it uses
%
%	runtime options and returned macros create user-friendly,
%	comprehensible, and interactive GUIs, which
%		- list the results in various panels
%		- plot a full dependency matrix
%
%	in essence, FDEP is a wrapper for DEPFUN and MLINT;
%	however, due to an efficient pruning engine
%	it is considerably faster
%
%	see also: depfun, depdir, ckdepfun, mlint, which
%		  and the accompanying HTML file
%
%SYNTAX
%-------------------------------------------------------------------------------
%		P = FDEP(FNAM);
%		P = FDEP(FNAM,OPT1,OPT2,...);
%
%INPUT
%-------------------------------------------------------------------------------
% FNAM	:	M-file (function or script) or P-file
%		- only ML entities can be extracted from
%		  standalone P-files, which do NOT have a
%		  corresponding M-file
%
% OPT	:	description
% --------------------------------------------
% -q	:	do NOT show runtime processing
% -l	:	show module list
% -m	:	show dependency matrix
%
%OUTPUT
%-------------------------------------------------------------------------------
% P		a structure, which returns all information from the lex parser;
%		fields, which are of common interest, are these macros
%
% P.macro()		call macro with default args
% P.macro(arg,...)	call macro with arguments arg1,...
%
%		arg	description
%		--------------------------------------------------------
%  .help	()	show help for the listing panels in a window
%		1	- show help in the command window
%  .list	()	create the GUI that lists the results
%		M	- activate module M
%  .find	M1,...	show the synopsis of modules M1,...
%  .get		M1,...	retrieve all data of modules M1,...
%  .mhelp	M1,...	show all data of module M1,... in a window
%  .mplot	()	create the GUI that shows the dependency matrix
%		N1,...	- show nodes N1,...
%			  numeric input syntax ([M#column/M#row],...)
%			  only valid nodes are shown with guiding lines
%  .tplot	()	show the runtime and modules tree in a window
%
%		Mx	may be numeric or the name of an existing module
%			or cells with any combination of the above
%
%		for more help, see the accompanying HTML file
%
%EXAMPLE
%-------------------------------------------------------------------------------
%		p=fdep('myfile');
%		p.list();	% show module list
%		p.mplot();	% show dependency matrix
%		p.find(2);	% show summary of module #2
%		p.mhelp(3,'m');	% show synopsis of modules #3 and 'm'
%		d=p.get('n');	% retrieve data of module <n>

% for software developers
%
%		mn=2;				% module number
% access module data
%		p.fun(mn)			% module name
%		p.fun(p.mix{mn})		% calls	TO
%		p.fun(p.cix{mn})		% calls	FROM
% access ML data
%		fn=1				% stock	function group
%		p.mlfun{fn}(p.mlix{sn,fn})

%{
	TEST	r2007a
		[z{1:8,1}]=depfun(p.module(v),'-toponly','-quiet');
		z{1}
		mlint(p.module(v),'-a','-calls')
%}


% created:
%	us	07-Mar-2006
% modified:
%	us	21-Jun-2010 02:16:53	/ FEX R2008a

%-------------------------------------------------------------------------------
function	po=fdep(varargin)

		magic='FDEP';
		ver='21-Jun-2010 02:16:53';
		dopt={
			'-toponly'
			'-quiet'
		};
		mopt={
			'-m3'
			'-calls'
		};

	if	nargout
		po=[];
	end
	if	~nargin
	if	nargout
		po=FDEP_ini_engine(ver,magic,dopt,mopt,varargin{:});
		return;
	else
		help(mfilename);
		clear po;
	end
		return;
	end

		[p,par]=FDEP_ini_engine(ver,magic,dopt,mopt,varargin{:});
	if	isempty(par)
		return;
	end

		tim=clock;
		[p,par]=FDEP_get_dep(p,par,p.fun{1});
		p.runtime(1)=etime(clock,tim);

		tim=clock;
		[p,par]=FDEP_end_engine(p,par);
		p.runtime(2)=etime(clock,tim);

% needed to make sure all macros contain the latest parameters!
		tim=clock;
		p=FDEP_flib(magic,p,2);
	if	par.opt.lflg
		p=p.list();
		p=FDEP_flib(magic,p,1);			% needed!
	end
	if	par.opt.mflg
		p=p.mplot();
		p=FDEP_flib(magic,p,1);			% needed
	end

		p.runtime(3)=etime(clock,tim);
% no user-defined dependencies
	if	~p.ncall				&&...
		~par.opt.qflg
		disp(sprintf('\n-------------  NO USER-DEFINED DEPENDENCIES FOUND'));
		r=FDEP_dfind(p.magic,p,false,1);
		disp(char(r.rm));
	elseif	~par.opt.qflg
		ntbx=numel(p.toolbox);
		disp(sprintf('\n%9s: %-1d','toolboxes',ntbx));
	for	i=1:ntbx
		disp(sprintf('%9s: %-1d   %s',' ',i,p.toolbox{i}));
	end
	end

	if	nargout
		po=p;
	end
end
%-------------------------------------------------------------------------------
function	[p,par]=FDEP_ini_engine(ver,magic,dopt,mopt,varargin)

% retrieve current FARG parameter templates
		fap=farg;

		F=false;
		T=true;
		p=[];
		par=[];

% create output structure
		p.magic=magic;
		p.([magic,'ver'])=ver;
		p.([fap.magic,'ver'])=fap.([fap.magic,'ver']);
		p.MLver=version;
		p.section_10='---------- ENGINE  ------------';
		p.rundate=datestr(clock);
		p.runtime=[0,0,0];
		p.par=[];
		p.section_20='---------- INPUT   ------------';
		p.afile={};
		p.file='';
		p.section_30='---------- OUTPUT  ------------';
		p.ncall=0;
		p.nfun=0;
		p.module={};
		p.fun={};
		p.froot={};
		p.sub={};
		p.mix={};				% calls    to
		p.cix={};				% called   from
		p.mlix={};				% system   calls
		p.tix=[];				% function type
		p.depth=[0,0];
		p.nmlcall=zeros(1,6);
		p.mlfun={};
		p.toolbox={};
		p.modbix={};
		p.modbox=[];
		p.tree={};
		p.rtree={};
		p.caller={};
		p.mat=int8([]);
		p.section_31='---------- macros   -----------';
		p.lib=[];
		p.help=[];
		p.get=[];
		p.find=[];
		p.list=[];
		p.mhelp=[];
		p.mplot=[];
		p.tplot=[];
		p.smod=[];
	if	isempty(varargin)
		return;
	end

% output parameters
% - description	.TIX				0	1
%----------------------------------------------------------------
	desc.t={
		0	'C'	'caller		no	yes'
		1	'R'	'recursive	no	yes'
		2	'E'	'evals		no	yes'
		3	'S'	'type		script	function'	
		4	'F'	'type		M-file	P-file'
	};

% - description .SUB().n
%------------------------------------------------------------
	desc.s={
		1	'U'	'functions outside the scope'
		2	'S'	'subfunctions'
		3	'N'	'nested functions'
		4	'A'	'anonymous functions'
		5	'UD'	'user defined functions'
		6	'MS'	'ML stock functions'
		7	'MB'	'ML built-in functions'
		8	'CE'	'calls to eval..'
		9	'MC'	'ML classes'
		10	'OC'	'other classes'
		11	'TB'	'ML tbx'
		12	'X'	'unresolved calls'
	};
%
% - description .CALL{x,n}
%-------------------------------------------------------
	desc.c={
		1	'UD'	'user defined functions'
		2	'MS'	'ML stock functions'
		3	'MB'	'ML built-in functions'
		4	'MC'	'ML classes'
		5	'OC'	'other classes'
		6	'TB'	'ML tbx'
	};

% start engine

% - check file name

	if	~ischar(varargin{1})
		disp(sprintf('%s> input not a string: class <%s>',magic,class(varargin{1})));
		return;
	end
		fnam=varargin{1};

% - select file name
%   this is NOT as trivial as it seems...

		[fpat,frot,fext]=fileparts(fnam);	%#ok
	if	isempty(fext)
		fext='.m';
	end

		afnam=which(fnam,'-all');
	if	isempty(afnam)
		disp(sprintf('%s> file not found or not a valid MATLAB file <%s>',magic,varargin{1}));
		return;
	end

		[apat,arot,aext]=cellfun(@fileparts,afnam,'uni',false);	%#ok
		ix=	strcmp(arot,frot)		&...
			strcmp(aext,fext);
	if	~any(ix)
		disp(sprintf('%s> file not valid <%s>',magic,varargin{1}));
		disp(sprintf('%s> files %8d\n',magic,numel(afnam)));
		disp(char(afnam));
		return;
	else
		fnam=afnam{find(ix,1,'first')};
	end

	if	~exist(fnam,'file')
		disp(sprintf('%s> file not found <%s> = %s',magic,varargin{1},fnam));
		return;
	end

% - simple option parser
		opt.qflg=false;
		opt.lflg=false;
		opt.mflg=false;
		opt.dflg=false;				% hidden flag
	if	nargin > 4
	for	i=1:numel(varargin)
	switch	varargin{i}
	case	'-q'
		opt.qflg=true;
	case	'-l'
		opt.lflg=true;
	case	'-m'
		opt.mflg=true;
	case	'-d'
		opt.dflg=true;
	end
	end
	end

		par.farg=fap;
		par.opt=[];
		par.desc=[];
		par.enum=[];
% - macros
		par.macro.sr=@(t) strrep(t,'\','/');
		par.macro.range=@(x) max(x)-min(x);	% replacement for <stats tbx>

% - engine parameters
		[fpat,frot]=fileparts(fnam);
		fnam=par.macro.sr(fnam);

		par.mlroot=[matlabroot,filesep,'toolbox'];
		par.opt=opt;
		par.dopt=dopt;
		par.mopt=mopt;
		par.x=0;				% loop counter
		par.xx=1;				% entry
		par.c=0;				% depth
		par.e=0;
		par.fix=[];
		par.ac={sprintf('%-4d: * %s',0,frot)};
		par.am={fnam};
		par.nn=12;
		par.nc=6;
		par.call=cell(1,6);

% - templates
		par.rexcls='^\w';			% module class
		par.rexmod='\w+$';			% module
		par.rexmod='(\w+$)|(\d+$)';
		par.rextbx='\w+';			% find toolboxes
		par.rexmbi='(?<=\().+(?=\))';		% full path to built-in
		par.rexscr='(?<=\\)\w+(?=\.[mp]$)';	% file roots

		par.spec=[0,0,0,0];
		par.dspec='RESP';

		par.fdes={'FUNCTION','SCRIPT'};
		par.rdes={'no','yes','not known'};
		par.edes={'not used','used','not known'};

%   unique program id for the module manager
		par.tagpid=sprintf('%s.%s.module.',magic,num2hex(rand));
		par.tagid={
			'PIDhelp      > '
			'PIDlist      > '
			'PIDmatrix    > '
			'PIDsynopsis  > '
			'PIDmanager   > '
			'PIDtree      > '
		};
		par.tagid=strrep(par.tagid,'PID',par.tagpid);
		par.tag={
			@(varargin) sprintf('%s%s',par.tagid{1,1},varargin{1})
			@(varargin) sprintf('%s%s',par.tagid{2,1},varargin{1})
			@(varargin) sprintf('%s%s',par.tagid{3,1},varargin{1})
			@(varargin) sprintf('%s%s',par.tagid{4,1},varargin{1})
			@(varargin) sprintf('%s%s',par.tagid{5,1},varargin{1})
			@(varargin) sprintf('%s%s',par.tagid{6,1},varargin{1})
		};

		par.ixbi=5;				% MLINT calls
		par.ixsub={...
%		call M-file (ML)
			'C',{2,T,	'ML   M  %s'}
%		built-in
			'B',{5,F,	'        built-in'}
%		call P-file (ML)
			'P',{6,T,	'ML   P  %s'}
%		call P-file (user)
			'D',{7,T,	'CALL P  %s'}
%		recursion
			'R',{-1,F,	'------  RECURSION'}
%		call M-file (user)
			'M',{-5,T,	'CALL M  %s'}
%		subfunction
			'S',{-100,F,	'------  SUBFUNCTION'}
%		nested
			'N',{-101,F,	'------  NESTED FUNCTION'}
%		anonymous
			'A',{-102,F,	'------  ANONYMOUS FUNCTION'}
%		f/eval...
			'E',{-400,F,	'------  EVAL'}
%		unresolved
			'X',{-500,F,	'--**--  NOT FOUND'}
		}.';

%   descriptor: module
		par.mtag={
			'@@@UNRESOLVED@@@'
			'@@@TOOLBOX@@@'
		};

		par.mktxtm=@(a,b,ix) {
		sprintf('M-FILE       : %s',a.sub(ix).M)
		sprintf('P-FILE       : %s',a.sub(ix).P)
		sprintf('MODULE  #%4d: %s',ix,a.module{ix})
		sprintf('type         : %s',b.fdes{a.tix(ix,4)+1})
		sprintf('created      : %s',b.date)
		sprintf('size         : %-1d bytes',b.size)
		sprintf('lines        : %-1d',a.sub(ix).l)
		sprintf('comments     : %-1d',a.sub(ix).cl)
		sprintf('empty        : %-1d',a.sub(ix).el)
		sprintf('recursive    : %s',b.rdes{a.tix(ix,2)+1})
		sprintf('f/eval..     : %s',b.edes{a.tix(ix,3)+2*max([0,(a.tix(ix,5)-a.sub(ix).mp(1))])+1})
		sprintf('unresolved   : %s',b.rdes{double(a.sub(ix).n(b.enum.s.X)~=0)+isinf(a.sub(ix).n(b.enum.s.X))+1});
		sprintf('calls    TO  : %5d  user defined',numel(a.mix{ix}))
		sprintf('called   FROM: %5d  user defined',numel(a.cix{ix}))
		sprintf('calls in FILE: %5d              ',a.sub(ix).n(b.enum.s.U))
		sprintf('subfunctions : %5d  inside  file',a.sub(ix).n(b.enum.s.S))
		sprintf('nested       : %5d              ',a.sub(ix).n(b.enum.s.N))
		sprintf('anonymous    : %5d              ',a.sub(ix).n(b.enum.s.A))
		sprintf('f/eval..     : %5d              ',a.sub(ix).n(b.enum.s.CE))
		sprintf('unresolved   : %5d              ',~isinf(a.sub(ix).n(b.enum.s.X))*a.sub(ix).n(b.enum.s.X));
		par.mtag{1,1}
		sprintf('ML      stock: %5d              ',numel(a.mlix{ix,1}))
		sprintf('ML  built-ins: %5d              ',numel(a.mlix{ix,2}))
		sprintf('ML    classes: %5d              ',numel(a.mlix{ix,3}))
		sprintf('OTHER classes: %5d              ',numel(a.mlix{ix,4}))
		sprintf('ML  toolboxes: %5d              ',numel(a.mlix{ix,5}))
		par.mtag{2,1}
		};

%   descriptor: main program
		par.mktxtf=@(a,b,ix) {
		sprintf('ROOT         : %s',a.module{1})
		sprintf('type         : %s',b.fdes{a.tix(1,4)+1})
		sprintf('recursive    : %s',b.rdes{a.tix(1,2)+1})
		sprintf('f/eval..     : %s',b.edes{a.tix(1,3)+2*max([0,(a.tix(1,5)-a.sub(1).mp(1))])+1})
		sprintf('FDEP  version: %s',a.FDEPver);
		sprintf('ML    version: %s',a.MLver)
		sprintf('ML      stock: %5d',a.nmlcall(1))
		sprintf('ML  built-ins: %5d',a.nmlcall(2))
		sprintf('ML    classes: %5d',a.nmlcall(3))
		sprintf('OTHER classes: %5d',a.nmlcall(4))
		sprintf('ML  toolboxes: %5d',numel(a.mlfun{5}))
		sprintf('runtime      : %10.4f sec',sum(a.runtime(1)));
		};

%   MLINT templates
		par.ftmpl='M0';
		par.stmpl={
			'U'	3	F	@(x) regexp(x,par.rexmod,'match')
			'S'	3	T	@(x) regexp(x,par.rexmod,'match')
			'N'	3	T	@(x) regexp(x,par.rexmod,'match')
			'A'	[1,4]	T	''
			'E'	0	F	''
		};
		par.stmplf=fap.par.stmplf;	% latest FARG
		par.stmpla.M=[];
		par.stmpla.P=[];
		par.stmpla.mp=[];
		par.stmpla.l=0;
		par.stmpla.cl=0;
		par.stmpla.el=0;
		par.stmpla.nn=par.nn;
		par.stmpla.des={};
		par.stmpla.n=[];
	for	i=1:size(par.stmpl,1)
		fn=par.stmpl{i,1};
		par.stmpla.(fn)=par.stmplf{i,2};
	end

%   DEPFUN templates
		par.mlfield={
			'MLfunction'
			'MLbuiltin'
			'MLclass'
			'OTHERclass'
			'MLtoolbox'
			'MLtoolbox'			% KEEP THIS!
		};

%   link templates
		par.sn={
%			fieldname	cell	sort
			'module'	F	F
			'fun'		F	F
			'sub'		F	F
			'mix'		T	T
			'cix'		T	T
			'mlix'		F	F
			'tix'		F	F
			'depth'		F	F
		};

		par.ixsub=struct(par.ixsub{:});
		par.call(1,1)={par.macro.sr(fnam)};

% - graphics
%{
	original color scheme
		par.mcol=[.75,1,1];			% color: modules
		par.fcol=[1,1,.75];			% color: module
		par.pcol=[.85,1,.85];			% color: main pg
%}
%	john d'errico adjustment
		par.mcol=[.85,1,1];			% color: modules
		par.fcol=[1,1,.85];			% color: module
		par.pcol=[.95,1,.95];			% color: main pg
		par.tcol=[0,0,1];			% color: text
		par.rcol=[1,.95,.95];			% color: tree

		ss=get(0,'screensize');
		par.lwin=[.3*ss(3),100,.7*ss(3)-20,ss(4)-160];
		par.hwin=[10,50,.5*ss(3)-20,ss(4)-80];

% output structure
		p.afile=afnam;
		p.file=fnam;

% user defined functions
		p.module={frot};
		p.fun={fnam};
		p.froot={[fpat,filesep,frot]};
		p.sub=par.stmpla;

% descriptors/enumerators
		fn=fieldnames(desc);
	for	i=1:numel(fn)
		cf=fn{i};
		par.desc.(cf)=desc.(cf);
		par.enum.(cf)=desc.(cf)(:,[2,1]).';
		par.enum.(cf)=struct(par.enum.(cf){:});
	end
end
%-------------------------------------------------------------------------------
function	[p,par]=FDEP_end_engine(p,par)

% stop engine
		p.nfun=numel(p.fun);
		p.par=par;

	for	i=1:p.nfun
		p.fun=par.macro.sr(p.fun);
		p.froot=par.macro.sr(p.froot);
	end

		ml=max(cellfun('length',par.ac));
		cm=[num2cell(1:numel(par.ac));par.ac.';par.am.'];
		fmt=sprintf('%%-4d %%-%ds -> %%s\n',ml+2);
		p.tree=sprintf(fmt,cm{:});
		p.tree=strread(p.tree,'%s','delimiter','','whitespace','');

		txt=sprintf('%-9.9s: > %s','ROOT',p.file);
		p.rtree=[[{txt},{''}];p.rtree];

		p.rtree=[char(p.rtree(:,1)),repmat('   ',size(p.rtree,1),1),char(p.rtree(:,2))];
	
		t=strrep(p.mlfun{1},par.macro.sr([matlabroot,filesep,'toolbox',filesep]),'');
		p.mlfun{5}=unique(regexp(t,par.rextbx,'match','once'));
		ntbx=numel(p.mlfun{5});
		tf=true(ntbx,1);
		tnam=cell(ntbx,1);
	for	i=1:ntbx
		tver=ver(p.mlfun{5}{i});
	if	~isempty(tver)
		tnam{i}=sprintf('%s (%s) [%s]',tver.Name,tver.Version,p.mlfun{5}{i});
	else
		tf(i)=false;
	end
	end
		p.mlfun{5}=p.mlfun{5}(tf);
	if	any(tf)
		p.mlfun{6}=tnam(tf);
		p.toolbox=tnam(tf);
	else
		p.mlfun{6}={};
		p.toolbox=[];
	end

		p.cix=cell(p.nfun,1);
		p.mlix=cell(p.nfun,6);

	for	i=1:p.nfun
		ix=ismember(p.fun,par.call{i,1});
		ix=par.fix(ix);
		p.mix{i,1}=ix.';
		p.cix(ix,1)=cellfun(@(x) [x,i],p.cix(ix,1),'uni',false);
	for	j=1:5
		ix=ismember(p.mlfun{j},par.call{i,j+1});
		p.mlix{i,j}=find(ix);
		p.nmlcall(j)=numel(ix);
	end
		p.mlix{i,j+1}=p.mlix{i,j};
		p.nmlcall(j+1)=p.nmlcall(j);
	end
		p=FDEP_fsort(p,par);
		p=FDEP_cmp_depmat(p);
		p=FDEP_parse_modules(p,par);
		p=FDEP_get_modtbx(p);
end
%-------------------------------------------------------------------------------
function	p=FDEP_flib(magic,p,nr)

% assign FDEP functions
% - do NOT change this tedious assingment!
% - requires a lot of time!
	for	i=1:nr
		p.lib=@()		FDEP_flib(magic,p,2);
		p.help=@(varargin)	FDEP_manager([],[],mfilename,p,'p',varargin{:});
		p.get=@(varargin)	FDEP_dget(magic,p,varargin{:});
		p.find=@(varargin)	FDEP_dfind(magic,p,true,varargin{:});
		p.list=@(varargin)	FDEP_dlist(magic,p,varargin{:});
		p.mhelp=@(varargin)	FDEP_mlist(magic,p,varargin{:});
		p.mplot=@(varargin)	FDEP_dplot(magic,p,varargin{:});
		p.tplot=@(varargin)	FDEP_rtree(magic,p,varargin{:});
	if	~isfield(p,'smod')
		p.smod=[];
	end
	end
end
%-------------------------------------------------------------------------------
function	[p,par]=FDEP_get_dep(p,par,fnam)

		par.x=par.x+1;
		par.c=par.c+1;

		fnam=which(fnam);
		[fpat,frot]=fileparts(fnam);		%#ok

		[p,par,dtmp,dmlf,dmod,dmcl,docl]=FDEP_get_fun(p,par,fnam,frot);
		wtmp=dtmp;

		mltbx=strrep(dmlf,[matlabroot,filesep,'toolbox',filesep],'');
		mltbx=unique(regexp(mltbx,par.rextbx,'match','once'));
		par.call(par.xx,:)={
			par.macro.sr(dtmp(2:end))
			par.macro.sr(dmlf)
			par.macro.sr(dmod)
			par.macro.sr(dmcl)
			par.macro.sr(docl)
			par.macro.sr(mltbx)
		};

	if	par.x > 1
		p.mlfun={
			unique([p.mlfun{1};par.call{par.xx,2}])
			unique([p.mlfun{2};par.call{par.xx,3}])
			unique([p.mlfun{3};par.call{par.xx,4}])
			unique([p.mlfun{4};par.call{par.xx,5}])
			unique([p.mlfun{5};par.call{par.xx,6}])
			unique([p.mlfun{5};par.call{par.xx,6}])
		};
	else
		p.mlfun=par.call(1,2:end).';
	end

		tmpd=cellfun(@(x) x(1:find(x=='.',1,'last')-1),...
			dtmp,...
			'uni',false);
		ix=ismember(tmpd,p.froot);
		dtmp(ix)=[];
		ndtmp=numel(dtmp)-1;
		p.ncall=p.ncall+ndtmp+1;

	if	numel(dtmp) < 2
		m={'()'};
	else
		m=dtmp(2:end);
	end
		c=repmat({
			sprintf('%-4d: %s| %s',...
				par.x,repmat(' ',1,2*(par.c-1)),frot)
			},...
			numel(m),1);
		par.ac=[par.ac;c];
		par.am=[par.am;m];

		p.tix(par.x,:)=[1,par.spec];
	if	~numel(dtmp)
		ix=ismember(p.fun,wtmp(2:end));
		ofix='';
		p.tix(par.x,1)=0;
	if	any(ix)
		p.tix(par.x,1)=1;
		ofix=par.fix(ix);
		ofix=sprintf('%-1d ',ofix);
		ofix(end)='';
	end
		fnum=numel(find(ix));
		[p,par]=FDEP_show_entry(p,par,frot,fnum,ofix);
	else

		keep=par.c;
		par.e=keep;
	for	i=1:numel(dtmp)
		[dpat,drot]=fileparts(dtmp{i});
		tmpd=[dpat,filesep,drot];
		ix=ismember(tmpd,p.froot);
	if	~any(ix)
		p.fun=[p.fun;dtmp{i}];
		p.froot=[p.froot;{tmpd}];
		p.module=[p.module;{drot}];
	if	i == 1
		[p,par]=FDEP_show_entry(p,par,frot,1,dtmp{i});
	end
		[p,par]=FDEP_get_dep(p,par,dtmp{i});
	end
		par.e=keep;

	end
	end
		par.c=par.c-1;
end
%-------------------------------------------------------------------------------
function	[p,par,dtmp,dmlf,dmod,dmcl,docl]=FDEP_get_fun(p,par,fnam,frot)

% DEPFUN	arg	description		FDEP		r2008a
%		------------------------------------
%		1	trace list		dtmp
%		2	built-in list		dmod
%		3	ML classes		dmcl
%		4	problem list		n/u
%		5	not used		n/u
%		6	eval strings		n/u
%		7	called from list	docx
%		8	other classes		docl

		[dtmp,dmod,dmcl,docx,docx,docx,docx,docl]=depfun(fnam,par.dopt{:});	%#ok
		im=strncmp(par.mlroot,dtmp,numel(par.mlroot));
		dmlf=dtmp(im);
		dtmp(im)=[];

% FARG
% - resolve calls inside the function file

		[fa,fap]=farg(fnam,'-s','-d');

		senum=par.enum.s;
		tenum=par.enum.t;
							% tix : CRESP
		par.spec=[0,0,0,0];			% spec:  RESP

		dtmp{1}=fap.wnam;
	if	fap.mp(1)
		p.fun{end}=fap.wnam;
		dtmp{1}=fap.wnam;
	elseif	fap.mp(2)
		p.fun{end}=fap.pnam;
		dtmp{1}=fap.pnam;
	else
		p.fun{end}=fap.wnam;
	end
		fap.U=fap.UU;				% reset to ALL U

		ex=cellfun(@exist,fap.U.fn);
		dmod=unique([dmod;fap.U.fn(ex==par.ixbi)]);
		par.spec(tenum.F)=+fap.mp(2);		% spec: M/P

		sub=par.stmpla;
		sub.M=par.macro.sr(fap.wnam);		% - M-file name
		sub.P=par.macro.sr(fap.pnam);		% - P-file name
		sub.mp=fap.mp;				% - M/P indicator
		sub.l=fap.par.nlen;			% - #lines
		sub.cl=fap.par.ncom;			% - #comments
		sub.el=fap.par.nemp;			% - #empty lines
		sub.des=par.desc.s(:,2).';		% - index descriptors
		sub.n=zeros(1,sub.nn);
		sub.n(1,size(par.stmpl,1):end)=...
			[numel(dtmp)-1,numel(im),numel(dmod),0,numel(dmcl),numel(docl),0,0];

		sub.E.fn={};
		sub.E.bx=fap;
		sub.E.ex=ex;

	if	isempty(fa)
	if	fap.par.mp(2)
		sub.l=nan;
		sub.n([senum.U,senum.CE])=nan;		% - no MAIN
		sub.n(senum.X)=inf;
	end
	if	~isempty(docx{1})
		par.spec(tenum.R)=1;			% spec: R
	end
		p.sub(par.xx,1)=sub;
		return;
	end
		sub.n(senum.U:senum.A)=fap.n([6,2:4]);

	if	~fap.par.nlen
		par.spec(tenum.S)=1;			% spec: S
		dmlf={};
		dmod={};
		dmcl={};
		docl={};
		p.sub(par.xx,1)=sub;
		return;
	end

	for	i=1:size(par.stmpl,1)
	if	par.stmpl{i,2}
		fn=par.stmpl{i,1};
		sub.(fn)=fap.(fn);
	end
	end
		sub.S.fn=fap.sub;
	if	fap.M.nx
		sub.S.fd=[fap.M.fn;fap.S.fn];
		sub.n(senum.S)=sub.n(senum.S)+1;
		sub.S.nx=sub.S.nx+1;
		sub.S.bx=[fap.M.bx,sub.S.bx];
	end

		c=fap.par.call;
		sx=strmatch(par.stmpl{1,1},c);
		c=c(sx);
		f=regexp(c,par.rexmod,'match');
		f=[f{:}].';
		sub.E.fn=f;
		sub.n(senum.X)=0;
		sub.E.bx=fap;
		sub.E.ex=ex;

% script
	if	~fap.par.mfun
		par.spec(tenum.S)=1;			% spec: S
		f=[frot;f];
		m=regexp(dtmp,par.rexscr,'match');
		m=[m{:}].';
		is=ismember(m,f);
		dtmp=dtmp(is);
	end

		[sub,par]=FDEP_parse_calls(frot,sub,par);
		p.sub(par.xx,1)=sub;
end
%-------------------------------------------------------------------------------
function	[sub,par]=FDEP_parse_calls(module,sub,par)
% resolve calls
% - subroutines

		f=sub.E.fn;
		ex=sub.E.ex;
		fap=sub.E.bx;
		senum=par.enum.s;
		tenum=par.enum.t;

% f/eval..
		ir=	strncmp('eval',fap.par.ltok(:,2),4)	|...
			strncmp('feval',fap.par.ltok(:,2),5);
	if	any(ir)
		par.spec(tenum.E)=1;			% spec: E
		sub.n(senum.CE)=numel(find(ir));
		ir=	strncmp('eval',fap.U.fn,4)	|...
			strncmp('evalc',fap.U.fn,5)	|...
			strncmp('evalin',fap.U.fn,6)	|...
			strncmp('feval',fap.U.fn,5);
		ex(ir)=par.ixsub(1).E;
	end

% resolved
		fu=sub.U.fn;
	if	sub.n(senum.S)
		ir=ismember(fu,sub.S.fd);
		ex(ir)=par.ixsub(1).S;
	end
	if	sub.n(senum.N)
		ir=ismember(fu,sub.N.fn);
		ex(ir)=par.ixsub(1).N;
	end

% unresolved
		fx=find(ex==0);
		sub.E.fn=fap.U.fn(~ex);
		ns=numel(sub.S.fd);
		ne=numel(sub.E.fn);
	if	all([ns,ne])				&&...
		any(fx)

		fu=sub.E.fn;
	if	sub.n(senum.S)
		ir=ismember(fu,sub.S.fd);
		ex(fx(ir))=par.ixsub(1).S;
	end
	if	sub.n(senum.N)
		ir=ismember(fu,sub.N.fn);
		ex(fx(ir))=par.ixsub(1).N;
	end

	end

% recursion
		ir=strcmp(module,f);
	if	any(ir)
		par.spec(1)=1;				% spec: R
		ex(ir)=par.ixsub(1).R;
	end

		sub.n(senum.X)=sum(~ex);
		sub.E.fn=fap.U.fn(~ex);
		ex(~ex)=par.ixsub(1).X;
		sub.E.ex=ex;
	if	sub.U.nx
		sub.E.bx=sub.U.bx(1,ex==par.ixsub(1).X);
	else
		sub.E.bx=[];
	end
end
%-------------------------------------------------------------------------------
function	[p,par]=FDEP_parse_modules(p,par)

% resolve calls
% - external modules

		p.fun=par.macro.sr(p.fun);
		p.froot=par.macro.sr(p.froot);

	for	i=1:p.nfun
		sub=p.sub(i,1);

	if	~isempty(sub.E.ex)

		ex=sub.E.ex;
		sub.U.fd=repmat({''},size(sub.U.fn));

% P-files
		ir=find(ex==par.ixsub(1).P);
	if	any(ir)
		sub.U.fd(ir)=cellfun(@(x) par.macro.sr(which(x)),...
			sub.U.fn(ir),...
			'uni',false);
		a=ismember(sub.U.fn(ir),p.module);
		ex(ir(a))=par.ixsub(1).D;
	end

% user-defined functions
		ir=find(ex==par.ixsub(1).C);
	if	any(ir)
		[a,b]=ismember(sub.U.fn(ir),p.module);
	if	any(a)
		sub.U.fd(ir(a))=p.fun(b(b>0));
		ex(ir(a))=par.ixsub(1).M;
	end

% ML stock functions
		ir=ir(~a);
	if	any(ir)
		sub.U.fd(ir)=cellfun(@(x) par.macro.sr(which(x)),...
			sub.U.fn(ir),...
			'uni',false);
	end
	end
		sub.E.ex=ex;
	end
		p.sub(i,1)=sub;
	end
end
%-------------------------------------------------------------------------------
function	p=FDEP_cmp_depmat(p)

		tix=(p.tix(:,1)~=0 | p.tix(:,2)~=0).';
		p.caller=p.module(tix);			% functions
		nc=(1:sum(tix)).';
		p.mat=zeros(p.nfun,'int8');
	for	i=1:p.nfun
		p.mat(p.mix{i},i)=1;
	if	p.tix(i,2)
		p.mat(i,i)=-1;
	end
	end
		p.mat(:,~tix)=[];
		p.mat=p.mat(:,nc);
end
%-------------------------------------------------------------------------------
function	[p,par]=FDEP_show_entry(p,par,frot,fnum,fnam)

		par.fix(par.xx,1)=par.xx;
		p.depth(par.xx,1)=par.e;
		p.depth(par.xx,2)=par.c;

		sp=repmat(' ',1,2*(par.c-1));
	if	par.e > 0				&&...
		par.e < par.c
		sp(2*(par.e)-1)='.';
	end
		spec=repmat(' ',1,numel(par.dspec));
		spec(par.spec~=0)=par.dspec(par.spec~=0);

		cc=sprintf('%-4d %-4d: %s| %s',...
			par.xx,par.c,...
			sp,...
			frot);
		cm=sprintf('%4.4s %-1d: %s',...
			spec,fnum,fnam);
		p.rtree(par.xx,:)={cc,cm};
		par.xx=par.xx+1;

	if	~par.opt.qflg
	if	par.xx == 2
		disp(sprintf('%-7.7s: > %s','ROOT',p.file));
	end
		disp([cc,sprintf('\t'),cm]);
	end
end
%-------------------------------------------------------------------------------
function	p=FDEP_fsort(p,par)

		ns=size(par.sn,1);
		[ix,ix]=sort(p.module(2:end));		%#ok
		ix=[1;ix+1];
		[is,is]=sort(ix);			%#ok
	for	i=1:ns
		fn=par.sn{i,1};
	if	par.sn{i,2}
	for	j=1:numel(p.(fn))
		p.(fn){j}=sort(is(p.(fn){j}).');
	end
	end
		p.(fn)=p.(fn)(ix,:);
	end

end
%-------------------------------------------------------------------------------
function	rm=FDEP_set_ent(p,cix,rm)

		io=strfind(rm{1},':');
		io=io(1);
% 		fmt=[repmat(' ',1,io-1),': %s'];
		fmt=[repmat(' ',1,io-1),': %+5d  %s'];

% ML toolboxes
		ix=find(strcmp(rm,p.par.mtag{2,1}));
		val=p.mlix{cix,end};
	if	~isempty(val)
		ne=numel(val);
		tmp=cell(ne,1);
		tbx=p.toolbox(val);
	for	i=1:ne
		tmp{i,1}=sprintf(fmt,i,tbx{i});
	end
		tmp=char(tmp);
		rm(ix)={tmp};
	else
		rm(ix)=[];
	end

% unresolved calls
		ix=find(strcmp(rm,p.par.mtag{1,1}));
		val=p.sub(cix).E.fn;
	if	~isempty(val)
		ne=numel(val);
		tmp=cell(ne,1);
	for	i=1:ne
		tmp{i,1}=sprintf(fmt,i,p.sub(cix).E.fn{i});
	end
		tmp=char(tmp);
		rm(ix)={tmp};
	else
		rm(ix)=[];
	end
end
%-------------------------------------------------------------------------------
function	p=FDEP_get_modtbx(p)

		mrk1='@#@#@#';
		mrk2='&#&#&#';

		nt=numel(p.toolbox);
		ix=false(p.nfun,nt);
		tbx=cell(nt,4);
		txt=cell(nt,1);
	for	i=1:nt
		ix(:,i)=cellfun(@(x) any(x==i),p.mlix(:,5));
		ixs=sum(ix(:,i));
		ixm=find(ix(:,i));
		tt=[{
			mrk1
			sprintf('%s',p.toolbox{i})
			mrk2
			}
			cellfun(@(x,y,z) sprintf('%6d/%6d:   %s',x,y,z),...
				num2cell(1:ixs).',...
				num2cell(ixm),...
				p.fun(ix(:,i)),'uni',false)
		];
		tbx(i,1)={p.toolbox(i)};
		tbx(i,2)={p.fun(ix(:,i))};
		tbx{i,3}=tt;
		tbx{i,4}=find(ix(:,i));
		txt{i,1}=tt;
	end

	if	nt
		txt=cat(1,txt{:});
		ml=max(cellfun(@numel,txt));
		txt=strrep(txt,mrk1,repmat('=',1,ml));
		txt=strrep(txt,mrk2,repmat('-',1,ml));
		p.modbix=tbx(:,end);
		p.modbox=txt;
	end
end
%-------------------------------------------------------------------------------
%-------------------------------------------------------------------------------
% OUTPUT utilities
%	- dget
%	- dfind
%	- dlist
%	- dplot
%	- mhelp
%-------------------------------------------------------------------------------
%-------------------------------------------------------------------------------
function	tf=FDEP_chkpar(magic,p)

		tf=false;
	if	isstruct(p)				&&...
		isfield(p,'magic')			&&...
		strmatch(magic,p.magic)
		tf=true;
		return;
	end
		disp(sprintf('%s> not a valid FDEP structure',magic));
end
%-------------------------------------------------------------------------------
function	r=FDEP_dget(magic,p,varargin)

		r=[];
	if	nargin < 3
		disp(sprintf('%s> usage: P.get(M1,...)',magic));
	if	~nargout
		clear r;
	end
		return;
	end

	if	isstruct(varargin{1})			&&...
		isfield(varargin{1},'ix')
		p=varargin{1};				% MHELP!
	else
		p=FDEP_dfind(magic,p,false,varargin{:});
	end

		senum=p.par.enum.s;

	if	~isempty(p.ix)
	for	i=1:numel(p.ix)
		ix=p.ix(i);
		tix=p.tix(ix,:);
		del=repmat('-',1,max([numel(p.fun{ix}),numel(p.file)]));

	if	~isempty(p.sub(ix).M)
		ac=p.sub(ix).U.fn;

% check unassigned calls
	if	~isnan(p.sub(ix).n(senum.U))			&&...
		p.sub(ix).n(senum.U)

		mu=max(cellfun(@numel,p.sub(ix).U.fn));
		fmt=sprintf('%%5d    %%-%d.%ds  >  %%s',mu,mu);
		ac=cell(p.sub(ix).n(senum.U),1);
		ex=p.sub(ix).E.ex;

		mod=p.par.ixsub(1);
		tfmt=p.par.ixsub(3);
		nf=fieldnames(p.par.ixsub);
	for	j=1:numel(nf)
		cf=nf{j};
		ir=ex==mod.(cf);
	if	any(ir)
		cu=p.sub(ix).U.fn(ir);			% module name
		cd=p.sub(ix).U.fd(ir);			% module file
		cb=num2cell(p.sub(ix).U.bx(1,ir)).';	% line

		g2=cellfun(@(a,b,c) sprintf(tfmt.(cf),a),...
			cd,...
			'uni',false);
		ac(ir)=cellfun(@(a,b,c) sprintf(fmt,a,b,c),...
			cb,cu,g2,...
			'uni',false);
	end
	end
	end

% ID
		rtmp.magic=[p.magic,'module'];
		rtmp.([magic,'ver'])=p.([magic,'ver']);
		rtmp.MLver=p.MLver;
		rtmp.rundate=p.rundate;
% module(s) content
		rtmp.MODULE_DESCRIPTION___________=del;
		rtmp.module=p.module{ix};
		rtmp.file=p.fun{ix};
		rtmp.parent=p.file;
		rtmp.index=ix;
		rtmp.type=p.par.fdes{tix(4)+1};
		rtmp.isscript=tix(4);
		rtmp.ispfile=isnan(p.sub(ix).l);
		rtmp.isrecursive=tix(2);
		rtmp.haseval=tix(3);
		rtmp.hasunresolved=~((double(p.sub(ix).n(senum.X)~=0)+isinf(p.sub(ix).n(senum.X))-1)~=0);
		rtmp.hascalls=numel(p.fun(p.mix{ix}));
		rtmp.iscalled=numel(p.fun(p.cix{ix}));
		rtmp.synopsis=p.rs{i};
		rtmp.MODULE_FUNCTIONS___________=del;
		rtmp.calls=ac;
		rtmp.subfunction=p.sub(ix).S.fn;
		rtmp.nested=p.sub(ix).N.fd;
		rtmp.anonymous=p.sub(ix).A.fd;
		rtmp.unresolved=p.sub(ix).E.fn;
		rtmp.callsTO=p.fun(p.mix{ix});
		rtmp.callsFROM=p.fun(p.cix{ix});
		rtmp.ML_FUNCTIONS___________=del;
	for	j=1:size(p.par.mlfield,1)
		fn=p.par.mlfield{j,1};
		rtmp.(fn)=p.mlfun{j}(p.mlix{ix,j});
	end
	if	i==1
		clear	r;
		r=rtmp;
		r(numel(p.ix))=rtmp;			% allocate
	else
		r(i)=rtmp;				%#ok
	end
	end
	end
	end

end
%-------------------------------------------------------------------------------
function	po=FDEP_dfind(magic,p,dflg,varargin)

	if	nargin < 3
		disp(sprintf('%s> usage: P.find(M1,...)',magic));
	if	~nargout
		clear p;
	end
		return;
	end
	if	~FDEP_chkpar(magic,p)
	if	nargout
		po=p;
	end
		return;
	end

		hdr='-------------';
		srch={
			'module'	true
			'fun'		false
		};

		ic=cellfun('isclass',varargin,'cell');
		narg=numel(varargin);
		nmod=sum(cellfun(@numel,varargin));

		p.ix=[];
		p.ry={};
		p.rm={};
		p.rf={};
		p.rs=cell(nmod,1);

		nm=0;
	for	i=1:narg
	if	ic(i)
		varg=varargin{i};
	else
		varg=varargin(i);
	end
		nvarg=numel(varg);

	for	j=1:nvarg
		ix=[];

		carg=varg{j};
	if	ischar(carg)
	for	k=1:size(srch,1)
		fn=srch{k,1};
	if	srch{k,2}
		ix=strmatch(carg,p.(fn),'exact');
	else
		ix=strmatch(carg,p.(fn));
	end
	if	~isempty(ix)
		break;
	end
	end

	elseif	isnumeric(carg)
		ix=carg(carg>0 & carg<=p.nfun);
	end

		p.ix=[p.ix;ix(:)];
	for	k=1:numel(ix)
		nm=nm+1;
		cix=ix(k);
	if	~isempty(cix)
		fdir=dir(p.fun{cix});
		p.par.date=fdir.date;
		p.par.size=fdir.bytes;
		rm=p.par.mktxtm(p,p.par,cix);
		p.ry=rm;
		rm=FDEP_set_ent(p,cix,rm);
		p.rm=[p.rm;rm];
		p.rf=[p.rf;rm;{hdr}];
		p.rs{nm,1}=rm;
	if	cix == 1
		rf=p.par.mktxtf(p,p.par,cix);
		p.rf=[p.rf;rf;{hdr}];

	end
	end	% K
	end	% J
	end	% I
	end

	if	~isempty(p.ix)
		p.rf(end)=[];
	end

	if	dflg
		disp(char(p.rf));
	end

	if	nargout
		po=p;
	end
end
%-------------------------------------------------------------------------------
function	p=FDEP_dlist(magic,p,varargin)

	if	~FDEP_chkpar(magic,p)
		return;
	end
		par=p.par;

		n=1;
		mrg=.01;
		l3=1/3;					% l = <el>!
		l4=1/5-mrg/5;
		xoff=0;
		yoff=mrg;
		ylen=l4-mrg-.02;
		xle2=2*l3-mrg;
		LB='listbox';
		fs=8;
		xpos=linspace(.5,1-mrg,6);
		dx1=xpos(2)-xpos(1);
		dx1=dx1-.01*dx1;

		ftag=p.par.tag{2}(p.module{1});
		fh=findall(0,'tag',ftag);
	if	isempty(fh)
		fh=figure;
	else
		figure(fh);
		shg;
		lh=get(fh,'userdata');
	if	numel(varargin)				&&...
		~isempty(varargin{1})
	if	ischar(varargin{1})
		p=FDEP_dfind(magic,p,false,varargin{1});
	if	~isempty(p.ix)
		n=p.ix;
	end
	else
		n=varargin{1};
	end
		FDEP_cb_list(lh(1),[],p,par,lh,lh(end),n);
	end
		FDEP_manager(fh,'dlist','dlist',p,'w',false);
		figure(fh);
		return;
	end
		ss=get(0,'screensize');
		fp=[.25*ss(3),50,.75*ss(3)-20,ss(4)-80];
		set(fh,'position',fp);
		fcol=get(fh,'color');

% macros
% - text position
			spos=@(x) [x(1:2)+[0,x(4)+.003],.75*x(3),.02];

		pos={
%		tag	position			description
%----------------------------------------------------------------------------
		'M'	[mrg,yoff+2*l4,1/3-2*mrg,1-(yoff+2*l4)-1*mrg-.02],...
			'modules'
		'F'	[xoff+l3,yoff+3*l4,xle2,ylen],...
			'calls  TO'
		'F'	[xoff+l3,yoff+2*l4,xle2,ylen],...
			'called FROM'
		'S'	[xoff+l3,yoff+1*l4,xle2,ylen],...
			'subfunctions'
		'S'	[xoff+l3,yoff+0*l4,xle2,ylen],...
			'nested / anonymous functions'
		'SM'	[mrg,yoff+1*l4,1/3-2*mrg,ylen],...
			'main function'
		'MT'	[mrg,yoff+0*l4,1/3-2*mrg,ylen],...
			'toolboxes'
		'T'	[xoff+l3,yoff+4*l4,xle2,ylen],...
			'module summary'
		};

		mpos={
%----------------------------------------------------------------------------
			[xpos(5),yoff+4*l4+ylen+.0025,dx1,.025],...
			'EDIT',...
			{@FDEP_cb_edit},...
			par.fcol
			[xpos(3),yoff+4*l4+ylen+.0025,dx1,.025],...
			'font -',...
			{@FDEP_cb_fs,-1},...
			par.pcol
			[xpos(4),yoff+4*l4+ylen+.0025,dx1,.025],...
			'font +',...
			{@FDEP_cb_fs,1},...
			par.pcol
		};

		v=num2cell(1:p.nfun).';
		tix=p.tix(:,2:5)~=0;
		des=repmat(p.par.dspec,size(tix,1),1);
		des(~tix)='.';
		des=cellstr(des);

		maxs=max(cellfun(@numel,p.module))+3;
		fmt=sprintf('%%%dd: %%-%ds %%s',fix(log10(p.nfun))+1,maxs);
		flst=cellfun(@(x,y,z) sprintf(fmt,x,y,z),v,p.module,des,'uni',false);
		flst{1}=[flst{1},'   [MAIN]'];

		np=size(pos,1);
		lh=zeros(np,1);
		th=zeros(np,1);
		uh=zeros(2,1);
	for	i=np:-1:1
			cp=pos{i,2};
		lh(i)=uicontrol(...
			'tag',pos{i,1},...
			'units','normalized',...
			'position',cp,...
			'style',LB,...
			'userdata',1);
		th(i)=uicontrol(...
			'tag',[pos{i,1},'text'],...
			'units','normalized',...
			'position',spos(cp),...
			'style','text',...
			'string',pos{i,3},...
			'horizontalalignment','left',...
			'fontname','courier new',...
			'fontsize',11,...
			'fontweight','bold',...
			'backgroundcolor',fcol);
	end
		set(lh,...
			'callback',{@FDEP_cb_list,p,par,lh,lh(end)},...
			'max',1,...
			'horizontalalignment','left',...
			'fontname','courier new',...
			'fontsize',fs,...
			'backgroundcolor',par.fcol,...
			'foregroundcolor',par.tcol);
		set(lh(1),'string',flst,...
			'backgroundcolor',par.mcol);
		set(lh(6),'string',par.mktxtf(p,par));
		set(lh(7),'string',p.toolbox,...
			'max',2);
		set(lh(6:7),...
			'backgroundcolor',par.pcol);
		set(lh(1:3),...
			'tooltipstring','*** click an ENTRY to show its content ***');
		set(lh(4:5),...
			'tooltipstring','*** click an ENTRY to open the module at the function ***');
		set(lh(6),...
			'tooltipstring','*** click anywhere to show the MAIN module ***');
		set(lh(8),...
			'tooltipstring','*** click the first LINE to show full module content ***');
		set(lh(7),...
			'hittest','off');

	for	i=1:size(mpos,1)
		uh(i)=uicontrol(...
			'callback',{mpos{i,3}{:},p,lh,LB},...
			'units','normalized',...
			'position',mpos{i,1},...
			'string',mpos{i,2},...
			'fontname','courier new',...
			'fontsize',11,...
			'fontweight','bold',...
			'backgroundcolor',mpos{i,4});	%#ok r2008b
	end

			uctrl={'quit','help','manager','matrix','tree'};
			FDEP_set_ctrl(p,fh,lh(8),uctrl,-17,12,2,1.5);

		set(fh,...
			'closerequestfcn',{@FDEP_manager,fh,p,'wd',false},...
			'deletefcn',{@FDEP_manager,fh,p,'wd',false},...
			'tag',ftag,...
			'userdata',lh,...
			'toolbar','none',...
			'menubar','none',...
			'numberTitle','off',...
			'name',['MODULE LIST:   ',...
				p.par.macro.sr(p.file)],...
			'color',fcol);

	if	numel(varargin)				&&...
		~isempty(varargin{1})
	if	ischar(varargin{1})
		p=FDEP_dfind(magic,p,false,varargin{1});
	if	~isempty(p.ix)
		n=p.ix;
	end
	else
		n=varargin{1};
	end
	end
		FDEP_manager(fh,'dlist','dlist',p,'w',false);
		FDEP_cb_list(lh(1),[],p,par,lh,lh(end),n);
		figure(fh);
		shg;

	if	~nargout
		clear p;
	else
		p.smod=@(ix) FDEP_cb_list(lh(1),[],p,par,lh,lh(end),ix);
	end
end
%-------------------------------------------------------------------------------
% CALLBACK functions
%	- dlist
%-------------------------------------------------------------------------------
function	FDEP_cb_map(h,e,p,lh,ix)		%#ok

		FDEP_dplot(p.magic,p);
end
%-------------------------------------------------------------------------------
function	FDEP_cb_edit(h,e,p,lh,ix)		%#ok

		v=get(lh(1),'userdata');
	try
		edit(p.fun{v});
	catch						%#ok
	end
end
%-------------------------------------------------------------------------------
function	FDEP_cb_sedit(h,e,p,par,ix,lh)		%#ok

		ud=get(h,'userdata');
	if	isempty(ud)
		return;
	end
		v=get(h,'value');
		opentoline(p.fun{ix},ud(v));
end
%-------------------------------------------------------------------------------
function	FDEP_cb_fs(h,e,mode,p,par,ix,lh)	%#ok

		lh=findall(gcf,'style',ix);
		cfs=get(lh(1),'fontsize');
		set(lh,'fontsize',cfs+mode);
end
%-------------------------------------------------------------------------------
function	FDEP_cb_help(h,e,p,lh,ix)		%#ok
		FDEP_manager([],'help',mfilename,p,'p',false);
end
%-------------------------------------------------------------------------------
function	FDEP_cb_list(h,e,p,par,lh,lht,v)	%#ok

	if	~all(ishandle([h;lh;lht]))
		disp(sprintf('%s> handles invalid',p.magic));
		return;
	end
	if	nargin < 7
		v=get(h,'value');
	elseif	v <= 0					||...
		v > p.nfun
		disp(sprintf('%s> index out of range: %-1d [1:%-1d]',...
			p.magic,v,p.nfun));
		return;
	end
		t=get(h,'tag');
	if	isempty(v)				||...
		numel(v) > 1
		return;
	end

		senum=p.par.enum.s;

	switch	t
	case	'M'
		set(h,'max',1);
	case	'F'
		s=cellstr(get(h,'string'));
	if	v <= 0 || v > numel(s)
		disp(sprintf('ERROR %5d',v));
		disp(s);
		return;
	end
		v=strmatch(s(v),p.fun,'exact');
	if	isempty(v);
		return;
	end
	case	'SM'
		v=1;
	case	'TB'
	case	'T'
		s=get(h,'string');
		m=get(lh(1),'value');
	if	v == 1
		p.ix=m;
		p.rs=s;
		FDEP_manager([],'synopsis',mfilename,p,'m',true,m,s);
	end
		return;
	case	'MT'
	if	v && v <= size(p.modbix,1)
		vx=p.modbix{v,end};
		set(lh(1),'max',2);
		set(lh(1),'value',vx);
	end
		return;
	otherwise
		return;
	end

		set([lh(4:5);lht],...
			'userdata',[],...
			'string','');
		set(lh(2:end),'value',1);
		set(lh(1),...
			'max',1,...
			'value',v);
		set(lht,'listboxtop',1);

		set(lh(2),'string',p.fun(p.mix{v}));
		set(lh(3),'string',p.fun(p.cix{v}));
	if	p.sub(v).n(senum.S)
		tmpt=cellfun(@(x,y) sprintf('S(%5d): %s',y,x),p.sub(v).S.fn,num2cell(p.sub(v).S.bx(1,:)).','uni',false);
		tmpt{1}(1)='M';
		set(lh(4),...
			'userdata',p.sub(v).S.bx(1,:).',...
			'string',tmpt);
	end
		txtn={''};
		ln=[];
	if	p.sub(v).n(senum.N)
		txtn=cellfun(@(x,y) sprintf('N(%5d): %s',y,x),p.sub(v).N.fd,num2cell(p.sub(v).N.bx(1,:)).','uni',false);
		ln=p.sub(v).N.bx(1,:).';
	end
	if	p.sub(v).n(senum.A)
		tmpt=cellfun(@(x,y) sprintf('A(%5d): %s',y,x),p.sub(v).A.fd,num2cell(p.sub(v).A.bx(1,:)).','uni',false);
		txtn=[txtn;tmpt];
		ln=[ln;p.sub(v).A.bx(1,:).'];
	end
	if	isempty(txtn{1})
		txtn=txtn(2:end);
	end
	if	numel(txtn)
		[ln,lnx]=sort(ln);
		set(lh(5),...
			'userdata',ln,...
			'string',txtn(lnx));
	end
		set(lh(4:5),...
			'callback',{@FDEP_cb_sedit,p,par,v,lh}');

		set(lh(7),'value',p.mlix{v,5});

		fdir=dir(p.fun{v});
		par.date=fdir.date;
		par.size=fdir.bytes;
		txt=par.mktxtm(p,par,v);
	for	i=1:size(p.par.mtag,1)
		txt=txt(~strcmp(txt,p.par.mtag{i}));
	end
		set(lht,'string',txt);
		set(lh(1),'userdata',v);
end
%-------------------------------------------------------------------------------
function	p=FDEP_dplot(magic,p,varargin)

	if	~FDEP_chkpar(magic,p)
			return;
	end
			ftag=p.par.tag{3}(p.module{1});

% one instance only
			fh=findall(0,'tag',ftag);
		if	~isempty(fh)
			figure(fh);
			FDEP_manager(fh,'plot','plot',p,'w',false);
			figure(fh);
			shg;
			return;
		end

% common parameters
			mrks=5;
			cbtag='CALLBACK';
			fs=9;					% font size
			fn='courier new';			% font name
			afs=8;
			afn='arial';

			cs=sum(abs(p.mat~=0),1);
			ms=sum(abs(p.mat~=0),2);

			xv=linspace(0,1,numel(p.caller)+2);
			yv=linspace(0,1,numel(p.module)+2);
			apos=[.25,.1,.65,.65];
			xoff=-.02;
			yoff=1.02;
			lh=nan(length(p.caller),length(p.module));

			fh=figure;
			set(fh,...
				'position',p.par.lwin,...
				'tag',ftag);
			shg;
			ah=axes;
			set(ah,...
				'position',apos,...
				'xlim',[0,1],...
				'ylim',[0,1],...
				'fontname',afn,...
				'fontsize',afs);

% CALLERS
	for	i=1:numel(p.caller)
			com=sprintf('edit(''%s'')',p.caller{i});
			th=text(xv(i+1),yoff,p.caller{i},...
				'units','normalized',...
				'rotation',90,...
				'verticalalignment','middle',...
				'fontsize',fs,'fontname',fn,...
				'interpreter','none',...
				'buttondownfcn',com,...
				'tag','f');
	if	i == 1
			set(th,'color',[1 0 0]);
	end
			set(th,'tag','c');
	for	j=1:numel(p.module)
			mcol=[0 0 1];
			ix=strcmp(p.caller{i},p.module{j});
	if	p.mat(j,i) > 0
			mrk='+';
			mrkc=[0 0 1];
	elseif	p.mat(j,i) < 0
			mrk='o';
			mrkc='none';
	elseif	ix
			mrk='diamond';
			mrkc=[0 0 1];
	else
			mrk='';
	end
	if	p.tix(j,4)
			mrkc=[1 0 0];
			mcol=mrkc;
	end
	if	mrk
			um=uicontextmenu(...
				'tag','f',...
				'callback',{@FDEP_cb_pos,p,i,j,cbtag,'m'},...
				'userdata',[]);
			lh(i,j)=line(i,j,...
				'tag','f',...
				'uicontextmenu',um,...
				'buttondownfcn',{@FDEP_cb_pos,p,i,j,cbtag,'m'},...
				'marker',mrk,...
				'markersize',mrks,...
				'markerfacecolor',mrkc,...
				'linestyle','none',...
				'color',mcol,...
				'userdata',[]);
	end
	end
	end

% MODULES
			yv=fliplr(yv);
	for	i=1:numel(p.module);
			tcol=[0 0 0];
			smod='     ';
			mod=p.module{i};
			ix=~any(strcmp(mod,p.caller));
	if	p.tix(i,3)
			smod(4)='E';
	end
	if	p.tix(i,4)
			smod(3)='S';
	end
			mod=sprintf('%s%s>',mod,smod);
	if	~ix
			mod(end)='+';
	end
			com=sprintf('edit(''%s'')',p.module{i});
			text(xoff,yv(i+1),mod,...
				'units','normalized',...
				'tag','m',...
				'buttondownfcn',com,...
				'horizontalalignment','right',...
				'fontsize',fs,'fontname',fn,...
				'interpreter','none',...
				'color',tcol,...
				'userdata',i);
	end
			set(ah,...
				'buttondownfcn',{@FDEP_cb_ax,cbtag,'f'},...
				'xlim',[0 length(p.caller)+1],...
				'xtick',1:length(p.caller),...
				'xticklabel',cs,...
				'ydir','reverse',...
				'ylim',[0 length(p.module)+1],...
				'ytick',1:length(p.module),...
				'yaxislocation','right',...
				'yticklabel',ms,...
				'color','none');
			box on;
			axis square;

			xt=sprintf('%-1d caller(s)\n[+: link',size(p.mat,2));
			xt=[xt '  \o: recursive'];
			xt=[xt '  \diamondsuit: caller=module]'];
			yt=sprintf('%-1d module(s)\n',size(p.mat,1));
			yt=[yt '[+: a caller  >: not a caller  S: a script (red)  E: calls f/eval..]'];
			xlabel(xt,'fontsize',afs+2);
			ylabel(yt,'fontsize',afs+2);

			set(fh,...
				'closerequestfcn',{@FDEP_manager,fh,p,'wd',false},...
				'deletefcn',{@FDEP_manager,fh,p,'wd',false},...				'toolbar','none',...
				'menubar','none',...
				'numberTitle','off',...
				'name',['DEPENDENCY MATRIX:   ',...
					p.par.macro.sr(p.file)],...
				'color',p.par.mcol);
			shg;

	if	nargin > 2
			pause(0);			% redraw!
	for	i=1:numel(varargin)
			d=varargin{i};
	if	numel(d) == 2				&&...
		isnumeric(d)				&&...
		ishandle(lh(d(1),d(2)))
			FDEP_cb_pos(lh(d(1),d(2)),[],p,d(1),d(2),cbtag,'m');
	end
	end
	end

		uh=uicontrol(...
			'units','normalized',...
			'position',[0,0,1,1],...
			'style','listbox');
		uctrl={'quit','help','manager','list','tree'};
		FDEP_set_ctrl(p,fh,uh,uctrl,-17,12,2,1.5,-100,[]);
		delete(uh);
		FDEP_manager(fh,'plot','plot',p,'w',false);
		figure(fh);

	if	~nargout
		clear p;
	end
end
%-------------------------------------------------------------------------------
% CALLBACK functions
%	- dplot
%-------------------------------------------------------------------------------
function	FDEP_cb_pos(h,e,p,xd,yd,tag1,tag2)	%#ok

		ud=get(h,'userdata');
	if	isempty(ud)
		th=findall(gca,'tag',tag2,'userdata',yd);
		txt=get(th,'string');
		is=find(isspace(txt));
		txt(is(1))=':';
		txt(is(2:end))='';
		fs=get(th,'fontsize');
		xlim=get(gca,'xlim');
		ylim=get(gca,'ylim');
		xh=line(xlim.',[yd;yd],[-10,-10],'tag',tag1);
		yh=line([xd;xd],ylim.',[-10,-10],'tag',tag1);
		set([xh,yh],'color',.9*[1,1,1]);
		txt=sprintf('%s\n%s',p.caller{xd},txt);
		th=text(xd+.01*p.par.macro.range(xlim),yd,10*ones(size(yd)),txt,...
			'tag',tag1,...
			'fontsize',fs+1,...
			'color',[1,0,0]);
		ud=[xh,yh,th];
	else
		delete(ud);
		ud=[];
	end
		set(h,'userdata',ud);
end
%-------------------------------------------------------------------------------
function	FDEP_cb_ax(h,e,tag1,tag2)		%#ok

		th=findall(h,'tag',tag1);
	if	isempty(th)
		return;
	end
		delete(th);
		th=findall(h,'tag',tag2);
		set(th,'userdata',[]);
end
%-------------------------------------------------------------------------------
function	s=FDEP_manager(hdl,evc,fnam,p,mode,dflg,varargin)	%#ok

% NOTE
% - dual role of manager
%	- callback		:	{@FDEP_manager,fnam,p,...}
%	- regular subfunction	:	s=FDEP_manager(hdl,evc,fnam,p,...)

	if	nargin < 6
		mode='p';		% help window		[def]
		dflg=false;		% create window		[def]
	end
		isman=false;		% calls manager windows
		hasfile=false;		% reads file
		hasctrl=false;		% wants controls

		fh=[];
		fs=9;
		fpos=p.par.hwin;

	switch	mode
% tree
%---------------------------------------
	case	'r'
		dflg=false;
		hasctrl=true;
		htag=p.par.tag{6}(p.module{1});
		s=varargin{2};
		c=double(~strcmp(s,varargin{3}));
		ix=find(c==0);
		c([1:3,ix])=[-300,-400,0,300].';
		s(ix)=s(2);
		s{1}=sprintf('%s     (*)=jump to section / click an entry to open its module synopsis',s{1});
		s{2}=sprintf('%s     (*)=jump to section / click an entry to open its module synopsis',s{2});
		ftit='FDEP RUNTME TREE';
		ucol=p.par.rcol;
		m=[];
		mx=[];
		ip=3;

% full module synopsis
%---------------------------------------
	case	'm'
		dflg=false;
		hasctrl=true;
		ucol=p.par.fcol;
		[s,c,m,mx,htag,ftit]=FDEP_get_module(p,varargin{:});
	if	isempty(ftit)
		return;
	end
		ip=find(c==0);

% listing panels' help
%---------------------------------------
	case	'p'
		htag=p.par.tag{1}(p.module{1});
		fh=findall(0,'tag',htag);
	if	~isempty(fh)
		figure(fh);
		uistack(fh,'top');
		shg;
		return;
	end
		hasfile=true;
		hasctrl=true;
		c=[-100,0];
		m=[];
		mx=[];
		ip=2;
		tb='%@LISTHELP_BEG';
		te='%@LISTHELP_END';
		ftit='FDEP HELP';
% FDEP windows manager
%---------------------------------------
	case	{'w','wd'}
		isman=true;
	if	p.par.opt.dflg

		disp(sprintf('MANAGER call  : %s',mode));
	if	ishandle(hdl)
		disp(sprintf('- hdl = %7d %s',hdl,get(hdl,'tag')));
	end
	end
		
% - caller:	fdep windows manager
		htag=p.par.tag{5}(p.module{1});
		fh=findall(0,'tag',htag);

% - caller:	callback closing
%		no manager
	if	strcmp(mode,'wd')			&&...
		ishandle(hdl)
		set(hdl,...
			'closerequestfcn','',...
			'deletefcn','');
		delete(hdl);
	if	isempty(fh)
		return;
	end
	end

% - caller:	callback create
%		has manager
		mh=findall(0,'type','figure');
		s=get(mh,'tag');
	if	~iscell(s)
		s={s};
	end
		s=s(strncmp(p.par.tagpid,s,numel(p.par.tagpid)));
		is=strcmp(htag,s);
	if	any(is)
		s(is)=[];
	end
		s=sort(s);
		s=strrep(s,p.par.tagpid,'');

	if	isempty(s)				&&...
		~isempty(is)				&&...
		ishandle(mh(is))
	if	p.par.opt.dflg
		disp(sprintf('MANAGER delete: empty manager'));
	end
		set(mh(is),...
			'closerequestfcn','',...
			'deletefcn','');
		delete(mh(is));
		return;
	elseif	isempty(is)
		return;
	end
%   start manager only if at least two windows are open
	if	numel(s) == 1				&&...
		isempty(fh)
		return;
	end

		fpos=[fpos(1),fpos(2)+.75*fpos(4),.5*fpos(3),.25*fpos(4)];
		ucol=p.par.pcol;
		fs=10;
		c=-200;
		m=[];
		mx=[];
		ip=1;
		ftit=sprintf('FDEP %s (%s)',p.module{1},p.([p.magic,'ver']));

% - invalid ID
	otherwise
		disp(sprintf('FDEP> invalid HELP id'));
		return;
	end

% read help section
%---------------------------------------
	if	hasfile
		ucol=p.par.pcol;
		s=p.par.farg.par.fh([fnam,'.m'],1);	% TEXTREAD replacement
		ib=find(strcmp(tb,s));
		ie=find(strcmp(te,s));
		s=detab(s(ib+1:ie-1));
	end

% create controls
%---------------------------------------
	if	~dflg
	if	isempty(fh)
		fh=figure(...
			'toolbar','none',...
			'tag',htag,...
			'position',fpos,...
			'numbertitle','off',...
			'menu','none',...
			'name',ftit);
	elseif	ishandle(fh)
		figure(fh);
		ch=findall(fh,'type','uicontrol');
		delete(ch);
	else
		return;
	end
		uh=uicontrol(...
			'units','normalized',...
			'position',[0,0,1,1],...
			'style','listbox',...
			'horizontalalignment','left',...
			'max',2,...
			'value',ip,...
			'string',s,...
			'fontname','courier new',...
			'fontsize',fs,...
			'backgroundcolor',ucol,...
			'foregroundcolor',p.par.tcol,...
			'callback',{@FDEP_cb_mlist,p,mx,m,s,c});
		pause(.05);
		set(uh,...
			'listboxtop',1);

	if	hasctrl
			FDEP_set_ctrl(p,fh,uh,[],-17,12,2,1.5,c,mx);
	end

		set(fh,...
			'closerequestfcn',{@FDEP_manager,fh,p,'wd',false},...
			'deletefcn',{@FDEP_manager,fh,p,'wd',false});

	if	~isman
	if	p.par.opt.dflg
		disp(sprintf('MANAGER load  : %s',get(fh,'tag')));
	end
		FDEP_manager(fh,'manager','manager',p,'w',false);
		figure(fh);
	elseif	isman					&&...
		ishandle(hdl)				&&...
		strcmp('figure',get(hdl,'type'))	% KEEP THIS!
		figure(hdl);
	else
		figure(fh);
	end

	else
		disp(char(s));
	end
	if	~nargout
		clear s;
	end
end
%-------------------------------------------------------------------------------
function	FDEP_mlist(magic,p,varargin)

	if	nargin < 3
		return;
	end

	for	i=1:numel(varargin)
	if	~iscell(varargin{i})
		carg=varargin(i);
	else
		carg=varargin{i};
	end

	for	j=1:numel(carg)
		arg=carg{j};
		argc=class(arg);
	switch	argc
	case	'char'
		p=FDEP_dfind(magic,p,false,arg);
		FDEP_manager([],[],[],p,'m',true,p.ix,p.ry);
	case	'struct'
	for	k=1:numel(arg)
		FDEP_manager([],[],[],p,'m',true,arg(k).index,arg(k).synopsis);
	end
	otherwise
	if	isnumeric(arg)
	for	k=1:numel(arg)
		p=FDEP_dfind(magic,p,false,arg(k));
		FDEP_manager([],[],[],p,'m',true,p.ix,p.ry);
	end
	else
		disp(sprintf('FDEP> invalid MHELP class [%s]',argc));
	end
	end
	end
	end
end
%-------------------------------------------------------------------------------
function	FDEP_rtree(magic,p,varargin)		%#ok

		htag=p.par.tag{6}(p.module{1});
		fh=findall(0,'tag',htag);
	if	~isempty(fh)
		figure(fh);
		uistack(fh,'top');
		shg;
	else
		ctag='@@@CALLER@@@';
		s=[
		{
			'RUNTIME    TREE'
			'MODULES    TREE'
			''
		}
			cellstr(p.rtree)
			{ctag}
			p.tree
		];
		FDEP_manager([],[],[],p,'r',true,1,s,ctag);
	end
end
%-------------------------------------------------------------------------------
function	[s,c,m,mx,htag,ftit]=FDEP_get_module(p,varargin)

% retrieve callback association from latest synopsis output
%
%	s=p.get(1);
%	n=num2cell(-1:-1:-size(s.synopsis,1)).';
%	c=cellfun(@(a,b) sprintf('%5d %s',a,b),n,s.synopsis,'uni',false)	

		TT=repmat(sprintf('\t'),1,2);
		COM='(click entry to open module)';
		COF='(click entry to open MODULE at call)';
		JTS=[TT,'(*)'];
		nof=2;

	mlst={
%		fieldname	descriptor	callback-ix	help
%		----------------------------------------------------
		'subfunction'	'MAIN function / subfunctions',...
			101	-14-nof,...
			COF	JTS
		'nested'	'nested functions',...
			102	-15-nof,...
			COF	JTS
		'anonymous'	'anonymous functions',...
			103	-16-nof,...
			COF	JTS
		'unresolved'	'unresolved functions',...
			104	-18-nof,...
			COF	JTS
		'callsTO'	'calls  TO   modules',...
			105	-11-nof,...
			COM	[JTS,'=jump to section']
		'callsFROM'	'called FROM modules',...
			105	-12-nof,...
			COM	JTS
		'MLtoolbox'	'ML toolboxes',...
			100	-23-nof,...
			''	JTS
		'MLfunction'	'ML stock functions',...
			105	-19-nof,...
			COM	JTS
		'MLbuiltin'	'ML built-in functions',...
			100	-20-nof,...
			''	JTS
		'MLclass'	'ML classes',...
			105	-21-nof,...
			COM	JTS
		'OTHERclass'	'OTHER classes',...
			100	-22-nof,...
			''	JTS
		'calls'		'calls in FILE',...
			110	-13-nof,...
			COF	JTS
	};

		c=[];
		m=[];
		mx=[];
		htag=[];
		ftit=[];

		s=varargin{2};
	for	i=1:size(p.par.mtag,1)
		s=s(~strcmp(s,p.par.mtag{i}));
	end
		d=FDEP_dget(p.magic,p,p);
	if	isempty(d)
		return;
	end

		m=d.file;
		mx=d.index;
		htag=p.par.tag{4}(d.module);
		otag=findall(0,'tag',htag);
	if	~isempty(otag)
		figure(otag);
		return;
	end

		nlst=size(mlst,1);
		nmax=max(cellfun(@numel,mlst(:,2)));
		fmt=sprintf('----- %%-%d.%ds: %%d\\t\\t%%s',nmax,nmax);

		ss=size(s,1);
		s{end+1}='-';
		ch=-14*nan(size(s));
		ch(-[mlst{:,4}])=[mlst{:,4}];
		c=num2cell(ch);

	for	i=1:nlst
		s{-mlst{i,4}}=sprintf('%s%s',s{-mlst{i,4}},mlst{i,6});
		ts=d.(mlst{i,1});
		ts=ts(~cellfun(@isempty,ts));
		ns=numel(ts);
	if	ns
		s{end+1}=sprintf(fmt,mlst{i,2},ns,mlst{i,5});	%#ok
	else
		s{end+1}=sprintf(fmt,mlst{i,2},ns,'');		%#ok
	end
		c(end+1)=mlst(i,4);				%#ok

	if	ns
		tn=num2cell(1:ns).';
	if	i < nlst
		s(end+1:end+ns)=cellfun(@(a,b) sprintf('%4d:          %s',a,b),tn,ts,'uni',false);
		c(end+1:end+ns)=mlst(i,3);
	else
		s(end+1:end+ns)=cellfun(@(a,b) sprintf('%4d: %s',a,b),tn(:),ts(:),'uni',false);
		c(end+1:end+ns)=mlst(i,3);
	end
	end
		s(end+1)={''};					%#ok
		c(end+1)={nan};					%#ok
	end

		c=[c{:}].';
		c(1:numel(ch))=ch;
		c(ss+1)=0;

		n=max(cellfun(@numel,s(1:ss)));
		s{ss+1}=repmat('-',1,n);
		s=detab(s);

		ftit=sprintf('MODULE SYNOPSIS:   %s   >   %s',p.module{1},d.module);
end
%-------------------------------------------------------------------------------
function	FDEP_set_ctrl(p,fh,uh,ix,xoff,xlen,yoff,ylen,varargin)

	uc={
%		descriptor	callback	color		tip
%		----------------------------------------------------------
		'quit'		'quit'		p.par.pcol	'quit this window'
		'font -'	'fontm'		p.par.pcol	'make fontsize smaller'
		'font +'	'fontp'		p.par.pcol	'make fontsize bigger'
		'help'		'help'		p.par.pcol	'show the help window'
		'manager'	'manager'	p.par.pcol	'show the window manager'
		'list'		'list'		p.par.pcol	'show the module list'
		'matrix'	'matrix'	p.par.pcol	'show the dependency matrix'
		'tree'		'tree'		p.par.pcol	'show the runtime tree'
		'home'		'home'		p.par.pcol	'go to start of synopsis'
	};

	if	isempty(ix)
		ix=1:size(uc,1);
	elseif	iscell(ix)
		[ix,ix]=ismember(ix,uc(:,1));		%#ok
	end
		uc=uc(ix,:);

		set(uh,'units','characters');
		pos=get(uh,'position');
		set(uh,'units','normalized');
	for	i=1:size(uc,1)
		npos=[pos(1)+pos(3)+xoff,pos(2)+pos(4)-i*ylen-yoff,xlen,ylen];
		uicontrol(...
			'units','characters',...
			'position',npos,...
			'string',uc{i,1},...
			'tooltipstring',uc{i,4},...
			'callback',{@FDEP_cb_mbutton,p,uc{i,2},fh,uh,varargin{:}},...
			'backgroundcolor',.99*uc{i,3});	%#ok r2008b
	end
end
%-------------------------------------------------------------------------------
% CALLBACK functions
%	- mhelp
%-------------------------------------------------------------------------------
function	FDEP_cb_mlist(h,e,p,mx,m,s,c)		%#ok

		v=get(h,'value');
	if	numel(v) > 1
		return;
	end

% help window
	if	c(1) == -100
		return;
	end

% tree window
	if	c(1) == -300
	if	v == 2
		v=find(c==300);
		set(h,'listboxtop',v);
	elseif	v == 1
		v=4;
		set(h,'value',v);
	else
		ix=strfind(s{v},'|');
	if	~isempty(ix)
		m=regexp(s{v}(ix+1:end),'(?<=|)\w+(?=\s*)','match','once');
	end
		p.mhelp(m);
	end
		return;
	end

% manager window
	if	c(1) == -200
		v=get(h,'value');
	if	~isempty(v)
		cs=get(h,'string');
	if	~isempty(cs)
		cs=[p.par.tagpid,cs{v}];
		fh=findall(0,'tag',cs);
		set(h,'value',v);
	if	~isempty(fh)				&&...
		numel(fh) == 1				&&...
		ishandle(fh)				% KEEP THIS!
		figure(fh);
	end
	elseif	ishandle(h)
		delete(h);
	end
	elseif	ishandle(h)
		delete(h);
	end
		return;
	end

% mhelp windows
		cn=c(v);
	if	cn == 0
		return;
	end
	if	isnan(cn)
		return;					% -1: home
	elseif	cn > 100
		cn=c(v)-100;
	elseif	v <= -min(c)
		ix=find(c==cn,1,'last');
		set(h,'value',ix);
		pause(.05);
		set(h,'listboxtop',ix);
		return
	end
		cs=s{v};

	switch	cn
	case	{1,2,3,4}
		ml={'S','N','A','E'};
		[r,nr,er]=sscanf(cs,'%d:%s',[1,2]);	%#ok
	if	er
		return;
	end
		opentoline(m,p.sub(mx).(ml{cn}).bx(1,r(1)));
	case	5
		[r,nr,er]=sscanf(cs,'%d:%s',[1,2]);	%#ok
	if	er
		return;
	end
		f=char(r(2:end));
	if	exist(f,'file')
		opentoline(f,1);
	end
	case	10
		[r,nr,er]=sscanf(cs,'%d:%d%s',[1,3]);	%#ok
	if	er
		return;
	end
		opentoline(m,r(2));
	case	501
		p.list();
	case	502
		p.list();
	case	503
		p.list();
	case	-1
		set(h,'value',find(c==0));
		pause(.05);
		set(h,'listboxtop',1);
	otherwise
	end
end
%-------------------------------------------------------------------------------
function	FDEP_cb_mbutton(h,e,p,cb,fh,uh,c,mx)	%#ok

	switch	cb
	case	'help'
		p.help();
		return;
	case	'list'
		p.list(mx);
		return;
	case	'matrix'
		p.mplot();
		return;
	case	'tree'
		p.tplot();
		return;
	case	'home'
		set(uh,'value',find(c==0));
		pause(.05);
		set(uh,'listboxtop',1);
		return;
	case	'quit'
		delete(fh);
	case	'manager'
		mh=findall(0,'tag',p.par.tag{5}(p.module{1}));
	if	~isempty(mh)
		figure(mh);
		return;
	end
	case	'fontm'
		cfs=get(uh,'fontsize');
		set(uh,'fontsize',cfs-1);
		return;
	case	'fontp'
		cfs=get(uh,'fontsize');
		set(uh,'fontsize',cfs+1);
		return;
	otherwise
	end
		FDEP_manager(fh,'button','button',p,'w',false);
end
%-------------------------------------------------------------------------------
%-------------------------------------------------------------------------------
%-------------------------------------------------------------------------------
%
% FARG		a FEX file
% created:
%	us	02-Jan-2005
%
% download the latest standalone including help/comments from
% http://www.mathworks.com/matlabcentral/fileexchange/15924
%
%-------------------------------------------------------------------------------
%-------------------------------------------------------------------------------
%-------------------------------------------------------------------------------
%$SSC_INSERT_BEG   21-Jun-2010/02:16:53   F:/usr/matlab/tmp/fex/afarg/ver2010/farg.m
%-------------------------------------------------------------------------------
% SSC automatic file insertion utility
%     - us@neurol.unizh.ch [ver 26-Apr-2010/00:48:30]
%     - all empty spaces and comments are stripped for brevity
%     - original code available upon request
%-------------------------------------------------------------------------------
function	[p,pp]=farg(varargin)
		magic='FARG';
		fver='21-Jun-2010 02:16:38';
	if	~nargin
	if	nargout
		[p,pp]=FARG_ini_par(magic,fver,mfilename,'-d');
	else
		help(mfilename);
	end
		return;
	end
		[p,par]=FARG_ini_par(magic,fver,varargin{:});
	if	~par.flg
		[p,par]=FARG_set_text(p,par,1);
		[p,par]=FARG_get_file(p,par);
	if	~par.flg
		[p,par]=FARG_get_calls(p,par);
	if	~par.flg
		[p,par]=FARG_get_entries(p,par);
	end
	end
		[p,par]=FARG_set_text(p,par,2);
	end
	if	nargout
		pp=p;
		pp.hdr=par.hdr;
		pp.res=par.res;
	if	~par.opt.dflg				&&...
		isfield(pp,'par')
		pp=rmfield(pp,'par');
	else
		pp.par=par;
	end
		p=par.res;
	else
		clear p;
	end
end
function	[p,par]=FARG_ini_par(magic,fver,varargin)
		narg=nargin-2;
		F=false;
		T=true;
		p.magic=magic;
		p.([magic,'ver'])=fver;
		p.MLver=version;
		p.rundate=datestr(now);
		p.fnam='';
		p.pnam='';
		p.wnam='';
		p.dnam='';
		p.ftyp='';
		p.mp=[true,true,false];			% M P O
		p.hdr='';
		p.res='';
		p.def={};
		p.sub={};
		p.ixm=[];
		par=p;
		par.txt={};
		par.opt=[];
		par.fh=@FARG_read;
		par.mopt={
			'-m3'
			'-calls'
		};
		par.lopt={
			'-m3'
			'-lex'
		};
		par.opt.dflg=false;
		par.opt.eflg=false;
		par.opt.hflg=false;
		par.opt.line=true;
		par.opt.sflg=true;
		par.opt.Sflg=false;			% hidden option
		par.opt.wflg=false;
	if	narg > 1
	for	i=1:narg
	switch	varargin{i}
	case	'-d'
		par.opt.dflg=true;
	case	'-e'
		par.opt.eflg=true;
	case	'-h'
		par.opt.hflg=true;
	case	'-l'
		par.opt.line=false;
	case	'-s'
		par.opt.sflg=false;
	case	'-S'
		par.opt.Sflg=true;
		par.opt.dflg=true;
	case	'-w'
		par.opt.wflg=true;
	end
	end
	end
		par.fmtnoop='%10d';
		par.fmtopen='<a href="matlab:opentoline(''%s'',%d)">NUMDIG</a>';
		par.fmtopen=strrep(par.fmtopen,'NUMDIG',par.fmtnoop);
		par.fmtmark=sprintf('__&&@@%s@@&&__',par.rundate);	% unique marker
		par.fmtcmp='%1d';
		par.rexlex='(?<=(:.+:\s+)).+$';
		par.rexmod='(\w+$)|(\d+$)';
		par.lexerr='<LEX_ERR>';
		par.rexcmp='(?<='').*(?='')|(?<=(\s))\d+(?=(\.)$)';
		par.rexcyc='The McCabe complexity of';
		par.rexeva='(^feval$)|(^evalc$)|(^evalin$)|(^eval$)';
		par.rexfh=@(x) regexp(x,par.rexmod,'match');
		par.ftok={
			'+'	' '		% M: main function
			'-'	' '		% S: subroutine
			'.'	'    '		% N: nested
			'@'	'       '	% A: anonymous
			'?'	'          '	% X: unresolved
			' '	'          '	% U: ML stock functions
			'!'	'       '	% E: eval
			'+'	' '		% R: recursion
			
		};
		par.lexstp={			% @ stop conditions
			'<EOL>'
			''';'''
			''','''
		};
		par.lexbrb={			% @ REVERSE search!
			'''('''
			'''{'''
			'''['''
		};
		par.lexbre={			% @ REVERSE search!
			''')'''
			'''}'''
			''']'''
		};
		par.lent={			% function delimiters
			'FUNCTION'	2
			'<EOL>'		2
		};
		par.scom=...
			@(x) textscan(x,'%d/%d(%d):%[^:]:%s');
		par.mext='.m';
		par.pext={
			'.miss'		0	F
			'.var'		1	F
			'.m'		2	T
			'.mex'		3	T
			'.mdl'		4	T
			'.builtin'	5	T
			'.p'		6	T
			'.folder'	7	F
			'.java'		8	F
		};
		par.mlroot=[matlabroot,filesep,'toolbox'];
		par.ftyp={'SCRIPT','FUNCTION','CLASS'};
		par.stmpl={
			'M'	1	3	true	par.rexfh
			'S'	2	3	false	par.rexfh
			'N'	3	3	true	par.rexfh
			'A'	4	[1,4]	true	par.rexfh
			'X'	5	0	false	''
			'U'	6	3	false	par.rexfh
			'E'	7	0	false	''
			'R'	8	0	false	''
			'O'	9	0	false	''
			'UU'	16	0	false	''
		};
		par.stmplf={
			'fn'	{}	1
			'fd'	{}	1
			'nx'	0	0
			'bx'	[]	2
			'ex'	[]	2
			'lx'	[]	0
			'dd'	[]	1
		};
		par.stmpla.n=zeros(1,size(par.stmpl,1));
		par.senum=par.stmpl(:,1:2).';
		par.senum=struct(par.senum{:});
		par.flg=true;
		par.fver=fver;
		par.rt=0;
		par.shdr=3;
		par.ooff=10-3;				% memo: opentoline offset - n*%+1
		par.crlf=sprintf('\n');
		par.wspace=[' ',sprintf('\t')];
		par.bol='%';
		par.deflin='';
		p.des=par.stmpl(:,1).';
		p.n=par.stmpla.n;
	for	i=1:size(par.stmpl,1)
		fn=par.stmpl{i,1};
	for	j=1:size(par.stmplf,1)
		fm=par.stmplf{j,1};
		par.stmpla.(fn).(fm)=par.stmplf{j,2};
	end
		p.(fn)=par.stmpla.(fn);
	end
		flg=false;
		par.fnam=varargin{1};
		ftype=exist(par.fnam,'file');
		[fpat,frot,fext]=fileparts(par.fnam);	%#ok
	if	isempty(fext)				||...
		ftype ~= par.pext{3,2}
		par.fnam=[frot,par.mext];
	end
	if	ftype ~= par.pext{3,2}
		par.pnam=varargin{1};
	end
		par.pnam=which(par.pnam);
	if	isempty(par.pnam)
		par.mp(2)=false;
	end
		par.wnam=which(par.fnam);
		wtype=exist(par.wnam,'file');
	if	isempty(par.wnam)			||...
		wtype ~= par.pext{3,2}
		flg=true;
		par.mp(1)=false;
	if	par.opt.sflg
		disp(sprintf('%s> ERROR   M-file not found',p.magic));
		disp(sprintf('-----------   %s',varargin{1}));
	end
	end
		par.dnam=dir(par.wnam);
	if	~flg
		par.dnam.ds=strread(par.dnam.date,'%s','whitespace',' ');
	end
	if	par.mp(2)				&&...
		~par.pext{ftype+1,3}
		par.mp=[false,false];
	end
		p.fnam=par.fnam;
		p.pnam=par.pnam;
		p.wnam=par.wnam;
		p.dnam=par.dnam;
		p.mp=par.mp;
		par.nlen=0;
		par.nlex=0;
		par.nfun=0;
		par.mfun=0;
		par.ncom=0;
		par.nemp=0;
		par.file={};
		par.call={};
		par.mlex={};
		par.comt={};
		par.lex={};
		par.ltok={};
		par.lint={};
		par.flg=flg;
		p.par=par;
		p.s=[];
end
function	[s,nl]=FARG_read(fnam,mode)
		s='';
	if	mode <= 1
		fp=fopen(fnam,'rt');
	if	fp > 0
		s=fread(fp,inf,'*char').';
		fclose(fp);
	end
		ie=[strfind(s,sprintf('\n')),numel(s)+1];
		nl=numel(ie);
	end
	if	mode >= 1
	if	mode == 2
		s=fnam;
	end
		s=strread(s,'%s','delimiter','','whitespace','');
		nl=size(s,1);
	end
end
function	[p,par]=FARG_get_file(p,par)
		[par.file,par.nlen]=par.fh(par.wnam,0);
		par.call=mlintmex(par.wnam,par.mopt{:});
		par.call=par.fh(par.call,2);
		par.lex=mlintmex(par.wnam,par.lopt{:});
		par.mlex=par.fh(par.lex,2);
		ix=	~cellfun(@isempty,strfind(par.mlex,'%:'))	|...
			~cellfun(@isempty,strfind(par.mlex,'%{:'))	|...
			~cellfun(@isempty,strfind(par.mlex,'%}:'));
		par.comt=par.mlex(ix);
		par.ncom=sum(ix);
		ix=ismember(par.lex,par.wspace);
		par.lex(ix)='';
		par.lex=par.scom(par.lex);
		par.ltok=[par.lex{:,4},par.lex{:,5}];
		par.lex=cat(2,par.lex{1:3});
		par.nlex=size(par.ltok,1);
		par.nemp=sum(accumarray(par.lex(:,1),par.lex(:,3))==1);
		par=FARG_chk_lint(par);
end
function	par=FARG_chk_lint(par)
		par.lint.ferr=false;
		par.lint.nerr=0;
		par.lint.err={};
		par.lint.serr=[];
		par.lint.mcyc=nan;
		par.lint.ncyc=[];
		par.lint.cyc={};
		err=mlint(par.wnam,'-all');
	if	~isempty(err)
	if	~par.opt.line
		fmt=par.fmtnoop;
		fnc=@(x,y,z) sprintf(['%s %5d>',fmt,': %s'],...
				par.bol,x(1),y(1),z(1,:));
	else
		fmt=par.fmtopen;
		fnc=@(x,y,z) sprintf(['%s %5d>',fmt,': %s'],...
				par.bol,x(1),par.wnam,y(1),y(1),z(1,:));
	end
		par.lint.nerr=numel(err);
		par.lint.serr=err;
		par.lint.err=cellfun(@(x,y,z) fnc(x,y,z),...
			num2cell(1:numel(err)),...
			{err.line},...
			{err.message},...
			'uni',false).';
	end
		cyc=mlint(par.wnam,'-cyc');
		cyc={cyc.message}.';
		ix=strncmp(cyc,par.rexcyc,numel(par.rexcyc));
	if	any(ix)
		cyc=regexp(cyc(ix),par.rexcmp,'match');
		cyc=[cyc{:}]';
		par.lint.cyc=reshape(cyc.',2,[])';
		par.lint.ncyc=cellfun(@(x) sscanf(x,'%d'),par.lint.cyc(:,2));
		par.lint.mcyc=max(par.lint.ncyc);
		ncmp=max([1,ceil(log10(par.lint.mcyc))]);
		par.fmtcmp=sprintf('%%%ds',ncmp);
	end
		lerr=sum(strcmp(par.ltok,par.lexerr),2);
	if	any(lerr)
		par.file=par.fh(par.file,2);
		par.lint.ferr=true;
		par.flg=true;
		par.opt.sflg=true;
		ix=find(lerr);
		nx=numel(ix);
		par.txt=[
			par.txt
			'DONE'
			{
			sprintf('%s LEX errors%6d',par.bol,nx)
			'LINE'
			}
		];
	for	i=1:nx
			nl=par.lex(ix(i),:);
	if	par.opt.line
			el=sprintf(par.fmtopen,par.wnam,nl(1),nl(1));
	else
			el=sprintf(par.fmtnoop,nl(1));
	end
			nl(2)=min([nl(2),numel(par.file{nl(1)})]);
			to=par.file{nl(1)}(nl(2));
		par.txt=[
			par.txt
			{
			sprintf('%s line  %s:   %-1d = <%s>\n',par.bol,el,nl(2),to)
			}
			par.lint.err
		];
	end
		par.txt(4,1)={
			sprintf('%s %s\n',par.bol,repmat('-',1,size(char(par.txt(1:3)),2)-3))
		};
	end
end
function	[p,par]=FARG_get_calls(p,par)
		[p,par]=FARG_get_class(p,par,1);
		ic=find(~cellfun(@isempty,par.stmpl(:,end))).';
	for	i=ic
		fn=par.stmpl{i,1};
		v.(fn)=[];				%#ok
		ix=~cellfun('isempty',regexp(par.call,['^',fn],'match'));
	if	any(ix)
		vtmp=par.stmpl{i,5}(par.call(ix));
		bx=cellfun(@(x) sscanf(x,'%*2s %d %d %*s'),par.call(ix),'uni',false);
		ex=bx;
	if	par.stmpl{i,4}
		ex=cellfun(@(x) sscanf(x,'%*2s %d %d %*s'),par.call(find(ix)+1),'uni',false);
	end
		p.n(i)=sum(ix);
		p.(fn).fn=[vtmp{:}].';
		p.(fn).nx=p.n(i);
		p.(fn).bx=[bx{:}];
		p.(fn).ex=[ex{:}];
		p.(fn).lx=cellfun(@numel,p.(fn).fn);
	end
	end
		p.UU=p.U;
		par.nfun=sum(p.n(1:3));			% M S N [A X U E R]
		par.mfun=par.nfun;			% M S N
	if	par.mp(3)				&&...
		p.M.nx > 1
		par.lint.ferr=true;
		par.flg=true;
		par.opt.sflg=true;
		par.txt=[
			par.txt
			'DONE'
			{
			sprintf('%s FATAL ERROR',par.bol)
			'LINE'
			}
			par.lint.err
		];
		par.txt(4,1)={
			sprintf('%s %s\n',par.bol,repmat('-',1,size(char(par.txt(1:3)),2)-3))
		};
	end
end
function	[p,par]=FARG_get_class(p,par,mode)
	switch	mode
	case	1
		ich=find(strncmp('CLASSDEF',par.ltok(:,1),numel('CLASSDEF')));
		ic=ich;
	if	strcmp(par.ltok(ic+1,1),'''(''')
		ic=ic+1;
	while	ic < par.nlex
		ic=ic+1;
	if	strcmp(par.ltok(ic,1),''')''')
		break;
	end
	end
	end
	if	any(ich)
		par.ltok(ich,:)=strrep(par.ltok(ich,:),'CLASSDEF','FUNCTION');
		par.call=[
			{
			sprintf('M%-1d %-1d %-1d %s',0,par.lex(ic+1,1:2),par.ltok{ic+1,2})
			sprintf('E%-1d %-1d %-1d %s',0,par.lex(ic+1,1:2),par.ltok{ic+1,2})
			}
			par.call
		];
		par.mp(3)=1;
		return;
	end
	case	2
	if	par.mp(3)
		fn=cell(par.nfun,1);
	for	i=1:3
		ix=p.ixm(:,2)==i;
	switch	i
	case	1
		fn(ix)=p.M.fn;
	case	2
		fn(ix)=p.S.fn;
	case	3
		fn(ix)=p.N.fn;
	end
	end
	if	~isempty(par.lint.cyc)
		cyc=par.lint.cyc(:,2);
	else
		cyc={};
	end
		tcyc=[
			repmat({'c'},par.nfun-numel(par.lint.ncyc),1)
			cyc
		];
		ncyc=[
			repmat(-1,par.nfun-numel(par.lint.ncyc),1)
			par.lint.ncyc
		];
		par.lint.cyc=[fn,tcyc];
		par.lint.ncyc=ncyc;
		par.lint.mcyc=max(abs(par.lint.ncyc));
		ncmp=max([2,ceil(log10(par.lint.mcyc))]);
		par.fmtcmp=sprintf('%%%ds',ncmp);
	end
	end
end
function	[p,par]=FARG_get_entries(p,par)
		ixt=false(par.nlex,2);
	for	i=1:size(par.lent,1)
		ctok=par.lent{i,1};
		nmatch=par.lent{i,2};
		ixt(:,i)=sum(strcmp(ctok,par.ltok),2)==nmatch;
	end
		lix=strcmp(par.ltok(:,1),'%');
		ltmp=par.ltok(lix,2);
		par.ltok(lix,2)={''};
		ixb=[];
		sr={};
	if	par.nfun
		p.ixm=zeros(par.nfun,3);
		ixb=zeros(par.nfun,1);
		ixe=zeros(par.nfun,1);
		ixc=zeros(par.nfun,1);
		ixl=zeros(par.nfun,1);
		sr=cell(size(p.ixm,1),1);
	if	p.N.nx
		nix=p.N.bx(1,:);
		nex=p.N.ex(1,:);
	end
	if	par.mfun
		ixb(1:par.mfun,1)=find(ixt(:,1)==1);
	for	i=1:par.mfun
		ixl(i)=find(ixt(ixb(i)+1:end,2)==1,1,'first');
		sr{i}=par.ltok(ixb(i):ixb(i)+ixl(i),2);
		sr{i}=regexprep(sr{i},'^''','');
		sr{i}=regexprep(sr{i},'''$','');
		ixe(i)=par.lex(ixb(i)+ixl(i),1);
		ixb(i)=par.lex(ixb(i),1);
		ixc(i)=par.lex(ixb(i),2);
		sr{i}=sprintf('%s',sr{i}{2:end-1});
		p.ixm(i,:)=[ixb(i),min([i,2]),ixc(i)];
	if	p.N.nx					&&...
		numel(nex)
	if	any(ixe(i)<=nex(1))			&&...
		any(ixe(i)>=nix(1))
		p.ixm(i,2)=3;
		nex(1)=[];
		nix(1)=[];
	end
	end
	end
	end
		ixb=p.ixm(:,1);
	end
		[p,par]=FARG_get_class(p,par,2);
		[p,par]=FARG_chk_entries(p,par);
	if	p.A.nx
		p=FARG_get_context(p,par,'A',false);
		ss=FARG_set_context(p,par,'A');
		p.A.fn=ss;
		p.A.fd=ss;
		[p,par,sr,ixb]=FARG_add_entries(p,par,sr,'A',ixb);
	end
		[p,par,sr,ixb]=FARG_add_entries(p,par,sr,'X',ixb);
	if	p.R.nx
		p=FARG_get_context(p,par,'R',true);
		ss=FARG_set_context(p,par,'R');
		p.R.fd=ss;
		[p,par,sr,ixb]=FARG_add_entries(p,par,sr,'R',ixb);
	end
	if	p.E.nx					&&...
		par.opt.eflg
		p=FARG_get_context(p,par,'E',true);
		ss=FARG_set_context(p,par,'E');
		p.E.fd=ss;
		[p,par,sr,ixb]=FARG_add_entries(p,par,sr,'E',ixb);
	end
	for	i=1:size(par.stmpl,1)
		cf=par.stmpl{i,1};
		cx=par.stmpl{i,2};
	if	par.nfun
		ix=p.ixm(:,2)==cx;
	if	any(ix)
		p.(cf).fd(1:sum(ix),1)=sr(ix);
	end
		p.n(i)=p.(cf).nx;
	end
	end
		p.ftyp=par.ftyp{sign(par.mfun)+1};
		p.s=@(varargin) FARG_show_entries(p,varargin{:});
	if	par.opt.Sflg
		return;
	end
		[p,par,s]=FARG_set_text(p,par,3);
		par.hdr=s{1};
	if	~par.opt.hflg
		[p,par]=FARG_set_entries(p,par,s,sr,ixb);
	else
		par.res=par.hdr;
	end
		par.ltok(lix,2)=ltmp;
end
function	[p,par]=FARG_chk_entries(p,par)
		ie=cellfun(@exist,p.UU.fn);
		p.UU.dd=ie.';
		p.U.fd=p.U.fn;
		p.U.dd=nan(size(p.U.fd));
	if	par.nfun
	if	p.M.nx
		ix=strncmp(p.M.fn{1},p.U.fn,numel(p.M.fn{1}));
		ix=ix&(p.U.lx==p.M.lx);
	if	any(ix)
		ie(ix)=[];
		ia=find(strncmp(par.ltok(:,2),p.M.fn{1},numel(p.M.fn{1})));
		ia=ia(par.lex(ia,3)==p.M.lx);
		ia=ia(3:end);
	if	~isempty(ia)
		na=numel(ia);
		p.U.fn=[p.U.fn;repmat(p.U.fn(ix),na,1)];
		p.U.fd=[p.U.fd;repmat(p.U.fd(ix),na,1)];
		p.U.dd=[p.U.dd;repmat(p.U.dd(ix),na,1)];
		p.U.ex=[p.U.ex,par.lex(ia,1:2).'];
		p.U.bx=[p.U.bx,par.lex(ia,1:2).'];
		p.U.nx=p.U.nx+na;
		ix=[ix;true(na,1)];
	end
		[p,par]=FARG_upd_entries(p,par,'R',ix,~ix);
	end
	end
		ix=~cellfun(@isempty,regexp(p.U.fn,par.rexeva));
	if	any(ix)
		ie(ix)=[];
		ia=regexp(par.ltok(:,2),par.rexeva);
		ia=find(~cellfun(@isempty,ia));
		it=~ismember(par.lex(ia,1:2),p.U.bx(:,ix).','rows');
		ia=ia(it);
	if	~isempty(ia)
		na=numel(ia);
		tok=par.ltok(ia,2);
		p.U.fn=[p.U.fn;tok];
		p.U.fd=[p.U.fd;tok];
		p.U.dd=[p.U.dd;nan(na,1)];
		p.U.ex=[p.U.ex,par.lex(ia,1:2).'];
		p.U.bx=[p.U.bx,par.lex(ia,1:2).'];
		p.U.nx=p.U.nx+na;
		ix=[ix;true(na,1)];
	end
		[p,par]=FARG_upd_entries(p,par,'E',ix,~ix);
	end
	end
		af=[p.S.fn;p.N.fn];
		im=ismember(p.U.fn,af);
		id=cellfun(@which,p.U.fn,'uni',false);
		iw=cellfun(@isempty,id);
		p.U.fd(~iw)=id(~iw);
		p.U.dd=ie(:).';
	if	~isempty(im)
		us=~im&iw&ie;				% unknown source
		p.U.fd(us)=cellfun(@(x) sprintf('%s [source?]',x),p.U.fn(us),'uni',false);
		ur=~im&iw;
		uk=~(ur|im);
		[p,par]=FARG_upd_entries(p,par,'X',ur,uk);
	end
end
function	[p,par]=FARG_upd_entries(p,par,fe,ur,uk)
	for	i=1:size(par.stmplf)
		nr=par.stmplf{i,3};
	if	nr
		fn=par.stmplf{i,1};
	switch	nr
	case	1
		p.(fe).(fn)=p.U.(fn)(ur);
		p.U.(fn)=p.U.(fn)(uk);
	case	2
		p.(fe).(fn)=p.U.(fn)(:,ur);
		p.U.(fn)=p.U.(fn)(:,uk);
	end
	end
	end
		p.(fe).nx=sum(ur);
		p.U.nx=sum(uk);
end
function	[p,par,sr,ixb]=FARG_add_entries(p,par,sr,fe,ixb)
		sub=p.(fe);
	if	sub.nx
		par.nfun=par.nfun+sub.nx;
		ci=numel(ixb);
		ixb=[ixb;sub.bx(1,:).'];
		p.ixm=[p.ixm;[par.senum.(fe)*ones(sub.nx,2),sub.bx(2,:).']];
		p.ixm(:,1)=ixb;
		sr(ci+1:ci+sub.nx)=sub.fd;
		[ix,ix]=sortrows(p.ixm,[1,3,2]);	%#ok
		sr=sr(ix);
		p.ixm=p.ixm(ix,:);
		ixb=p.ixm(:,1);
	end
		p.def=sr;
end
function	[p,par]=FARG_set_entries(p,par,s,sr,ixb)
	if	par.nfun
		nfmt=repmat({''},par.nfun,1);
		ix=p.ixm(:,2)<4;			% cyc M S N
	if	any(ix)					% FUNCTION
		nfmt(ix)=par.lint.cyc(:,2);
	else						% SCRIPT
		par.fmtcmp='%1s';
	end
		fmt=strrep('%s%6d|%s: %c  X %s','X',par.fmtcmp);
		omax=0;
	for	i=1:par.nfun
		cn=i+par.shdr;
		s{cn}=sprintf(fmt,...
			par.bol,...
			i,...
			par.fmtmark,...
			par.ftok{p.ixm(i,2),1},...
			nfmt{i},...
			par.ftok{p.ixm(i,2),2});
		s{cn}=deblank(sprintf('%s%s',s{cn},sr{i}));
	if	par.opt.line
		of=sprintf(par.fmtopen,par.wnam,ixb(i),ixb(i));
	else
		of=sprintf(par.fmtnoop,ixb(i));
	end
		omax=max([omax,numel(of)]);
		s{cn}=strrep(s{cn},par.fmtmark,of);
	end
	if	par.opt.line
		s{par.shdr}=[par.bol,' ',sprintf(repmat('-',1,size(char(s),2)-omax+par.ooff))];
	else
		cmax=max(cellfun(@numel,s(par.shdr+1:end)));
		s{par.shdr}=[par.bol,' ',sprintf(repmat('-',1,cmax-3))];
	end
		ix=(p.ixm(:,2)==1) | (p.ixm(:,2)==2);
	if	any(ix)
		sf=[p.M.fn;p.S.fn];
		sf=sf(~cellfun(@isempty,sf));
		sd=sr(ix);
		ns=max(cellfun(@numel,sf));
		fmt=sprintf('%%-%ds   >   %%s',ns);
		sd=cellfun(@(a,b) sprintf(fmt,a,b),sf,sd,'uni',false);
		p.sub=sd;
	end
		ix=strfind(par.deflin,'syntax');
		im=cellfun(@numel,par.ftok(:,2));
		s{par.shdr}(ix+im-1)='|';
	else
		s=s(1);
	end
		p.def=sr;
		par.res=s;
end
function	p=FARG_get_context(p,par,fe,isclosed)
	if	isclosed
		lexstp=par.lexstp;
		par.lexstp{3}=''')''';
	end
		sub=p.(fe);
		[ib,ib]=ismember(sub.bx.',par.lex(:,1:2),'rows');	%#ok
		[ie,ie]=ismember(sub.ex.',par.lex(:,1:2),'rows');	%#ok
	for	ibx=1:numel(ib)
		nb=0;
	for	ix=ib(ibx):-1:1
	if	isclosed
	if	any(ismember(par.ltok{ix,2},lexstp))
		ib(ibx)=ix+1;
		break;
	end
	else
		nb=nb+any(ismember(par.ltok{ix,2},par.lexbre));
	if	nb>0
		nb=nb-any(ismember(par.ltok{ix,2},par.lexbrb));
	elseif	~nb
		im=any(ismember(par.ltok{ix,2},par.lexstp));
	if	im
		ib(ibx)=ix+1;
		break;
	end
	end
	end
	end
	end
	for	ibx=1:numel(ie)
	for	ix=ie(ibx):par.nlex
		im=any(ismember(par.ltok{ix,2},par.lexstp));
	if	im
		ie(ibx)=ix-1;
		break;
	end
	end
	end
		sub.lx=[ib(:).';ie(:).'];
	if	isclosed
		[sub.lx,ix]=sortrows(sub.lx.');
		sub.fn=sub.fn(ix);
		sub.fd=sub.fd(ix);
		sub.lx=sub.lx.';
		sub.bx=sub.bx(:,ix);
		sub.ex=sub.ex(:,ix);
	end
		p.(fe)=sub;
end
function	ss=FARG_set_context(p,par,fe)
		ss=cell(p.(fe).nx,1);
	for	i=1:p.(fe).nx
		dtok=par.ltok(p.(fe).lx(1,i):p.(fe).lx(2,i),:);
		ix=~strncmp('<STRING>',dtok(:,1),8);
		ie= strncmp('<EOL>',dtok(:,1),5);
		iz=cellfun(@numel,dtok(:,1))==1;
		ix=xor(ix,iz);
		a=par.ltok(p.(fe).lx(1,i):p.(fe).lx(2,i),2);
		a(ix)=regexprep(a(ix),'^['']','');
		a(ix)=regexprep(a(ix),'['']$','');
		a(ie)={';'};
		a=sprintf('%s',a{:});
		a=strrep(a,'...','');
		a=strrep(a,''':'':''',':');
		ix=ismember(a,par.wspace);
		a(ix)='';
		ix=find(a=='@',1,'first');
	if	~isempty(ix)
		ix=find(a(ix:end)==')')+ix-1;
		a=[a(1:ix),' ',a(ix+1:end)];
	end
		ss{i}=FARG_set_bracket(a);
	end
end
function	s=FARG_set_bracket(s)
		br={
			'[]'	1
			'()'	2
			'{}'	3
		};
		ba=cell(size(br,1),1);
	for	i=1:size(br,1)
		bb=strfind(s,br{i,1}(1));
		be=strfind(s,br{i,1}(2));
		k=zeros(size(s));
		k(bb)=ones(size(bb));
		k(be)=-ones(size(be));
		k=cumsum(k);
		k=[k(end:-1:1),0];
	if	k(1) > 0
		bc=br{i,2}*ones(2,k(1));
	for	j=1:k(2)
		bc(1,j)=find(k(1:end-1)==j&k(2:end)==j-1,1,'first');
	end
		ba{i}=bc;
	end
	end
		ba=cat(2,ba{:});
	if	~isempty(ba)
		ba(1,:)=numel(s)-ba(1,:)+1;
		bc=sortrows(ba.',-1).';
		bc=bc(2,:);
		r=char(1:numel(bc)-1);
	for	i=1:size(br,1)
		r(bc==br{i,2})=br{i,1}(2);
	end
		s=[s,r];
	end
end
function	[p,par,s]=FARG_set_text(p,par,mode)
	if	par.opt.Sflg
		return;
	end
	switch	mode
	case	1
		par.txt(1,1)={
			sprintf('%s parsing...          %s',par.bol,par.wnam)
		};
		FARG_sdisp(par,char(par.txt));
		par.rt=clock;
		return;
	case	2
		par.rt=etime(clock,par.rt);
		par.txt(2,1)={
			sprintf('%s done                %.4f sec',par.bol,par.rt)
		};
	if	~par.lint.ferr				&&...
		par.opt.wflg				&&...
		par.lint.nerr
		nl=max(cellfun(@numel,par.lint.err));
		par.res=[
			par.res
			{
				sprintf('\n%s WARNINGS',par.bol)
				repmat('-',1,nl)
			}
			par.lint.err
		];
	end
		par.res=char(par.res);
	if	~par.flg
		FARG_sdisp(par,char(par.txt(2:end,1)));
		FARG_sdisp(par,char(par.res));
	else
		par.res=char(par.txt);
		FARG_sdisp(par,par.res(1+p.par.opt.sflg:end,:));
	end
		return;
	case	3
		par.txt=[
			par.txt
			{
			'DONE'
			sprintf('');
			}
		];
	if	~isempty(par.pnam)
		pc=par.pnam;
	else
		pc='';
	end
		nu=numel(unique(p.U.fd));
		s=cell(par.nfun+par.shdr,1);
	if	par.mp(3)
		ftype=par.ftyp{3};
	else
		ftype=par.ftyp{sign(par.mfun)+1};
	end
		s{1}={
			sprintf('%s MATLAB version  :   %s',par.bol,par.MLver)
			sprintf('%s %.4s   version  :   %s',par.bol,par.magic,par.fver)
			sprintf('%s run    date     :   %s',par.bol,par.rundate)
			sprintf('%s',par.bol);
			sprintf('%s FILE            :   %s',par.bol,par.wnam)
			sprintf('%s - Pcode         :   %s',par.bol,pc)
			sprintf('%s - type          :   %s',par.bol,ftype)
			sprintf('%s - date          :   %s',par.bol,par.dnam.ds{1})
			sprintf('%s - time          :      %s',par.bol,par.dnam.ds{2})
			sprintf('%s - size          :   %11d   bytes',par.bol,par.dnam.bytes)
			sprintf('%s - LEX tokens    :   %11d',par.bol,par.nlex)
			sprintf('%s   - lines       :   %11d',par.bol,par.nlen)
			sprintf('%s   - comments    :   %11d /           %.2f %%',par.bol,par.ncom,100*par.ncom/par.nlen)
			sprintf('%s   - empty       :   %11d /           %.2f %%',par.bol,par.nemp,100*par.nemp/par.nlen)
			sprintf('%s   - warnings    :   %11d',par.bol,par.lint.nerr)
			sprintf('%s   - complexity  :   %11d   max',par.bol,par.lint.mcyc);
			sprintf('%s - calls         :   %11d',par.bol,sum(p.n))
			sprintf('%s   - stock/user  :   %11d / unique    %-1d',par.bol,p.U.nx,nu)
			sprintf('%s - functions     :   %11d',par.bol,par.nfun)
			sprintf('%s   - main        : %c %11d / recursion %-1d',par.bol,par.ftok{1,1},p.M.nx,p.R.nx)
			sprintf('%s   - subroutines : %c %11d',par.bol,par.ftok{2,1},p.S.nx)
			sprintf('%s   - nested      : %c %11d',par.bol,par.ftok{3,1},p.N.nx)
			sprintf('%s   - anonymous   : %c %11d',par.bol,par.ftok{4,1},p.A.nx)
			sprintf('%s   - eval        : %c %11d',par.bol,par.ftok{7,1},p.E.nx)
			sprintf('%s   - unresolved  : %c %11d',par.bol,par.ftok{5,1},p.X.nx)
		};
		s{1}=char(s{1});
	if	par.nfun
			ctok=strrep(par.fmtcmp,'d','s');
			ctok=sprintf(ctok,'C');
			par.deflin=sprintf('%s     #|line      : T  %s  syntax',...
				par.bol,ctok);
		s{2}={
			sprintf('%s',par.bol)
			sprintf('%s FUNCTIONS',par.bol)
			par.deflin
		};
		s{2}=char(s{2});
		s{par.shdr}='x';
	end
	end
end
function	FARG_sdisp(par,txt)
	if	par.opt.sflg
		disp(txt);
	end
end
function	s=FARG_show_entries(p,varargin)
		ades=p.des(1:end-1);
	if	nargin > 1
		ix=ismember(lower(ades),lower(varargin));
	else
		ix=true(1,numel(ades));
	end
		ades=p.des(ix);
	if	isempty(ades)
		return;
	end
		s=cell(sum(p.n(ix))+numel(ades),1);
		p.A.fd=repmat({''},p.A.nx,1);
		oa=p.A;
		p.A.fn=p.A.fd;
		sm=-inf;
	for	i=ades(:).'
		sm=max([sm;max(cellfun(@numel,p.(i{:}).fn))]);
	end
		p.A=oa;
		ffmt=sprintf('%%%%%%%% -   %%-%d.%ds > %%s',sm,sm);
		afmt=sprintf('%%%%%%%% -   %%s%%s');
		ix=0;
	for	i=1:numel(ades)
		ix=ix+1;
		cd=ades{i};
		s{ix}=sprintf('%%%% %s %d',cd,p.(cd).nx);
	if	cd == 'A'
		fmt=afmt;
	else
		fmt=ffmt;
	end
	for	j=1:p.(cd).nx
		ix=ix+1;
		s{ix}=sprintf(fmt,p.(cd).fn{j},p.(cd).fd{j});
	end
	end
	if	~nargout
		disp(char(s));
		clear	s;
	end
end
%-------------------------------------------------------------------------------
%$SSC_INSERT_END   21-Jun-2010/02:16:53   F:/usr/matlab/tmp/fex/afarg/ver2010/farg.m
%-------------------------------------------------------------------------------
%-------------------------------------------------------------------------------
%-------------------------------------------------------------------------------
%
% DETAB		a FEX file
% created:
%	us	21-Apr-1992
%
% download the latest standalone including help/comments from
% http://www.mathworks.com/matlabcentral/fileexchange/10536
%
%-------------------------------------------------------------------------------
%-------------------------------------------------------------------------------
%-------------------------------------------------------------------------------
%$SSC_INSERT_BEG   21-Jun-2010/02:16:53   F:/usr/matlab/unix/detab.m
%-------------------------------------------------------------------------------
% SSC automatic file insertion utility
%     - us@neurol.unizh.ch [ver 26-Apr-2010/00:48:30]
%     - all empty spaces and comments are stripped for brevity
%     - original code available upon request
%-------------------------------------------------------------------------------
function	[ss,p]=detab(cstr,varargin)
		magic='DETAB';
		pver='04-Jul-2008 20:35:47';
		ss=[];
		p=[];
		fnam='CELL';
		deftlen=8;
		deftchar=' ';
		otmpl={
		'-t'	true	1	deftlen		'tab length in char'
		'-c'	true	1	deftchar	'tab end marker'
		'-l'	false	0	[]		'show listbox'
		'-lp'	false	1	{}		'listbox parameters'
		};
	if	nargin < 1
		help(mfilename);
		return;
	end
		[opt,par]=DETAB_get_par(otmpl,varargin{:});
	if	ischar(cstr)
		fnam=which(cstr);
	if	~exist(cstr,'file')
		disp(sprintf('DETAB> file not found <%s>',fnam));
		return;
	end
		[fp,msg]=fopen(fnam,'rb');
	if	fp < 0
		disp(sprintf('DETAB> cannot open file <%s>',fnam));
		disp(sprintf('       %s',msg));
		return;
	end
		cstr=textscan(fp,'%s',...
			'delimiter','\n',...
			'whitespace','');
		fclose(fp);
		cstr=cstr{:};
	elseif	~iscell(cstr)
		disp('DETAB> input must be a file name or a cell');
		return;
	end
		tab=sprintf('\t');
		p.magic=magic;
		p.([magic,'ver'])=pver;
		p.MLver=version;
		p.rundate=datestr(clock);
		p.runtime=clock;
		p.par=par;
		p.opt=opt;
		p.input=fnam;
		p.cs=size(cstr);
		p.ns=numel(cstr);
		p.nc=0;
		p.nl=0;
		p.nt=0;
		cstr=cstr(:);
		ix=cellfun('isclass',cstr,'char');
		p.nc=sum(ix);
	if	~p.nc
		ss=cstr;
		return;
	end
		ss=cstr(ix);
		tmax=max(cellfun('length',ss));
		tlen=p.opt.t.val;
		tt=tlen:tlen:tmax*tlen;
		p.par.tab=repmat(['.......',p.par.tc],1,ceil(tmax/tlen));
		ttb=sprintf('TAB=%-1d',tlen);
		p.par.tab(1:length(ttb))=ttb;
		p.runtime=clock;
	for	i=1:p.nc
		s=ss{i};
		tp=strfind(s,tab);
	if	~isempty(tp)
		nt=numel(tp);
		p.nl=p.nl+1;
		p.nt=p.nt+nt;
		tn=1:nt;
		tm=tt(tn);
		tx=tm-tp+tn;
		tx(end)=[];
		tx=[0,tx]+tp-tn;
		tx=tm-tx;
		tx=mod(tx-1,tlen)+1;
		tx=p.par.t(tx);
		ss{i,1}=regexprep(s,'\t',tx,'once');
	end
	end
		p.runtime=etime(clock,p.runtime);
		cstr(ix)=ss;
		ss=reshape(cstr,p.cs);
		
	if	p.opt.l.flg
		blim=.005;
		clf;
		shg;
		p.par.uh=uicontrol('units','norm',...
			'position',[blim,blim,1-2*blim,1-2*blim],...
			'style','listbox',...
			'max',2,...
			'fontname','courier new',...
			'backgroundcolor',1*[.75 1 1],...
			'foregroundcolor',[0 0 1],...
			'tag',p.magic,...
			p.opt.lp.val{:});
		sh=char([{p.par.tab};ss(ix)]);
		set(p.par.uh,'string',sh);
	end
end
function	[opt,par]=DETAB_get_par(otmpl,varargin)
		par.t=[];
		par.tab=[];
		narg=nargin-1;
	for	i=1:size(otmpl,1)
		[oflg,val,arg,dval]=otmpl{i,1:4};
		flg=oflg(2:end);
		opt.(flg).flg=val;
		opt.(flg).val=dval;
		ix=strcmp(oflg,varargin);
		ix=find(ix,1,'last');
	if	ix
		opt.(flg).flg=true;
	if	arg
	if	narg >= ix+arg
		opt.(flg).val=varargin{ix+1:ix+arg};
	else
		opt.(flg).flg=val;
	end
	end
	end
	end
		tlen=opt.t.val;
		par.t=cell(tlen,1);
	for	i=1:tlen
		par.t{i,1}=sprintf('%*s',i,opt.c.val);
	end
	if	~isempty(opt.c.val)	&&...
		~isspace(opt.c.val)
		par.tc=opt.c.val;
	else
		par.tc=char(166);	% <>
	end
		par.uh=[];
end
%-------------------------------------------------------------------------------
%$SSC_INSERT_END   21-Jun-2010/02:16:53   F:/usr/matlab/unix/detab.m
%--------------------------------------------------------------------------------
%-------------------------------------------------------------------------------
%-------------------------------------------------------------------------------
%
% FDEP
% additional help sections
%
%-------------------------------------------------------------------------------
%-------------------------------------------------------------------------------
%-------------------------------------------------------------------------------
%@LISTHELP_BEG
% FDEP	version 21-Jun-2010 02:16:53
%
% the ML-file under investigation is the
%	root function = MAIN module
% a module is a user-defined ML-file living outside the root function
%	in a folder, which is part of ML's search path
% a module may be a ML-function (M- or P-file), a ML-script (M-file), or
%	a MEX/DLL-file (listed as P-file with correct extension)
% functions, which are called by an individual module, are grouped into
%	- main function
%	- subfunctions
%	- nested functions
%	- anonymous functions
%	- eval class calls
%	- unresolved calls
%	- ML stock functions
%	- ML built-in functions
%	- ML classes
%	- ML toolboxes
% most panels have tooltips
%
% all windows have a floating list with buttons for
%	- quit			closes the current window
%	- font -		makes the fontsize smaller by 1 point
%	- font +		makes the fontsize larger  by 1 point
%	- help			shows this help in a window
%	- manager		shows the window manager if there is more than
%				  one FDEP associated window open
%				- contains a list of all open FDEP windows
%				- clicking on an entry will bring its window
%				  to the top
%	- list			shows the modules listing window
%	- matrix		shows the dependency matrix window
%	- tree			shows the runtime and modules tree
%	- home			jumps to the top of a single module window
%
%	changing the window size may cause the button list to disappear until
%	it is resized again
%
% modules
%-------------------------------------------------------------------------------
%	a list of all modules, which are called by the MAIN module
%	the MAIN module is always on top of the list, all other modules are
%	   sorted in alphabetical order and show information in 3 columns
%		1	# of the module
%			- this number must be used for command line access of
%			  numeric module information by the macros
%				p.find(M#,...);
%				p.get(M#,...);
%				p.FDEP_mlist(M#);
%				p.list(M#,...);
%				p.plot([Mx/My],...);
%		2	name of the module
%		3	special attributes of the module
%				R: module calls itself (recursive)
%				E: module uses an EVAL/EVALIN/EVALC/FEVAL construct
%				S: module is a SCRIPT
%				P: module is or has a P-file
%	CLICKING on a name activates the module
%
% main function
%-------------------------------------------------------------------------------
%	shows a synopsis of the MAIN module including a summary of the calls of
%	   all its modules for each group of ML functions, version information,
%	   and the runtime
%	CLICKING in this box will activate the MAIN module
%
% toolboxes
%-------------------------------------------------------------------------------
%	shows a list of all toolboxes that are used by the modules
%	those that are used by the currently selected module are highlighted
%	toolboxes are shown with their official name, version, and folder name
%	CLICKING on a toolbox name highlights in the modules list
%		those modules, which use the toolbox
%
% module summary
%-------------------------------------------------------------------------------
%	shows the summary of the current module including its attributes and
%	   the exact number of calls for each group of functions
%	all function group entries are sorted
%	all calls found in the function are shown in sequence and may be
%	   repeated (same call in different subfunctions)
%	if both M- and P-FILE names are shown, the M-file is used
%	   to extract all data, but the P-FILE will be called during runtime
%	if only a P-FILE name is shown (standalone), only ML entities
%	   can be extracted due to the limitations of MLINT
%	to retrieve this information from the command window, use macro
%		p.find(M1,...);
%	CLICKING on the first line will show the full synopsis in a window
%	to show the full synopsis from the command window, use macro
%		p.mhelp(M1,...);
%
% calls  TO
%-------------------------------------------------------------------------------
%	shows all modules that the current module calls
%	CLICKING on a name activates the module in <modules> and shows its
%	   content
%
% called FROM
%-------------------------------------------------------------------------------
%	shows all modules that call the current module
%	CLICKING on a name activates the module in <modules> and shows its
%	   content
%
% subfunctions
%-------------------------------------------------------------------------------
%	shows subfunctions of the current module in the format
%		M(line#): function name > definition of MAIN/first function
%		S(line#): function name > definition of subfunction
%	this box is only filled, if the module is a ML function
%	CLICKING on a name opens the module in the editor at its line
%
% nested / anonymous functions
%-------------------------------------------------------------------------------
%	shows function definitions of the current module in the format
%		A(line#): definition of anonymous function
%		N(line#): definition of nested    function
%	CLICKING on a name opens the module in the editor at its line
%
% font - / font +
%-------------------------------------------------------------------------------
%	utility in honor of John D'errico, a senior and most respected
%	   FEX and CSSM contributor, with very poor eyesight
%	CLICKING on the button will change the fontsize by -1/1 point
%
% EDIT
%-------------------------------------------------------------------------------
%	opens the current module in the editor
%
% DEPENDENCY MATRIX
%-------------------------------------------------------------------------------
%	displays the dependency matrix of the MAIN module
%
% HELP
%-------------------------------------------------------------------------------
%	shows this help in a window
%	to show this help from the command window, use macro
%		p.help();	displays content in a window
%		p.help(1);	displays content in the command window
%
%@LISTHELP_END
%-------------------------------------------------------------------------------

Contact us