goo 0.155-13 / usr / lib / goo / mods / eval / dependency.goo

This file is indexed.

/usr/lib/goo/mods/eval/dependency.goo is in goo 0.155-13.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below. 

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
;;;; Copyright 2002, Jonathan Bachrach.  See file TERMS.

;;;;;======================================================================
;;;;;  Dependency Tracking
;;;;;======================================================================
;;;;;  TODO - Considering renaming all the major classes in this module.

(use goo)

;;;;=======================================================================
;;;;  Types of Dependencies
;;;;=======================================================================
;;;;  We represent dependency types as integers for the sake of peformance
;;;;  and compactness.

(dv <dependency-type> <int>)

(df dependency-or (dep1|<dependency-type>
                   dep2|<dependency-type>
                   => <dependency-type>)
  (| dep1 dep2))

(df dependency-and (dep1|<dependency-type>
                    dep2|<dependency-type>
                    => <dependency-type>)
  (& dep1 dep2))

(dv $nul-dependency 0)
(dv $all-dependency-types 65535) ;; XXX - Should be all 1 bits.

(df dependency-nul? (dep|<dependency-type> => <log>)
  (== dep $nul-dependency))

(df dependency-includes-all? (main|<dependency-type>
                              values|<dependency-type>
                              => <log>)
  (== (dependency-and main values) values))

(df dependency-includes-any? (main|<dependency-type>
                              values|<dependency-type>
                              => <log>)
  (not (dependency-nul? (dependency-and main values))))

(export
  <dependency-type>
  dependency-or
  dependency-and
  $nul-dependency
  $all-dependency-types
  dependency-nul?
  dependency-includes-all?
  dependency-includes-any?)


;;;;=======================================================================
;;;;  Parse-Time Dependencies
;;;;=======================================================================
;;;;  If these are invalidated, we need to reparse the source code.

(dv $name-parse-dependency 1)         ; We translated a name to a binding.
(dv $expansion-parse-dependency 2)    ; We expanded a macro.

(dv $parse-dependencies
  (dependency-or $name-parse-dependency
                 $expansion-parse-dependency))

(export
  $name-parse-dependency
  $expansion-parse-dependency
  $parse-dependencies)


;;;;=======================================================================
;;;;  Optimization-Time Dependencies
;;;;=======================================================================
;;;;  If these are invalidated, we only need to re-optimize the source
;;;;  code.

(dv $value-optimization-dependency 4) ; We looked at the binding's value.

(dv $optimizaton-dependencies
  $value-optimization-dependency)

(export
  $value-optimization-dependency
  $optimizaton-dependencies)


;;;;=======================================================================
;;;;  Dependents & Dependables
;;;;=======================================================================

;;; May be depended-upon by a <dependent>.
(dc <dependable> (<any>))
  ;; A table keyed by <dependent>, containing <dependency-type> values.
  (dp dependents (<dependable> => <tab>) (fab <tab> 4))

;;; May depend upon a <dependable>.
(dc <dependent> (<any>))
  (dp! depends-on (<dependent> => <tab>) (fab <tab> 20))

;;; Log a dependency, together with any type information.
(df log-dependency (dependable|<dependable>
                    dependent|<dependent>
                    dtype|<dependency-type> => #f)
  (set (elt (depends-on dependent) dependable) #t)
  (def dep-table (dependents dependable))
  (def entry     (elt-or dep-table dependent #f))
  (set (elt dep-table dependent)
       (if entry
           (dependency-or entry dtype)
           dtype))
  #f)

;;; Look up a dependecy.  Primarily used for testing.
(df find-dependency (dependable|<dependable>
                     dependent|<dependent>
                     => (t? <dependency-type>))
  (elt-or (dependents dependable) dependent #f))

;;; Clobber a single dependent.  'dtype' says which kinds of dependencies
;;; have been invalidated.
(dg invalidate-dependent (dependent|<dependent>
                          dependable|<dependable>
                          dtype|<dependency-type>))

;;; Clobber all dependents of 'dependable' which rely on any of the
;;; bits in 'invalid-dtype'.
(df invalidate-dependents
    (dependable|<dependable> invalid-dtype|<dependency-type>)
  (do-keyed
   (fun (dependent dependendent-dtype)
     (def intersection (dependency-and invalid-dtype dependendent-dtype))
     (unless (dependency-nul? intersection)
       (invalidate-dependent dependent dependable intersection)))
   (dependents dependable)))

;;; Remove a dependent from everything it depends upon.
(df detach-dependent (dependent|<dependent>)
  (do-keyed
   (fun (dependable junk)
     (unless (del! (dependents dependable) dependent)
       (ast-error "Cannot remove %= from %=.\n" dependent dependable)))
   (depends-on dependent))
  (set (depends-on dependent) (fab <tab> 0)))

(dg ast-error (msg args|...))

(export
  ast-error
  <dependable>
  <dependent>
  log-dependency
  find-dependency
  invalidate-dependent
  invalidate-dependents
  detach-dependent)

APT Browse - Built by Thomas Orozco.