Vector Part select addressing
=============================

    - Variable part selects cannot have 
      variable widths, i.e variable part selects
      can only vary the starting point or index
      but the width of the part select should be 
      statically evaluatable ( it should either
      be locally or globally static )
      eg: literal number, constants, call to
      a constant function.

    - Out of range bits of a part select cannot be
      supported.

    - Constant part selects would be fully supported.

    - Vector part selects which appear on rhs of an
      assignment can be fully supported.

    - For variable part selects the following should
      be considered:
      - Can it appear on the lhs of an assignemnt ?
        possibly this can be supported in the same way
        as variable bit indices are supported i.e using
        a decoder to find out the actual range.
        eg: // b is [0:2]
            always @(clk) begin
                b[i +: 1] = a;
            end

            This can be synthesized to :
            DECOD #(1,3) decod(.out(n_wire), .in(i)) // n_wire is [0:2]
            .... ckt. to calculate the proper range so that
            proper bits of the output o_wire are 1.
            as the range of vector b and the width of the
            variable part select. output of ckt [0:2]o_wire
            
            LATCH LD0(.Q(b[0]), .D(a), .En(o_wire[0]));
            LATCH LD1(.Q(b[1]), .D(a), .En(o_wire[1]));
            LATCH LD2(.Q(b[2]), .D(a), .En(o_wire[2]));
            
      - What happens when it appears in a condition like:
        if(big_vect[i +: 8])
            a = b;
        ( where 'i' is a variable and can possibly take any
        value )
        OR
        in any continous assignment 
        OR
        in expression (like as function/task arguments)
        
        This can also be supported by the above logic.


ReEntrant Tasks & Functions
===========================
      - Reentrant tasks & functions can be supported if the 
        number of recursions can be determined exactly during
        elaboration.
        This should hold valid for both normal as well
        as automatic tasks/functions.

	  - Points to be considered: 
	    - What happens if the recusrion is indirect ?
		  eg: funcA -> funcB -> funcC -> funcA
		  As long as the elaboration is succesful this shouldn't
		  pose any problems.