home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / oper_sys / emerald / emrldsys.lha / Language / Compiler / Builtins / phoney_Array.m < prev    next >
Encoding:
Text File  |  1990-08-16  |  5.8 KB  |  165 lines
  1. % 
  2. % @(#)phoney_Array.m    1.1  3/6/87
  3. %
  4. export _ArrayObject to "Builtins"
  5.  
  6. const _ArrayObject == 
  7.   immutable object _ArrayObject
  8.     export of
  9.     function of [ElementType : AbstractType] -> [result : NAT]
  10.       where
  11.     NAT ==    immutable type NAT
  12.           operation empty -> [NA]
  13. %          operation literal [Vector.of[ElementType]] -> [NA]
  14.           operation create[Integer] -> [NA]
  15.           function getSignature -> [Signature]
  16.         end NAT
  17.     NA ==    type NA
  18.           function  getElement [Integer] -> [ElementType]
  19.             % get the element indexed by index, failing if index 
  20.             % out of range.
  21.           operation setElement [Integer, ElementType]
  22.             % set the element, failing if index out of range
  23.           function  upperbound -> [Integer]
  24.             % return the highest valid index, ub.
  25.           function  lowerbound -> [Integer]
  26.             % return the lowest valid index, lb.
  27.           function  getSlice [Integer, Integer] -> [NA]
  28.             % return a new array, a, with lower bound lb, and 
  29.             % upper bound ub, such that for lb <= i <= ub:
  30.             %     self.getElement[i] == a.getElement[i]
  31.             % fail if lb or ub is out of range.
  32.           operation setSlice [Integer, Integer, NA]
  33.             % set the elements indexed by i for lb <= i <= ub, so 
  34.             % that for each such i:
  35.             %     self.getElement[i] == a.getElement[i]
  36.             % fail if lb or ub is out of range.
  37.           operation slideTo [Integer]
  38.             % change the valid indicies for self.  Assuming 
  39.             % the old indicies ranged from lb to ub, the new 
  40.             % indicies will range from i to i + ub - lb
  41.           operation addUpper [ElementType]
  42.             % extend the set of valid indicies, changing ub to 
  43.             % ub + 1, and setting the element indexed by the new
  44.             % ub to be e.
  45.           operation removeUpper -> [ElementType]
  46.             % return the element indexed by ub, after contracting 
  47.             % the set of valid indicies to lb <= i <= ub - 1.
  48.           operation addLower [ElementType]
  49.             % extend the set of valid indicies, changing lb to 
  50.             % lb - 1, and setting
  51.             % the element indexed by the new lb to be e.
  52.           operation removeLower -> [ElementType]
  53.             % return the element indexed by lb, after contracting 
  54.             % the set of valid indicies to lb + 1 <= i <= ub.
  55.           function  empty -> [Boolean]
  56.             % -> true if lb == ub + 1, which is true initially,
  57.             % since initially lb = 1, and ub = 0.
  58.           operation catenate [a : NA] -> [r : NA]
  59.             % extend the range of valid indicies from lb .. ub to 
  60.             % lb .. ub + a.length.  Set these new elements to refer
  61.             % to the elements of a so that for a.lb <= i <= a.ub, 
  62.             % where oub is the old value of self.ub:
  63.             %     a.getElement[i] == self.getElement[oub + i - 1]
  64.         end NA
  65.     ElementType *> type T end T
  66.       end where
  67.  
  68.       result <- 
  69.     immutable object aNAT
  70.       export empty, create, getSignature
  71.  
  72.       function getSignature -> [result : Signature]
  73.         result <- NA
  74.       end getSignature
  75.  
  76.       operation create[length : Integer] -> [result : NA]
  77.         result <-
  78.           object aNA
  79.         export getElement, setElement, upperbound, lowerbound, getSlice, setSlice,
  80.                slideTo, addUpper, removeUpper, addLower,
  81.                removeLower, empty, catenate
  82.  
  83.         var lb : Integer
  84.         var ub : Integer
  85. %        var vec: Vector.of[ElementType]
  86.  
  87.         function  getElement [index : Integer] -> [result : ElementType]
  88.           % get the element indexed by index, failing if index 
  89.           % out of range.
  90.           primitive 002 [result] <- [index]
  91.         end getElement
  92.         operation setElement [i : Integer, r : ElementType]
  93.           % set the element, failing if index out of range
  94.           primitive 102 [] <- [i, r]
  95.         end setElement
  96.         function  upperbound -> [r : Integer]
  97.           % return the highest valid index, ub.
  98.           primitive 202 [r] <- []
  99.         end upperbound
  100.         function  lowerbound -> [r : Integer]
  101.           % return the lowest valid index, always 1.
  102.           primitive 302 [r] <- []
  103.         end lowerbound
  104.         function  getSlice [i1 : Integer, i2 : Integer] -> [r : NA]
  105.           % return a new Vector, a, with lower bound lb, and 
  106.           % upper bound ub, such that for lb <= i <= ub:
  107.           %     self.getElement[i] == a.getElement[i]
  108.           % fail if lb or ub is out of range.
  109.           primitive 402 [r] <- [i1, i2]
  110.         end getSlice
  111.         operation setSlice [i1 : Integer, i2 : Integer, s : NA]
  112.           % set the elements indexed by i for lb <= i <= ub, so 
  113.           % that for each such i:
  114.           %     self.getElement[i] == a.getElement[i]
  115.           % fail if lb or ub is out of range.
  116.           primitive 502 [] <- [i1, i2, s]
  117.         end setSlice
  118.         operation slideTo [i : Integer]
  119.           % change the valid indicies for self.  Assuming 
  120.           % the old indicies ranged from lb to ub, the new 
  121.           % indicies will range from i to i + ub - lb
  122.           primitive 602 [] <- [i]
  123.         end slideTo
  124.         operation addUpper [e : ElementType]
  125.           % extend the set of valid indicies, changing ub to 
  126.           % ub + 1, and setting the element indexed by the new
  127.           % ub to be e.
  128.           primitive 702 [] <- [e]
  129.         end addUpper
  130.         operation removeUpper -> [r : ElementType]
  131.           % return the element indexed by ub, after contracting 
  132.           % the set of valid indicies to lb <= i <= ub - 1.
  133.           primitive 802 [] <- [r]
  134.         end removeUpper
  135.         operation addLower [e : ElementType]
  136.           % extend the set of valid indicies, changing lb to 
  137.           % lb - 1, and setting
  138.           % the element indexed by the new lb to be e.
  139.           primitive 902 [] <- [e]
  140.         end addLower
  141.         operation removeLower -> [r : ElementType]
  142.           % return the element indexed by lb, after contracting 
  143.           % the set of valid indicies to lb + 1 <= i <= ub.
  144.           primitive 1002 [r] <- []
  145.         end removeLower
  146.         function  empty -> [r : Boolean]
  147.           % -> true if lb == ub + 1, which is true initially,
  148.           % since initially lb = 1, and ub = 0.
  149.           primitive 1102 [r] <- []
  150.         end empty
  151.         operation catenate [a : NA] -> [r : NA]
  152.           % return a new vector the result of catenating the 
  153.           % elements of a to self
  154.           primitive 1202 [r] <- [a]
  155.         end catenate
  156.           end aNA
  157.       end create
  158.       operation empty -> [result : NA]
  159.         result <- aNAT.create[10]
  160.       end empty
  161.     end aNAT
  162.     end of
  163.  
  164.   end _ArrayObject
  165.