module stack(out_stack, in_stack);
    output [7:0] out_stack;
    input [7:0] in_stack;
    wire st0 [7:0],
    st1 [7:0],
    st2 [7:0],
    st3 [7:0],
    st4 [7:0],
    st5 [7:0],
    st6 [7:0],
    st7 [7:0];
    wire wr;
    
        
    always in_stack
        
    if (wr)
        st7 = st6;
        st6 = st5;
        st5 = st4;
        st4 = st3;
        st3 = st2;
        st2 = st1;
        st1 = st0;
        st0 = in_stack;
        
endmodule

module stack(output [7:0] out_stack, input [7:0] in_stack, input wr);
    reg [7:0] st0,  st1,  st2,  st3, st4, st5, st6,  st7;
            
    always @(posedge wr) begin
        st7 <= st6;
        st6 <= st5;
        st5 <= st4;
        st4 <= st3;
        st3 <= st2;
        st2 <= st1;
        st1 <= st0;
        st0 <= in_stack;
     end



    assign out_stack = st7;


endmodule

module stack #(
                                parameter word_width=8,
                                parameter stack_depth=16
                            )
                        (
                            input bit clk,
                            input bit reset_n,
                            input bit stack_pop,
                            input bit stack_push,
                            output bit stack_full,
                            output bit stack_empty,
                            input bit [word_width-1:0] data_in,
                            output bit [word_width-1:0] data_out
                        );

function int log2(input int number);
    int temp;
     temp  = 1;
     log2 = 0;
     while (temp<number)
       begin
          log2 = log2+1;
          temp  = temp*2;
       end
endfunction

bit [log2(stack_depth)-1:0]stack_pointer;
bit [word_width-1:0]stack[stack_depth];


    always_ff @(posedge clk)
        begin
            if (reset_n==1'b0)
                begin
                    stack_pointer<=0;
                    stack_empty<=1'b1;
                    stack_full<=1'b0;
                end
            else
                begin
                    if(stack_pop==1'b1)
                        begin
                            if (stack_empty!=1'b1)stack_pointer<=stack_pointer-1;
                            data_out<=stack[stack_pointer-1];
                            if (stack_pointer==1)
                                stack_empty<=1'b1;
                            stack_full<=1'b0;
                        end
                    if(stack_push==1'b1)
                        begin
                            if (stack_full!=1'b1)
                                begin
                                    stack_pointer<=stack_pointer+1;
                                    stack[stack_pointer]<=data_in;
                                    data_out<=data_in;
                                end
                            if (stack_pointer==stack_depth-2)
                                stack_full<=1'b1;
                            stack_empty<=1'b0;
                        end
                end
        end

endmodule

class stack #(type Element_Type = int);
    local Element_Type storage[$];
    local semaphore read_semaphore;
    local semaphore write_semaphore;

    function new(int size_limit = 0);
      read_semaphore = new(0);
      if (size_limit > 0)
        write_semaphore = new(size_limit);
      else if (size_limit < 0)
        $display("Warning: Negative stack size limit was detected as a constructor parameter. Unbounded stack will be constructed");
    endfunction

    function int num();
      return storage.size();
    endfunction

    task put(Element_Type element);
      if (write_semaphore!=null)
        write_semaphore.get(1);
      storage.push_front(element);
      read_semaphore.put(1);
    endtask

    function int try_put(Element_Type element);
      if (write_semaphore==null || write_semaphore.try_get(1) > 0) begin
        storage.push_front(element);
        read_semaphore.put(1);
        return 1;
      end
      return 0;
    endfunction

    task get(output /*ref*/ Element_Type element);
      read_semaphore.get(1);
      element = storage.pop_front();
      if (write_semaphore!=null)
        write_semaphore.put(1);
    endtask

    function int try_get(output /*ref*/ Element_Type element);
      if (read_semaphore.try_get(1) > 0) begin
        element = storage.pop_front();
        if (write_semaphore!=null)
          write_semaphore.put(1);
        return 1;
      end
      return 0;
    endfunction

    task peek(output /*ref*/ Element_Type element);
      read_semaphore.get(1);
      element = storage[0];
      read_semaphore.put(1);
    endtask

    function int try_peek(output /*ref*/ Element_Type element);
      if (read_semaphore.try_get(1) > 0) begin
        element = storage[0];
        read_semaphore.put(1);
        return 1;
      end
      return 0;
    endfunction
endclass