Return to size.icn CVS log

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

Annotation of 43BSD/contrib/icon/src/lib/size.icn, revision 1.1

1.1     ! root        1: #      SIZE(2)
        !             2: #
        !             3: #      Size of Icon value
        !             4: #
        !             5: #      Ralph E. Griswold
        !             6: #
        !             7: #      Last modified 8/15/84
        !             8: #
        !             9: 
        !            10: global v16, v32, T
        !            11: 
        !            12: procedure Size(x,X,Done)
        !            13:    local i
        !            14:    initial {
        !            15:       v16 := table()           # 16-bit implementations
        !            16:       v32 := table()           # 32-bit implementations
        !            17:       v16["c"] := 34           # cset size
        !            18:       v16["dr"] := 4           # descriptor
        !            19:       v16["e"] := 2034         # co-expression
        !            20:       v16["f"] := 10           # file
        !            21:       v16["l"] := 12           # list
        !            22:       v16["le"] := 18          # list element
        !            23:       v16["li"] := 6           # long integer
        !            24:       v16["p"] := 18           # procedure
        !            25:       v16["r"] := 10           # real number
        !            26:       v16["s"] := 54           # set
        !            27:       v16["se"] := 12          # selement
        !            28:       v16["t"] := 60           # table
        !            29:       v16["te"] := 16          # table element
        !            30:       v16["R"] := 6            # record overhead
        !            31:       v32["c"] := 36           # cset size
        !            32:       v32["dr"] := 8           # descriptor
        !            33:       v32["e"] := 8068         # co-expression
        !            34:       v32["f"] := 20           # file
        !            35:       v32["l"] := 24           # list
        !            36:       v32["le"] := 36          # list element
        !            37:       v32["p"] := 36           # procedure
        !            38:       v32["r"] := 12           # real number
        !            39:       v32["s"] := 296          # set
        !            40:       v32["se"] := 24          # set element
        !            41:       v32["t"] := 304          # table
        !            42:       v32["te"] := 32          # table element
        !            43:       v32["R"] := 12           # record overhad
        !            44:       }
        !            45:    /Done := table()
        !            46:    case X of {
        !            47:       &null | 32:  T := v32
        !            48:       16:          T := v16
        !            49:       default:     stop("invalid second argument to Size")
        !            50:       }
        !            51:    if match("record ",image(x)) then return rsize(x,X,Done)
        !            52:    else return case type(x) of {
        !            53:       "co-expression": ifnew(x,T["e"],Done)
        !            54:       "cset":  ifnew(x,T["c"],Done)
        !            55:       "file":  ifnew(x,T["f"],Done)
        !            56:       "integer": isize(x,X)
        !            57:       "list":  lsize(x,X,Done)
        !            58:       "null":  0
        !            59:       "procedure": ifnew(x,T["p"],Done)
        !            60:       "real":  ifnew(x,T["r"],Done)
        !            61:       "set":  ssize(x,X,Done)
        !            62:       "string":  *x
        !            63:       "table": tsize(x,X,Done)
        !            64:       default: stop("unknown type")
        !            65:       }
        !            66: end
        !            67: 
        !            68: #  size of list
        !            69: #
        !            70: procedure lsize(a,X,Done)
        !            71:    local i
        !            72:    if \Done[a]  then return 0
        !            73:    Done[a] := 1
        !            74:    i := T["l"]
        !            75:    j := *a
        !            76:    j <:= 8
        !            77:    i := T["le"] + T["l"] + T["dr"] * j
        !            78:    every i +:= Size(!a,X,Done)
        !            79:    return i
        !            80: end
        !            81: 
        !            82: #  size of record
        !            83: #
        !            84: procedure rsize(x,X,Done)
        !            85:    local i
        !            86:    if match("record constructor ",image(x)) then return 0
        !            87:    if \Done[x] then return 0
        !            88:    Done[x] := 1
        !            89:    i := T["R"] + T["dr"] * *x
        !            90:    every i+:= Size(!x,X,Done)
        !            91:    return i
        !            92: end
        !            93: 
        !            94: #  size of set
        !            95: #
        !            96: procedure ssize(s,X,Done)
        !            97:    local i, a, a1
        !            98:    if \Done[s] then return 0
        !            99:    Done[s] := 1
        !           100:    i := T["s"] + T["se"] * *s
        !           101:    a := sort(s)
        !           102:    every a1 := !a do
        !           103:      i +:= Size(a1,X,Done)
        !           104:    return i
        !           105: end
        !           106: 
        !           107: #  size of table
        !           108: #
        !           109: procedure tsize(t,X,Done)
        !           110:    local i, a, a1
        !           111:    if \Done[t] then return 0
        !           112:    Done[t] := 1
        !           113:    i := T["t"] + T["te"] * *t
        !           114:    a := sort(t)
        !           115:    every a1 := !a do
        !           116:      i +:= Size(a1[1],X,Done) + Size(a1[2],X,Done)
        !           117:    return i
        !           118: end
        !           119: 
        !           120: #  test if object already counted in total
        !           121: #
        !           122: procedure ifnew(x,i,Done)
        !           123:    if \Done[x] then return 0
        !           124:    Done[x] := 1
        !           125:    return i
        !           126: end
        !           127: 
        !           128: #  size of integer
        !           129: #
        !           130: procedure isize(i,X)
        !           131:    if T === v32 then return 0
        !           132:    if -(2 ^ 15) <= i <= (2 ^ 15 - 1) then return 0
        !           133:    else return T["li"]
        !           134: end

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