Пример #1
0
def getNineType(theType):
    from ast.external import ExternalType
    from ast.vartypes import Type

    if isinstance(theType, Type):
        return theType
    elif isinstance(theType, type):
        return ExternalType.getNineType(clr.GetClrType(theType))
    elif isinstance(theType, basestring):
        return ExternalType.getNineType(System.Type.GetType(theType))

    return ExternalType.getNineType(theType)
Пример #2
0
def getNineType(theType):
    from ast.external import ExternalType
    from ast.vartypes import Type

    if isinstance(theType, CLRMeta):
        theType = typeToType(theType)

    # all classes from the CLR namespace are .NET classes.
    if theType.__module__.startswith('CLR'):
        return ExternalType.getNineType(theType)
    elif isinstance(theType, basestring):
        return ExternalType.getNineType(System.Type.GetType(theType))
    elif isinstance(theType, Type):
        return theType
    else:
        assert False, (theType, type(theType))
Пример #3
0
    def __init__(self, position, arrayType, arity):
        self.position = position
        self.arrayType = arrayType
        self.arity = arity
        self.__builder = None

        from ast.external import ExternalType
        from CLR import System
        self.bases = [ExternalType.getNineType(System.Array)]
Пример #4
0
    def semantic(self, scope):
        from ast import vartypes
        from nine import error, util
        import CLR

        expr = self.expr.semantic(scope)

        from ast.external import ExternalType

        # if not util.getNineType(System.Exception).isParentClass(expr.getType()):
        if not ExternalType.getNineType(util.typeToType(CLR.System.Exception)).isParentClass(expr.getType()):
            raise error.SyntaxError(
                self.position,
                "You can only throw object instances which inherit System.Exception, not %r" % expr.getType(),
            )

        return RaiseStatement(self.position, expr)
Пример #5
0
    def fixPrimitives(self):
        # HACK: make the primitive types match up. (disregard this, as it is wholly insane)
        import System
        from nine.util import typeToType as t2t
        from ast.external import ExternalType
        from ast import vartypes

        vartypes.IntType = ExternalType.getNineType(t2t(System.Int32))
        vartypes.FloatType = ExternalType.getNineType(t2t(System.Single))
        vartypes.DoubleType = ExternalType.getNineType(t2t(System.Double))
        vartypes.CharType = ExternalType.getNineType(t2t(System.Char))
        vartypes.StringType = ExternalType.getNineType(t2t(System.String))
        vartypes.BooleanType = ExternalType.getNineType(t2t(System.Boolean))
        vartypes.VoidType = ExternalType.getNineType(t2t(System.Void))

        vartypes.PrimitiveTypes = {
            'int' : vartypes.IntType,
            'float' : vartypes.FloatType,
            'double' : vartypes.DoubleType,
            'boolean' : vartypes.BooleanType,
            'char' : vartypes.CharType,
            'string' : vartypes.StringType,
            'void' : vartypes.VoidType
        }
Пример #6
0
    def fixPrimitives(self):
        # HACK: make the primitive types match up. (disregard this, as it is wholly insane)
        import CLR
        from nine.util import typeToType as t2t
        from ast.external import ExternalType
        from ast import vartypes

        vartypes.IntType = ExternalType.getNineType(t2t(CLR.System.Int32))
        vartypes.FloatType = ExternalType.getNineType(t2t(CLR.System.Single))
        vartypes.CharType = ExternalType.getNineType(t2t(CLR.System.Char))
        vartypes.StringType = ExternalType.getNineType(t2t(CLR.System.String))
        vartypes.BooleanType = ExternalType.getNineType(t2t(CLR.System.Boolean))
        vartypes.VoidType = ExternalType.getNineType(t2t(CLR.System.Void))

        vartypes.PrimitiveTypes = {
            "int": vartypes.IntType,
            "float": vartypes.FloatType,
            "boolean": vartypes.BooleanType,
            "char": vartypes.CharType,
            "string": vartypes.StringType,
            "void": vartypes.VoidType,
        }
Пример #7
0
    def _scanAssembly(self, globalNs, assemblyName):
        from ast.namespace import Namespace
        from ast.vartypes import Type
        from ast.external import ExternalType

        import System
        from System import Reflection
        from System.Reflection import Assembly

        #assembly = Assembly.LoadWithPartialName(assemblyName)
        assembly = self._loadAssembly(assemblyName)
        if assembly is None:
            raise Exception, 'Unable to load assembly %s' % assemblyName

        namespaces = globalNs

        def getNs(name, curNs=None):
            ns = curNs or globalNs

            if len(name) == 0:
                return curNs
            else:
                n = name[0]

                if n not in ns.symbols:
                    ns.symbols[n] = Namespace(n)

                return getNs(name[1:], ns.symbols[n])

        '''Absurdly complex, given how little it does. :P

        For each type whose full name does not begin with something freaky like $
        create namespace instances and a Type instance within the whole heirarchy
        to correspond with all the types in the assembly.

        For instance, storing the System.Console class requires creating or reopening
        of the System namespace, in which the Console Type gets poured.

        FIXME: nested types are not correctly handled at all.
        '''
        for type in assembly.GetTypes():
            if not type.Name[0].isalpha() and type.Name[0] != '_':
                continue

            if type.IsNestedPublic:
                outerName = type.FullName
                outerName, innerName = type.FullName.split('+', 1)

                outerName = outerName.split('.')
                outerNs = getNs(outerName[:-1])
                assert outerName[-1] in outerNs.symbols, "Internal badness: have to process a nested class before we've processed the enclosing class."

                outerClass = outerNs.symbols[outerName[-1]]
                outerClass.symbols[type.Name] = ExternalType.getNineType(type)

            else:
                if type.Namespace is None:
                    ns = globalNs
                else:
                    ns = getNs(type.Namespace.split('.'))

                ns.symbols[type.Name] = ExternalType.getNineType(type)

        return namespaces