core/Multiname-inlines.h

   1 /* -*- Mode: C++; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 4 -*- */
   2 /* vi: set ts=4 sw=4 expandtab: (add to ~/.vimrc: set modeline modelines=5) */
   3 /* ***** BEGIN LICENSE BLOCK *****
   4  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   5  *
   6  * The contents of this file are subject to the Mozilla Public License Version
   7  * 1.1 (the "License"); you may not use this file except in compliance with
   8  * the License. You may obtain a copy of the License at
   9  * http://www.mozilla.org/MPL/
  10  *
  11  * Software distributed under the License is distributed on an "AS IS" basis,
  12  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  13  * for the specific language governing rights and limitations under the
  14  * License.
  15  *
  16  * The Original Code is [Open Source Virtual Machine.].
  17  *
  18  * The Initial Developer of the Original Code is
  19  * Adobe System Incorporated.
  20  * Portions created by the Initial Developer are Copyright (C) 2009
  21  * the Initial Developer. All Rights Reserved.
  22  *
  23  * Contributor(s):
  24  *   Adobe AS3 Team
  25  *
  26  * Alternatively, the contents of this file may be used under the terms of
  27  * either the GNU General Public License Version 2 or later (the "GPL"), or
  28  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  29  * in which case the provisions of the GPL or the LGPL are applicable instead
  30  * of those above. If you wish to allow use of your version of this file only
  31  * under the terms of either the GPL or the LGPL, and not to allow others to
  32  * use your version of this file under the terms of the MPL, indicate your
  33  * decision by deleting the provisions above and replace them with the notice
  34  * and other provisions required by the GPL or the LGPL. If you do not delete
  35  * the provisions above, a recipient may use your version of this file under
  36  * the terms of any one of the MPL, the GPL or the LGPL.
  37  *
  38  * ***** END LICENSE BLOCK ***** */
  39
  40 namespace avmplus
  41 {
  42
  43 REALLY_INLINE Stringp Multiname::getName() const
  44 {
  45     AvmAssert(!isAnyName() && !isRtname());
  46     return name;
  47 }
  48
  49 REALLY_INLINE void Multiname::setName(Stringp _name)
  50 {
  51     AvmAssert(_name && _name->isInterned());
  52     this->flags &= ~RTNAME;
  53     this->name = _name;
  54 }
  55
  56 REALLY_INLINE void Multiname::setName(const Multiname* other)
  57 {
  58     // copy name settings from other
  59     flags &= ~RTNAME;
  60     flags |= other->flags & RTNAME;
  61     this->name = other->name;
  62 }
  63
  64 REALLY_INLINE int32_t Multiname::namespaceCount() const
  65 {
  66     return (nsset && (flags & NSSET)) ? nsset->count() : 1;
  67 }
  68
  69 REALLY_INLINE Namespacep Multiname::getNamespace() const
  70 {
  71     return getNamespace(0);
  72 }
  73
  74 REALLY_INLINE void Multiname::setNamespace(Namespacep _ns)
  75 {
  76     flags &= ~(NSSET|RTNS);
  77     AvmAssert(_ns != NULL);
  78     this->ns = _ns;
  79 }
  80
  81 REALLY_INLINE void Multiname::setNamespace(const Multiname* other)
  82 {
  83     // copy namespace settings from other
  84     flags &= ~(NSSET|RTNS);
  85     flags |= other->flags & (NSSET|RTNS);
  86     this->ns = other->ns;
  87 }
  88
  89 REALLY_INLINE NamespaceSetp Multiname::getNsset() const
  90 {
  91     AvmAssert(!isRtns() && (flags&NSSET));
  92     return nsset;
  93 }
  94
  95 REALLY_INLINE void Multiname::setNsset(NamespaceSetp _nsset)
  96 {
  97     flags &= ~RTNS;
  98     flags |= NSSET;
  99     AvmAssert(_nsset != NULL);
 100     this->nsset = _nsset;
 101 }
 102
 103 REALLY_INLINE uint32_t Multiname::getTypeParameter() const
 104 {
 105     AvmAssert(isParameterizedType());
 106     return next_index;
 107 }
 108
 109 REALLY_INLINE void Multiname::setTypeParameter(uint32_t index)
 110 {
 111     flags |= TYPEPARAM;
 112     this->next_index = index;
 113 }
 114
 115 REALLY_INLINE Multiname::Multiname()
 116 {
 117     this->name = NULL;
 118     this->ns = NULL;
 119     this->flags = 0;
 120     this->next_index = 0;
 121 }
 122
 123 REALLY_INLINE Multiname::Multiname(NamespaceSetp nsset)
 124 {
 125     this->name = NULL;
 126     this->nsset = nsset;
 127     this->flags = NSSET;
 128     this->next_index = 0;
 129 }
 130
 131 REALLY_INLINE Multiname::Multiname(const Multiname &other)
 132 {
 133     *this = other;
 134 }
 135
 136 REALLY_INLINE Multiname::Multiname(Namespacep ns, Stringp name)
 137 {
 138     AvmAssert(name && name->isInterned());
 139     this->name = name;
 140     this->ns = ns;
 141     this->flags = 0;
 142     this->next_index = 0;
 143 }
 144
 145 REALLY_INLINE Multiname::Multiname(Namespacep ns, Stringp name, bool qualified)
 146 {
 147     AvmAssert(name && name->isInterned());
 148     this->name = name;
 149     this->ns = ns;
 150     this->flags = 0;
 151     this->next_index = 0;
 152     if (qualified)
 153         setQName();
 154 }
 155
 156 REALLY_INLINE Multiname::~Multiname()
 157 {
 158     name = NULL;
 159     nsset = NULL;
 160     flags = 0;
 161     next_index = 0;
 162 }
 163
 164 REALLY_INLINE void Multiname::gcTrace(MMgc::GC* gc)
 165 {
 166     gc->TraceLocation((const void**)&name);
 167     gc->TraceLocation((const void**)&ns);    // or nsset
 168 }
 169
 170 REALLY_INLINE bool Multiname::containsAnyPublicNamespace() const
 171 {
 172     if (!nsset)
 173         return false; // note, also handles this->ns == null
 174
 175     if (flags & NSSET)
 176     {
 177         return this->nsset->containsAnyPublicNamespace();
 178     }
 179     else
 180     {
 181         return this->ns->isPublic();
 182     }
 183 }
 184
 185
 186 /**
 187  * return the flags we want to keep when copying a compile-time
 188  * multiname into a runtime temporary multiname
 189  */
 190 REALLY_INLINE int32_t Multiname::ctFlags() const
 191 {
 192     return flags & ~(RTNS|RTNAME);
 193 }
 194
 195 /**
 196  * returns true if this multiname could resolve to a binding.  Attributes,
 197  * wildcards, and runtime parts mean it can't match any binding.
 198  */
 199 REALLY_INLINE int32_t Multiname::isBinding() const
 200 {
 201     return !(flags & (ATTR|RTNS|RTNAME)) && name && ns;
 202 }
 203
 204 REALLY_INLINE int32_t Multiname::isRuntime() const
 205 {
 206     return flags & (RTNS|RTNAME);
 207 }
 208
 209 REALLY_INLINE int32_t Multiname::isRtns() const
 210 {
 211     return flags & RTNS;
 212 }
 213
 214 REALLY_INLINE int32_t Multiname::isRtname() const
 215 {
 216     return flags & RTNAME;
 217 }
 218
 219 REALLY_INLINE int32_t Multiname::isQName() const
 220 {
 221     return flags & QNAME;
 222 }
 223
 224 REALLY_INLINE bool Multiname::isAttr() const
 225 {
 226     return (bool) (flags & ATTR);
 227 }
 228
 229 REALLY_INLINE bool Multiname::isAnyName() const
 230 {
 231     return !isRtname() && !name;
 232 }
 233
 234 REALLY_INLINE bool Multiname::isAnyNamespace() const
 235 {
 236     return !isRtns() && !(flags&NSSET) && ns == NULL;
 237 }
 238
 239 REALLY_INLINE int32_t Multiname::isNsset() const
 240 {
 241     return flags & NSSET;
 242 }
 243
 244 REALLY_INLINE bool Multiname::isValidDynamicName() const
 245 {
 246     // return !isAnyName() && !isAttr() && containsAnyPublicNamespace();
 247     // consolidate the above to insure against compiler stupidity
 248     return ((flags & (ATTR|RTNAME)) == 0) && name != NULL && containsAnyPublicNamespace();
 249 }
 250
 251 REALLY_INLINE int32_t Multiname::isParameterizedType() const
 252 {
 253     return flags&TYPEPARAM;
 254 }
 255
 256 REALLY_INLINE void Multiname::setAttr(bool b)
 257 {
 258     if (b)
 259         flags |= ATTR;
 260     else
 261         flags &= ~ATTR;
 262 }
 263
 264 REALLY_INLINE void Multiname::setQName()
 265 {
 266     AvmAssert(namespaceCount()==1 && !(flags&NSSET));
 267     flags |= QNAME;
 268 }
 269
 270 REALLY_INLINE void Multiname::setRtns()
 271 {
 272     flags |= RTNS;
 273     flags &= ~NSSET;
 274     ns = NULL;
 275 }
 276
 277 REALLY_INLINE void Multiname::setRtname()
 278 {
 279     flags |= RTNAME;
 280     name = NULL;
 281 }
 282
 283 REALLY_INLINE void Multiname::setAnyName()
 284 {
 285     flags &= ~RTNAME;
 286     name = NULL;
 287 }
 288
 289 REALLY_INLINE void Multiname::setAnyNamespace()
 290 {
 291     flags &= ~(NSSET|RTNS);
 292     ns = NULL;
 293 }
 294
 295 REALLY_INLINE void Multiname::IncrementRef()
 296 {
 297     if (name != NULL)
 298         name->IncrementRef();
 299     if (ns != NULL && (flags & NSSET) == 0)
 300         ns->IncrementRef();
 301 }
 302
 303 REALLY_INLINE void Multiname::DecrementRef()
 304 {
 305     if (name != NULL)
 306         name->DecrementRef();
 307     if (ns != NULL && (flags & NSSET) == 0)
 308         ns->DecrementRef();
 309 }
 310
 311 REALLY_INLINE HeapMultiname::HeapMultiname()
 312 { /* our embedded Multiname inits itself to all zero */ }
 313
 314 REALLY_INLINE HeapMultiname::HeapMultiname(const Multiname& other)
 315 {
 316     setMultiname(other);
 317 }
 318
 319 REALLY_INLINE HeapMultiname::operator const Multiname* () const
 320 {
 321     return &name;
 322 }
 323
 324 REALLY_INLINE HeapMultiname::operator const Multiname& () const
 325 {
 326     return name;
 327 }
 328
 329 REALLY_INLINE const HeapMultiname& HeapMultiname::operator=(const HeapMultiname& that)
 330 {
 331     if (this != &that)
 332     {
 333         setMultiname(that.name);
 334     }
 335     return *this;
 336 }
 337
 338 REALLY_INLINE const HeapMultiname& HeapMultiname::operator=(const Multiname& that)
 339 {
 340     setMultiname(that);
 341     return *this;
 342 }
 343
 344 REALLY_INLINE void HeapMultiname::gcTrace(MMgc::GC* gc)
 345 {
 346     name.gcTrace(gc);
 347 }
 348
 349 REALLY_INLINE Stringp HeapMultiname::getName() const
 350 {
 351     return name.getName();
 352 }
 353
 354 REALLY_INLINE int32_t HeapMultiname::namespaceCount() const
 355 {
 356     return name.namespaceCount();
 357 }
 358
 359 REALLY_INLINE Namespacep HeapMultiname::getNamespace(int32_t i) const
 360 {
 361     return name.getNamespace(i);
 362 }
 363
 364 REALLY_INLINE Namespacep HeapMultiname::getNamespace() const
 365 {
 366     return name.getNamespace();
 367 }
 368
 369 REALLY_INLINE NamespaceSetp HeapMultiname::getNsset() const
 370 {
 371     return name.getNsset();
 372 }
 373
 374 REALLY_INLINE bool HeapMultiname::contains(Namespacep ns) const
 375 {
 376     return name.contains(ns);
 377 }
 378
 379 REALLY_INLINE int32_t HeapMultiname::ctFlags() const
 380 {
 381     return name.ctFlags();
 382 }
 383
 384 REALLY_INLINE int32_t HeapMultiname::isBinding() const
 385 {
 386     return name.isBinding();
 387 }
 388
 389 REALLY_INLINE int32_t HeapMultiname::isRuntime() const
 390 {
 391     return name.isRuntime();
 392 }
 393
 394 REALLY_INLINE int32_t HeapMultiname::isRtns() const
 395 {
 396     return name.isRtns();
 397 }
 398
 399 REALLY_INLINE int32_t HeapMultiname::isRtname() const
 400 {
 401     return name.isRtname();
 402 }
 403
 404 REALLY_INLINE int32_t HeapMultiname::isQName() const
 405 {
 406     return name.isQName();
 407 }
 408
 409 REALLY_INLINE bool HeapMultiname::isAttr() const
 410 {
 411     return name.isAttr();
 412 }
 413
 414 REALLY_INLINE bool HeapMultiname::isAnyName() const
 415 {
 416     return name.isAnyName();
 417 }
 418
 419 REALLY_INLINE bool HeapMultiname::isAnyNamespace() const
 420 {
 421     return name.isAnyNamespace();
 422 }
 423
 424 REALLY_INLINE int32_t HeapMultiname::isNsset() const
 425 {
 426     return name.isNsset();
 427 }
 428
 429 REALLY_INLINE bool HeapMultiname::matches(const Multiname *mn) const
 430 {
 431     return name.matches(mn);
 432 }
 433
 434 REALLY_INLINE MMgc::GC* HeapMultiname::gc() const
 435 {
 436     return MMgc::GC::GetGC(this);
 437 }
 438
 439 } // namespace avmplus