修改所有可能的stata ado文件，使其接受任意数量的变量

我正在尝试使用allappability.ado来检查几个变量之间的交互。它不接受超过6个变量。有没有办法修改代码，使其接受任意数量的变量。 这是代码，这个模块是由Nicholas J.Cox编写的

program define allpossible 
    version 7.0

    * process syntax 
    gettoken cmd 0 : 0
    syntax varlist(min=2 numeric ts) [aw fw iw pw] [if] [in] , /* 
    */ [ ECLASS(str) RCLASS(str) NPMAX(int -1) * Format(str)   /* 
    */ CELLWidth(int 12) Detail ] 
    
    marksample touse
    qui count if `touse' 
    if r(N) == 0 { 
        error 2000 
    }

    if "`eclass'`rclass'" == "" { 
        di as err "must specify at least one of eclass() or rclass()"
    exit 198 
    }   
    if "`rclass'" != "" { 
        local nr : word count `rclass' 
    if `nr' < 2 { 
        di as err "rclass() invalid"
        exit 198 
    }
    tokenize `rclass' 
    local rprog "qui `1'" 
    mac shift 
    local rclass `*' 
    }   

    tokenize `varlist'
    local response `1'
    macro shift
    local rest `*'
    local np : word count `rest'
    
    local npmax = cond(`npmax' > 0 , min(`npmax',`np', 6), `np') 
    local nfits = 0 
    forval i = 0 / `npmax' { 
        local nfits = `nfits' + comb(`np',`i') 
    }
    qui count   
    if r(N) < `nfits' { 
        di as err "sorry: # of observations should be at least `nfits'"
        exit 198 
    }     

    * wire in response and apply any weights 
    local cmd "`cmd' `response'"
    if "`detail'" != "" {
        local cmd "noisily `cmd'"
    }    
    local etc "[`weight' `exp'] if `touse', `options'" 

    * main loop, except that we break out somewhere before repetition  
    qui while 1 { 

        * no predictors 
        `cmd' `etc' 
    foreach s of local eclass { 
            tempvar v`s' 
            gen double `v`s'' = e(`s') in 1 
            label var `v`s'' "`s'" 
            local results "`results'`v`s'' "
    }   
    
    if "`rclass'" != "" { 
        `rprog' 
        foreach s of local rclass { 
            tempvar v`s' 
            gen double `v`s'' = r(`s') in 1 
            label var `v`s'' "`s'" 
            local results "`results'`v`s'' " 
        }
        }       
            
        tempvar predictors model 
        gen str6 `predictors' = "(none)" in 1 
        label var `predictors' "predictors" 
        gen byte `model' = _n 
        label var `model' "model"
             
        * one predictor
        local p = 1 
        qui forval i = 1 / `np' {
            `cmd' ``i'' `etc' 
            local p = `p' + 1 
            foreach s of local eclass { 
                replace `v`s'' = e(`s') in `p'
        }
            if "`rclass'" != "" { 
            `rprog' 
            foreach s of local rclass { 
                replace `v`s'' = r(`s') in `p' 
            } 
        }
            replace `predictors' = "`i'" in `p' 
        } 
             
        if `npmax' == 1 {
            continue, break 
        }    
      
        * two predictors
        local npm1 = `np' - 1 
        qui forval i = 1 / `npm1' {
            local j1 = `i' + 1
            forval j = `j1' / `np' {
                local p = `p' + 1 
                `cmd' ``i'' ``j'' `etc' 
                foreach s of local eclass { 
                    replace `v`s'' = e(`s') in `p'
                }     
        if "`rclass'" != "" { 
                `rprog' 
                foreach s of local rclass { 
                    replace `v`s'' = r(`s') in `p' 
                } 
            }
                replace `predictors' = "`i' `j'" in `p' 
            }     
        }

        if `npmax' == 2 {
            continue, break 
        }    
  
        * three predictors
        local npm2 = `np' - 2 
        qui forval i = 1 / `npm2' {
            local j1 = `i' + 1
            forval j = `j1' / `npm1' {
                local k1 = `j' + 1
                forval k = `k1' / `np' { 
                    local p = `p' + 1 
                    `cmd' ``i'' ``j'' ``k'' `etc'
                    foreach s of local eclass { 
                        replace `v`s'' = e(`s') in `p' 
                    }    
                    if "`rclass'" != "" { 
                        `rprog'                                            
                         foreach s of local rclass {  
                             replace `v`s'' = r(`s') in `p'         
             }
                    }
                    replace `predictors' = "`i' `j' `k'" in `p' 
        }   
            }                  
        }    
    
        if `npmax' == 3 {
            continue, break 
        }    

        * four predictors
        local npm3 = `np' - 3 
        qui forval i = 1 / `npm3' {
            local j1 = `i' + 1
            forval j = `j1' / `npm2' {
                local k1 = `j' + 1
                forval k = `k1' / `npm1' { 
                    local l1 = `k' + 1 
                    forval l = `l1' / `np' { 
                        local p = `p' + 1 
                        `cmd' ``i'' ``j'' ``k'' ``l'' `etc'
                        foreach s of local eclass { 
                            replace `v`s'' = e(`s') in `p' 
                        }
            if "`rclass'" != "" { 
                `rprog' 
                foreach s of local rclass { 
                    replace `v`s'' = r(`s') in `p' 
                }
            }    
                replace `predictors' = "`i' `j' `k' `l'" in `p' 
                    }
                }
            }     
        }

        if `npmax' == 4 {
            continue, break 
        }    

        * five predictors
        local npm4 = `np' - 4 
        qui forval i = 1 / `npm4' {
            local j1 = `i' + 1
            forval j = `j1' / `npm3' {
                local k1 = `j' + 1
                forval k = `k1' / `npm2' { 
                    local l1 = `k' + 1 
                    forval l = `l1' / `npm1' { 
                        local m1 = `l' + 1 
                        forval m = `m1' / `np' { 
                            local p = `p' + 1 
                            `cmd' ``i'' ``j'' ``k'' ``l'' ``m'' `etc'
                            foreach s of local eclass { 
                                replace `v`s'' = e(`s') in `p' 
                            }    
                if "`rclass'" != "" { 
                    `rprog' 
                foreach s of local rclass { 
                    replace `v`s'' = r(`s') in `p' 
                }
                }   
                            replace `predictors' = "`i' `j' `k' `l' `m'" in `p' 
                        }
                    }
                }     
            }     
        }
        
        if `npmax' == 5 {
            continue, break 
        }     
       
        * six predictors
        local npm5 = `np' - 5 
        quietly forval i = 1 / `npm5' {
            local j1 = `i' + 1
            forval j = `j1' / `npm4' {
                local k1 = `j' + 1
                forval k = `k1' / `npm3' { 
                    local l1 = `k' + 1 
                    forval l = `l1' / `npm2' { 
                        local m1 = `l' + 1 
                        forval m = `m1' / `npm1' { 
                            local n1 = `m' + 1  
                            forval n = `n1' / `np' { 
                                local p = `p' + 1 
                                `cmd' ``i'' ``j'' ``k'' ``l'' ``m'' ``n'' `etc'
                                foreach s of local eclass { 
                                    replace `v`s'' = e(`s') in `p' 
                                }     
                if "`rclass'" != "" { 
                    `rprog' 
                    foreach s of local rclass { 
                        replace `v`s'' = r(`s') in `p' 
                    }   
                }    
                                replace `predictors' = "`i' `j' `k' `l' `m' `n'" in `p' 
                            }
                        }
                    }     
                }     
            }
        }     

        if `npmax' == 6 {
            continue, break 
        }     
       
     } /* main loop */ 
     
     * table output 
     * integers mapped to strings to protect against decimal places 
     qui foreach v of local results { 
        capture assert `v' == int(`v') 
        if _rc == 0 { 
            tempvar v2 
            gen str1 `v2' = "" 
            replace `v2' = string(`v', "%9.0f") 
            _crcslbl `v2' `v' 
            local Results "`Results' `v2'" 
        } 
        else local Results "`Results' `v'" 
     } 
     
     if "`format'" == "" { 
        local format "%4.3f" 
     }


     tabdisp `model' in 1 / `p', c(`predictors' `Results') /* 
     */ format(`format') cellwidth(`cellwidth') 
     di 
     forval i = 1 / `np' { 
         di as res "  `i'" as text "{col 10}``i''" 
     }     

