Home - sourcepawn2 - file revision - src/TypeManager.cpp@a000bafece09 Mercurial
summary | shortlog | changelog | graph | tags | branches | files | changeset | file | latest | revisions | annotate | diff | raw | help
src/TypeManager.cpp
author David Anderson <dvander@alliedmods.net>
Mon Jul 30 12:13:22 2012 -0700 (2012-07-30)
changeset 142 a000bafece09
parent 140 aae2a2562684
child 143 393f1b8ac8c3
permissions -rw-r--r--
Implement re-tag unary expression. 
     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 || strcmp(tag->chars(), "_") == 0)
    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 
    81     // :TODO: cache this.
    82     return Type::NewPrimitive(zone_, tag);
    83 }
    84 
    85 Type *
    86 TypeManager::unsafeArray(Handle<Type> contained, int elements, bool isConst)
    87 {
    88     // :TODO: cache this.
    89     return Type::NewArray(zone_, contained, elements, isConst);
    90 }
    91 
    92 Type *
    93 TypeManager::getReference(Handle<Type> type, bool isConst)
    94 {
    95     if (!isConst && (type->isFloat() || (type->isInt32() && !type->tag())))
    96         return referenceTypes_[type->primitive()];
    97 
    98     // :TODO: cache this.
    99     return Type::NewReference(zone_, type, isConst);
   100 }
   101 
   102 Type *
   103 TypeManager::newFunction(Handle<Type> returnType, Handle<FixedArray> args)
   104 {
   105     // :TODO: cache this.
   106     return Type::NewFunction(zone_, returnType, args);
   107 }
   108 
   109 Type *
   110 TypeManager::newNative(Handle<Type> returnType, Handle<FixedArray> args, bool variadic)
   111 {
   112     // :TODO: cache this.
   113     return Type::NewNative(zone_, returnType, args, variadic);
   114 }
   115 
   116 void
   117 TypeManager::accept(VirtualObjectVisitor *visitor)
   118 {
   119     visitor->visit(voidType_.address());
   120     for (unsigned i = 0; i < PrimitiveTypes_Total; i++) {
   121         visitor->visit(primitiveTypes_[i].address());
   122         visitor->visit(referenceTypes_[i].address());
   123     }
   124 }
sourcepawn2
Feed