-- Copyright 1993-1998, by the Cecil Project
-- Department of Computer Science and Engineering, University of Washington
-- See the LICENSE file for license information.

-- word_vector is a fixed-sized vector of int words, stored in unboxed form
-- However, they are more or less useless, since one cannot manipulate 
-- untagged ints at the Cecil source level.

abstract object word_vector isa indexed[int];

method as_word_vector(v@:word_vector):word_vector { v }

let num_word_bits:int := 32;  -- maybe should be 16?

method length(v@:word_vector):int {
    prim
      rtl: "decl int len := num_elems_int v;
	    decl OOP lenOop := box_int len;
	    return lenOop;"
}

method fetch(v@:word_vector, index:int, if_absent:&():int):int {
    prim
      rtl: "if is_int_log index goto index_OK;
	    fatal \"can only index into word_vectors with ints\";
	label index_OK;
	    decl int i := unbox_int index;
            decl int len := num_elems_int v;
            if i <_unsigned_log len goto bounds_OK;
            decl OOP t5 := send eval(if_absent);
            return t5;
        label bounds_OK;
            decl wordInt t6 := v[i] wordInt;
	    decl OOP t7 := box_int t6;
            return t7;
" }


-- i_word_vector is a predefined immutable word_vector

extend i_word_vector isa word_vector, i_indexed[int];

method new_i_word_vector(size@:int, filler_oop@:int):i_word_vector {
    prim rtl: "
        decl int len := unbox_int size;
        if len >=_int_log 0 goto OK;
        len := 0;
      label OK;
        decl OOP v := new_i_word_vector len;
        if len =_int_log 0 goto exit;
	decl wordInt filler := unbox_int filler_oop;
        decl int i := 0;
      label l;
	v[i] wordInt := filler;
        i := i +_int 1;
  	if i <_int_log len goto l;
      label exit;
        return v;
" }

method new_i_word_vector_init(size@:int, cl:&(int):int):i_word_vector {
  prim rtl: "
        decl int len := unbox_int size;
        if len >=_int_log 0 goto OK;
	len := 0;
      label OK;
        decl OOP v := new_i_word_vector len;
        if len =_int_log 0 goto exit;
        decl int i := 0;
      label l;
        decl OOP tagged_i := box_int i;
	decl OOP elem_oop := send eval(cl, tagged_i);
	if is_int_log elem_oop goto elem_OK;
	fatal \"can only store ints in word_vectors\";
      label elem_OK;
	decl wordInt elem := unbox_int elem_oop;
	v[i] wordInt := elem;
	i := i +_int 1;
	if i <_int_log len goto l;
      label exit;
        return v;
" }

method new_i_word_vector_init_from(c@:indexed[`T],
				cl:&(T):int):i_word_vector (** inline **) {
    new_i_word_vector_init(c.length, &(i:int){ eval(cl, c!i) }) }

method new_i_word_vector_init_from(c@:ordered_collection[`T],
				cl:&(T):int):i_word_vector {
    let s:stream[T] := view_stream(c);
    new_i_word_vector_init(c.length, &(i:int){ eval(cl, s.next) }) }

method as_i_word_vector(v@:i_word_vector):i_word_vector { v }


-- copying behavior

method copy(v@:i_word_vector):i_word_vector {
    new_i_word_vector_init_from(v, &(x:int){ x }) }


-- printing behavior

method collection_name(@:i_word_vector):string { "i_word_vector" }



-- m_word_vector is a predefined mutable word_vector

extend m_word_vector isa word_vector, m_indexed[int];

-- indexing behavior

method store(v@:m_word_vector, index:int, x:int, if_absent:&():void):void {
    prim
      rtl: "if is_int_log index goto index_OK;
	    fatal \"can only index into word_vectors with ints\";
	label index_OK;
	    if is_int_log x goto x_OK;
	    fatal \"can only store ints in word_vectors\";
	label x_OK;
            decl int i := unbox_int index;
            decl int len := num_elems_int v;
            if i <_unsigned_log len goto bounds_OK;
            decl OOP t5 := send eval(if_absent);
            return void;
        label bounds_OK;
	    decl wordInt t6 := unbox_int x;
            v[i] wordInt := t6;
            return void;
" }


-- m_word_vector creation behavior

method new_m_word_vector(size@:int):m_word_vector {
    new_m_word_vector(size, 0) }

method new_m_word_vector(size@:int, filler_oop@:int):m_word_vector {
    prim rtl: "
        decl int len := unbox_int size;
        if len >=_int_log 0 goto OK;
	len := 0;
      label OK;
        decl OOP v := new_m_word_vector len;
        if len =_int_log 0 goto exit;
	decl wordInt filler := unbox_int filler_oop;
        decl int i := 0;
      label l;
	v[i] wordInt := filler;
        i := i +_int 1;
  	if i <_int_log len goto l;
      label exit;
        return v;
" }

method new_m_word_vector_init(size@:int, cl:&(int):int):m_word_vector {
  prim rtl: "
        decl int len := unbox_int size;
        if len >=_int_log 0 goto OK;
	len := 0;
      label OK;
        decl OOP v := new_m_word_vector len;
        if len =_int_log 0 goto exit;
        decl int i := 0;
      label l;
        decl OOP tagged_i := box_int i;
	decl OOP elem_oop := send eval(cl, tagged_i);
	if is_int_log elem_oop goto elem_OK;
	fatal \"can only store ints in word_vectors\";
      label elem_OK;
	decl wordInt elem := unbox_int elem_oop;
	v[i] wordInt := elem;
	i := i +_int 1;
	if i <_int_log len goto l;
      label exit;
        return v;
" }

method new_m_word_vector_init_from(c@:indexed[`T], cl:&(T):int
				   ):m_word_vector (** inline **) {
    new_m_word_vector_init(c.length, &(i:int){ eval(cl, c!i) }) }

method new_m_word_vector_init_from(c@:ordered_collection[`T],
				    cl:&(T):int):m_word_vector {
    let s:stream[T] := view_stream(c);
    new_m_word_vector_init(c.length, &(i:int){ eval(cl, s.next) }) }

method as_m_word_vector(v@:m_word_vector):m_word_vector { v }


-- copying behavior

method copy(v@:m_word_vector):m_word_vector {
    new_m_word_vector_init_from(v, &(x:int){ x }) }


-- printing behavior

method collection_name(@:m_word_vector):string { "m_word_vector" }