""" A simple hack to start thinking about a better way to handle
specification of typecodes.

TODO:
    The code_table should proably be cached somehow
    Float/Complex needs to have precision and range specifiers
"""

from numarray import zeros
import string

# dvhart - added the character 'u' for the UnisgnedInteger 'list of codes' ?
# typecodes = {'Integer':'1sil', 'UnsignedInteger':'Bbwu', 'Float':'fd', 'Complex':'FD'}
from numarray.numerictypes import typecodes

def _get_precisions(typecodes):
    lst = []
    for t in typecodes:
        lst.append( (zeros( (1,), t ).itemsize()*8, t) )
    return lst

def _fill_table(typecodes, table={}):
    for key, value in typecodes.items():
        table[key] = _get_precisions(value)
    return table

_code_table = _fill_table(typecodes)

class PrecisionError(Exception):
    pass

def _lookup(table, key, required_bits):
    lst = table[key]
    for bits, typecode in lst:
        if bits >= required_bits:
            return typecode
    raise PrecisionError, key+" of "+str(required_bits)+" bits not available on this system"

# Character = 'c'

try:
    UnsignedInt8 = _lookup(_code_table, "UnsignedInteger", 8)
    UInt8 = UnsignedInt8
except(PrecisionError):
    pass
try:
    UnsignedInt16 = _lookup(_code_table, "UnsignedInteger", 16)
    UInt16 = UnsignedInt16
except(PrecisionError):
    pass
try:
    UnsignedInt32 = _lookup(_code_table, "UnsignedInteger", 32)
    UInt32 = UnsignedInt32
except(PrecisionError):
    pass
try:
    UnsignedInt64 = _lookup(_code_table, "UnsignedInteger", 64)
    UInt64 = UnsignedInt64
except(PrecisionError):
    pass
try:
    UnsignedInt128 = _lookup(_code_table, "UnsignedInteger", 128)
    UInt128 = UnsignedInt128
except(PrecisionError):
    pass
UnsignedInteger = 'u'
UInt = UnsignedInteger


try: Int0 = _lookup(_code_table, 'Integer', 0)
except(PrecisionError): pass
try: Int8 = _lookup(_code_table, 'Integer', 8)
except(PrecisionError): pass
try: Int16 = _lookup(_code_table, 'Integer', 16)
except(PrecisionError): pass
try: Int32 = _lookup(_code_table, 'Integer', 32)
except(PrecisionError): pass
try: Int64 = _lookup(_code_table, 'Integer', 64)
except(PrecisionError): pass
try: Int128 = _lookup(_code_table, 'Integer', 128)
except(PrecisionError): pass
Int = 'l'

try: Float0 = _lookup(_code_table, 'Float', 0)
except(PrecisionError): pass
try: Float8 = _lookup(_code_table, 'Float', 8)
except(PrecisionError): pass
try: Float16 = _lookup(_code_table, 'Float', 16)
except(PrecisionError): pass
try: Float32 = _lookup(_code_table, 'Float', 32)
except(PrecisionError): pass
try: Float64 = _lookup(_code_table, 'Float', 64)
except(PrecisionError): pass
try: Float128 = _lookup(_code_table, 'Float', 128)
except(PrecisionError): pass
Float = 'd'

try: Complex0 = _lookup(_code_table, 'Complex', 0)
except(PrecisionError): pass
try: Complex8 = _lookup(_code_table, 'Complex', 16)
except(PrecisionError): pass
try: Complex16 = _lookup(_code_table, 'Complex', 32)
except(PrecisionError): pass
try: Complex32 = _lookup(_code_table, 'Complex', 64)
except(PrecisionError): pass
try: Complex64 = _lookup(_code_table, 'Complex', 128)
except(PrecisionError): pass
try: Complex128 = _lookup(_code_table, 'Complex', 256)
except(PrecisionError): pass
Complex = 'D'

# PyObject = 'O'
