def METHOD_NAME(snowline):
    """
    Compute the table with snowline height for each day of the year.
    @param snowline: Snowline definition.
    @type  snowline: L{Snowline}
    @return: Table of 12*32 entries with snowline heights.
    @rtype:  C{str}
    """
    day_table = [None] * 365  # Height at each day, starting at day 0
    for dh in snowline.date_heights:
        doy = dh.name.reduce()
        if not isinstance(doy, expression.ConstantNumeric):
            raise generic.ScriptError("Day of year is not a compile-time constant", doy.pos)
        if doy.value < 1 or doy.value > 365:
            raise generic.ScriptError("Day of the year must be between 1 and 365", doy.pos)
        height = dh.value.reduce()
        if isinstance(height, expression.ConstantNumeric) and height.value < 0:
            raise generic.ScriptError("Height must be at least 0", height.pos)
        if dh.unit is None:
            if isinstance(height, expression.ConstantNumeric) and height.value > 255:
                raise generic.ScriptError("Height must be at most 255", height.pos)
        else:
            unit = dh.unit
            if unit.type != "snowline":
                raise generic.ScriptError('Expected a snowline percentage ("snow%")', height.pos)
            if isinstance(height, expression.ConstantNumeric) and height.value > 100:
                raise generic.ScriptError("Height must be at most 100 snow%", height.pos)
            mul, div = unit.convert, 1
            if isinstance(mul, tuple):
                mul, div = mul
            # Factor out common factors
            gcd = generic.greatest_common_divisor(mul, div)
            mul //= gcd
            div //= gcd
            if isinstance(height, (expression.ConstantNumeric, expression.ConstantFloat)):
                # Even if mul == div == 1, we have to round floats and adjust value
                height = expression.ConstantNumeric(int(float(height.value) * mul / div + 0.5), height.pos)
            elif mul != div:
                # Compute (value * mul + div/2) / div
                height = nmlop.MUL(height, mul)
                height = nmlop.ADD(height, int(div / 2))
                height = nmlop.DIV(height, div)
        # For 'linear' snow-line, only accept integer constants.
        if snowline.type != "equal" and not isinstance(height, expression.ConstantNumeric):
            raise generic.ScriptError("Height is not a compile-time constant", height.pos)
        day_table[doy.value - 1] = height
    # Find first specified point.
    start = 0
    while start < 365 and day_table[start] is None:
        start = start + 1
    if start == 365:
        raise generic.ScriptError("No heights given for the snowline table", snowline.pos)
    first_point = start
    while True:
        # Find second point from start
        end = start + 1
        if end == 365:
            end = 0
        while end != first_point and day_table[end] is None:
            end = end + 1
            if end == 365:
                end = 0
        # Fill the days between start and end (exclusive both border values)
        startvalue = day_table[start]
        endvalue = day_table[end]
        unwrapped_end = end
        if end < start:
            unwrapped_end += 365
        if snowline.type == "equal":
            for day in range(start + 1, unwrapped_end):
                if day >= 365:
                    day -= 365
                day_table[day] = startvalue
        else:
            assert snowline.type == "linear"
            if start != end:
                dhd = float(endvalue.value - startvalue.value) / float(unwrapped_end - start)
            else:
                assert startvalue.value == endvalue.value
                dhd = 0
            for day in range(start + 1, unwrapped_end):
                uday = day
                if uday >= 365:
                    uday -= 365
                height = startvalue.value + int(round(dhd * (day - start)))
                day_table[uday] = expression.ConstantNumeric(height)
        if end == first_point:  # All days done
            break
        start = end
    table = [None] * (12 * 32)
    for dy in range(365):
        today = datetime.date.fromordinal(dy + 1)
        if day_table[dy]:
            expr = day_table[dy].reduce()
        else:
            expr = None
        table[(today.month - 1) * 32 + today.day - 1] = expr
    for idx, d in enumerate(table):
        if d is None:
            table[idx] = table[idx - 1]
    # Second loop is needed because we need make sure the first item is also set.
    for idx, d in enumerate(table):
        if d is None:
            table[idx] = table[idx - 1]
    return table