end

程序定义所有可能的
7.0版
*进程语法
gettoken cmd 0:0
语法变量列表（min=2个数字ts）[aw-fw-iw-pw][if][in]，/*
*/[ECLASS（str）RCLASS（str）NPMAX（int-1）*格式（str）/*
*/单元宽度（int 12）详图]
标记样本使用
如果“使用”，请计数
如果r（N）==0{
错误2000
}
如果“`eclass'`rclass'==”{
di as err“必须至少指定eclass（）或rclass（）中的一个”
198出口
}   
如果“'rclass'”="" { 
本地nr:字数'rclass'
如果'nr'小于2{
di作为错误“rclass（）无效”
198出口
}
标记“rclass”
本地rprog“qui`1'”
mac移位
本地rclass`*'
}   
标记化“varlist”
当地答复“1”
宏移位
局部休息“*”
局部np：字数'rest'
本地npmax=cond（`npmax'>0，min（`npmax'，`np'，6），`np'）
本地nfits=0
forval i=0/`npmax'{
本地nfits=`nfits'+comb（`np'，`i'）
}
qui计数
如果r（N）<`nfits'{
di作为错误“抱歉：#的观察值至少应为'nfits'”
198出口
}     
*电线响应并施加任何重量
本地cmd“`cmd'`response'”
如果“`细节'”="" {
本地命令“嘈杂地'cmd'”
}    
本地etc“['weight''exp']如果'tuse'，'options'”
*主循环，除了重复之前的某个地方
qui而1{
*无预测因素
`cmd'`etc'
局部eclass{
tempvar v`s'
gen double`v`s'=1中的e（`s'）
标签变量'v`s'“`s”
局部结果“`results'`v`s'”
}   
如果“`rclass'”=”{
`rprog'
局部rclass{
tempvar v`s'
gen double`v`s'=r（`s'）在1中
标签变量'v`s'“`s”
局部结果“`results'`v`s'”
}
}       
tempvar预测模型
gen str6‘预测器’=（无）在1中
标记变量“预测器”的“预测器”
发电机字节'model'=\n
标签变量'model'“model”
*一个预测器
局部p=1
qui forval i=1/`np'{
`cmd'`i'`etc'
局部p=`p'+1
局部eclass{
将'p'中的'v`s'=e（'s'）替换
}
如果“`rclass'”=”{
`rprog'
局部rclass{
替换'p'中的'v`s'=r（'s'）
} 
}
替换'p'中的'predictors'='i''
} 
如果'npmax'==1{
继续，休息
}    
*两个预测因子
局部npm1=`np'-1
qui forval i=1/`npm1'{
局部j1=`i'+1
forval j=`j1'/`np'{
局部p=`p'+1
`cmd'`i'`j'`etc'
局部eclass{
将'p'中的'v`s'=e（'s'）替换
}     
如果“`rclass'”=”{
`rprog'
局部rclass{
替换'p'中的'v`s'=r（'s'）
} 
}
替换'p'中的'predictors'='i''j''
}     
}
如果'npmax'==2{
继续，休息
}    
*三个预测因子
局部npm2=`np'-2
qui forval i=1/`npm2'{
局部j1=`i'+1
forval j=`j1'/`npm1'{
局部k1=`j'+1
forval k=`k1'/`np'{
局部p=`p'+1
`cmd'`i'`j'`k'`etc'
局部eclass{
将'p'中的'v`s'=e（'s'）替换
}    
如果“`rclass'”=”{
`rprog'
局部rclass{
替换'p'中的'v`s'=r（'s'）
}
}
将'predictors'替换为'p'中的'i''j''k''
}   
}                  
}    
如果'npmax'==3{
继续，休息
}    
*四个预测因子
本地npm3=`np'-3
qui forval i=1/`npm3'{
局部j1=`i'+1
forval j=`j1'/`npm2'{
局部k1=`j'+1
forval k=`k1'/`npm1'{
局部l1=`k'+1
forval l=`l1'/`np'{
局部p=`p'+1
`cmd'`i'`j'`k'`l'`etc'
局部eclass{
将'p'中的'v`s'=e（'s'）替换
}
如果“`rclass'”=”{
`rprog'
局部rclass{
替换'p'中的'v`s'=r（'s'）
}
}    
替换'p'中的'predictors'='i''j''k''l''
}
}
}     
}
如果'npmax'==4{
继续，休息
}    
*五个预测因子
局部npm4=`np'-4
qui forval i=1/`npm4'{
局部j1=`i'+1
forval j=`j1'/`npm3'{
局部k1=`j'+1
forval k=`k1'/`npm2'{
局部l1=`k'+1
F