Home - sourcepawn2 - file revision - src/TypeManager.cpp@e3974e7360e9 Mercurial
summary | shortlog | changelog | graph | tags | branches | files | changeset | file | latest | revisions | annotate | diff | raw | help
src/TypeManager.cpp
author David Anderson <danderson@mozilla.com>
Wed Jul 25 01:30:33 2012 -0700 (2012-07-25)
changeset 92 e3974e7360e9
parent 91 5f4402180204
child 140 aae2a2562684
permissions -rw-r--r--
Add GCC/Linux support. 
     1 /* vim: set ts=4 sw=4 tw=99 et:
     2  *
     3  * Copyright (C) 2012 David Anderson
     4  *
     5  * This file is part of JITCraft.
     6  *
     7  * JITCraft is free software: you can redistribute it and/or modify it under
     8  * the terms of the GNU General Public License as published by the Free
     9  * Software Foundation, either version 3 of the License, or (at your option)
    10  * any later version.
    11  * 
    12  * Foobar is distributed in the hope that it will be useful, but WITHOUT ANY
    13  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
    14  * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
    15  *
    16  * You should have received a copy of the GNU General Public License along with
    17  * JITCraft. If not, see http://www.gnu.org/licenses/.
    18  */
    19 #include <string.h>
    20 #include "Types.h"
    21 #include "TypeManager.h"
    22 #include "Zone.h"
    23 #include "Strings.h"
    24 #include "Spaces-inl.h"
    25 #include "Heap-inl.h"
    26 
    27 using namespace ke;
    28 
    29 
    30 TypeManager::TypeManager(Zone *zone)
    31   : zone_(zone)
    32 {
    33 }
    34 
    35 bool
    36 TypeManager::initialize()
    37 {
    38     voidType_ = Type::NewVoid(zone_);
    39     if (!voidType_)
    40         return false;
    41 
    42     Local<String> floatTag(zone_, zone_->makeSymbol("Float"));
    43     if (!floatTag)
    44         return false;
    45 
    46     Local<String> stringTag(zone_, zone_->makeSymbol("String"));
    47     if (!stringTag)
    48         return false;
    49 
    50     Local<String> nullTag(zone_);
    51 
    52     if ((primitiveTypes_[PrimitiveType_Int32] = Type::NewPrimitive(zone_, nullTag)) == NULL)
    53         return false;
    54     if ((primitiveTypes_[PrimitiveType_Float] = Type::NewPrimitive(zone_, floatTag)) == NULL)
    55         return false;
    56     if ((primitiveTypes_[PrimitiveType_Native] = Type::NewPrimitive(zone_, PrimitiveType_Native)) == NULL)
    57         return false;
    58     if ((primitiveTypes_[PrimitiveType_Char] = Type::NewPrimitive(zone_, stringTag)) == NULL)
    59         return false;
    60 
    61     Local<Type> type(zone_);
    62     for (unsigned i = 0; i < PrimitiveTypes_Total; i++) {
    63         type = primitiveTypes_[i];
    64         if ((referenceTypes_[i] = Type::NewReference(zone_, type, false)) == NULL)
    65             return false;
    66     }
    67 
    68     return true;
    69 }
    70 
    71 Type *
    72 TypeManager::getPrimitiveForTag(Handle<String> tag)
    73 {
    74     if (!tag)
    75         return getPrimitive(PrimitiveType_Int32);
    76     if (strcmp(tag->chars(), "Float") == 0)
    77         return getPrimitive(PrimitiveType_Float);
    78     if (strcmp(tag->chars(), "String") == 0)
    79         return getPrimitive(PrimitiveType_Char);
    80     return NULL;
    81 }
    82 
    83 Type *
    84 TypeManager::unsafeArray(Handle<Type> contained, int elements, bool isConst)
    85 {
    86     // :TODO: cache this.
    87     return Type::NewArray(zone_, contained, elements, isConst);
    88 }
    89 
    90 Type *
    91 TypeManager::getReference(Handle<Type> type, bool isConst)
    92 {
    93     if (!isConst && (type->isFloat() || (type->isInt32() && !type->tag())))
    94         return referenceTypes_[type->primitive()];
    95 
    96     // :TODO: cache this.
    97     return Type::NewReference(zone_, type, isConst);
    98 }
    99 
   100 Type *
   101 TypeManager::newFunction(Handle<Type> returnType, Handle<FixedArray> args)
   102 {
   103     // :TODO: cache this.
   104     return Type::NewFunction(zone_, returnType, args);
   105 }
   106 
   107 Type *
   108 TypeManager::newNative(Handle<Type> returnType, Handle<FixedArray> args, bool variadic)
   109 {
   110     // :TODO: cache this.
   111     return Type::NewNative(zone_, returnType, args, variadic);
   112 }
   113 
   114 void
   115 TypeManager::accept(VirtualObjectVisitor *visitor)
   116 {
   117     visitor->visit(voidType_.address());
   118     for (unsigned i = 0; i < PrimitiveTypes_Total; i++) {
   119         visitor->visit(primitiveTypes_[i].address());
   120         visitor->visit(referenceTypes_[i].address());
   121     }
   122 }
sourcepawn2
Feed