Return to fset.icn CVS log

Up to [CSRG BSD Unix] / 43BSD / contrib / icon / src / cmd

Annotation of 43BSD/contrib/icon/src/cmd/fset.icn, revision 1.1

1.1     ! root        1: #      FSET(1)
        !             2: #
        !             3: #      Perform set operations on file specifications
        !             4: #
        !             5: #      Thomas R. Hicks
        !             6: #
        !             7: #      Last modified 8/14/84
        !             8: #
        !             9: 
        !            10: procedure main(args)
        !            11:    local i, fyls, arglist
        !            12:    if not find("sets",&options) then
        !            13:       stop("Set extensions must be enabled to run this program.")
        !            14:    if *args = 0 then return
        !            15:    if *args > 1 then
        !            16:       every i := 2 to *args do
        !            17:          args[1] ||:= (" " || args[i])
        !            18:    (arglist := parse(args[1])) |
        !            19:       stop("Invalid file specification expression")
        !            20:    case type(arglist) of {
        !            21:       "string" : fyls := mkfset(arglist)
        !            22:       "list"   : fyls := exec(arglist)
        !            23:       default  : stop("Main: bad type -can't happen")
        !            24:       }
        !            25:    fyls := sort(fyls)
        !            26:    every write(!fyls," ")
        !            27: end
        !            28: 
        !            29: procedure Exp()                        # file spec expression parser
        !            30:    local a
        !            31:    suspend (a := [Factor(),=Op(),Factor()] & [a[2],a[1],a[3]]) |
        !            32:       Factor() |
        !            33:       (a := [="(",Exp(),=")"] & .a[2])
        !            34: end
        !            35: 
        !            36: procedure Factor()             # file spec expression parser
        !            37:    local a
        !            38:    suspend (a := [Term(),=Op(),Term()] & [a[2],a[1],a[3]]) |
        !            39:       Term() |
        !            40:       (a := [="(",Factor(),=")"] & .a[2])
        !            41: end
        !            42: 
        !            43: procedure Name()               # file spec name matcher
        !            44:    static valid
        !            45:    initial valid := ~'()'
        !            46:    suspend (any(~valid) || fail) | tab(find(Op()) | many(valid))
        !            47: end
        !            48: 
        !            49: procedure Non()                        # file spec expression parser
        !            50:    local a
        !            51:    suspend a := [Name(),=Op(),Name()] & [a[2],a[1],a[3]]
        !            52: end
        !            53: 
        !            54: procedure Op()                 # file spec operation matcher
        !            55:    suspend !["++","--","&&"]
        !            56: end
        !            57: 
        !            58: procedure Term()               # file spec expression parser
        !            59:    local a
        !            60:    suspend (a := [="(",Non(),=")"] & .a[2]) |
        !            61:            Name()
        !            62: end
        !            63: 
        !            64: procedure bldfset(arg)         # build file set, excluding . and ..
        !            65:    local line
        !            66:    static dotfiles
        !            67:    initial dotfiles := set([".",".."])
        !            68:    line := read(open("echo " || arg,"rp"))
        !            69:    return str2set(line,' ') -- dotfiles
        !            70: end
        !            71: 
        !            72: procedure exec(lst)            # process file spec list recursively
        !            73:    return setops(lst[1])(exec2(lst[2]),exec2(lst[3]))
        !            74: end
        !            75: 
        !            76: procedure exec2(arg)           # helping procedure for exec
        !            77:    case type(arg) of {
        !            78:       "string" : return mkfset(arg)
        !            79:       "list"   : return exec(arg)
        !            80:       default  : stop("exec2: can't happen")
        !            81:       }
        !            82: end
        !            83: 
        !            84: procedure mkfset(fspec)                # make file list from specification
        !            85:    if fspec == "*" then
        !            86:       fspec := "* .*"
        !            87:    return bldfset(fspec)
        !            88: end
        !            89: 
        !            90: procedure parse(str)           # top level of parsing procedures
        !            91:    local res
        !            92:    str ? (res := Exp() & pos(0)) | fail
        !            93:    return res
        !            94: end
        !            95: 
        !            96: procedure sdiff(f1,f2)         # set difference
        !            97:    return f1 -- f2
        !            98: end
        !            99: 
        !           100: procedure setops(op)           # return correct set operaton
        !           101:    case op of {
        !           102:       "++"     : return sunion
        !           103:       "&&"     : return sinter
        !           104:       "--"     : return sdiff
        !           105:       }
        !           106: end
        !           107: 
        !           108: procedure sinter(f1,f2)                # set intersection
        !           109:    return f1 ** f2
        !           110: end
        !           111: 
        !           112: procedure str2set(str,delim)   # convert delimited string into a set
        !           113:    local fset, f
        !           114:    fset := set([])
        !           115:    str ? {
        !           116:       while f := (tab(upto(delim))) do {
        !           117:          insert(fset,f)
        !           118:          move(1)
        !           119:          }
        !           120:       if "" ~== (f := tab(0)) then
        !           121:          insert(fset,f)
        !           122:       }
        !           123:    return fset
        !           124: end
        !           125: 
        !           126: procedure sunion(f1,f2)                # set union
        !           127:    return f1 ++ f2
        !           128: end

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.