script-inl.h 4.4 KB
Newer Older
1 2 3 4 5 6 7
// Copyright 2017 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifndef V8_OBJECTS_SCRIPT_INL_H_
#define V8_OBJECTS_SCRIPT_INL_H_

8 9
#include "src/objects/script.h"

10
#include "src/objects/shared-function-info.h"
11
#include "src/objects/smi-inl.h"
12
#include "src/objects/string-inl.h"
13 14 15 16 17 18 19

// Has to be the last include (doesn't have include guards):
#include "src/objects/object-macros.h"

namespace v8 {
namespace internal {

20
OBJECT_CONSTRUCTORS_IMPL(Script, Struct)
21 22 23

NEVER_READ_ONLY_SPACE_IMPL(Script)

24
CAST_ACCESSOR(Script)
25 26 27 28 29 30 31

ACCESSORS(Script, source, Object, kSourceOffset)
ACCESSORS(Script, name, Object, kNameOffset)
SMI_ACCESSORS(Script, id, kIdOffset)
SMI_ACCESSORS(Script, line_offset, kLineOffsetOffset)
SMI_ACCESSORS(Script, column_offset, kColumnOffsetOffset)
ACCESSORS(Script, context_data, Object, kContextOffset)
32
SMI_ACCESSORS(Script, type, kScriptTypeOffset)
33
ACCESSORS(Script, line_ends, Object, kLineEndsOffset)
34 35
ACCESSORS_CHECKED(Script, eval_from_shared_or_wrapped_arguments, Object,
                  kEvalFromSharedOrWrappedArgumentsOffset,
36 37 38
                  this->type() != TYPE_WASM)
SMI_ACCESSORS_CHECKED(Script, eval_from_position, kEvalFromPositionOffset,
                      this->type() != TYPE_WASM)
39 40
ACCESSORS(Script, shared_function_infos, WeakFixedArray,
          kSharedFunctionInfosOffset)
41 42 43
SMI_ACCESSORS(Script, flags, kFlagsOffset)
ACCESSORS(Script, source_url, Object, kSourceUrlOffset)
ACCESSORS(Script, source_mapping_url, Object, kSourceMappingUrlOffset)
44
ACCESSORS(Script, host_defined_options, FixedArray, kHostDefinedOptionsOffset)
45
ACCESSORS_CHECKED(Script, wasm_module_object, Object,
46
                  kEvalFromSharedOrWrappedArgumentsOffset,
47 48
                  this->type() == TYPE_WASM)

49
bool Script::is_wrapped() const {
50
  return eval_from_shared_or_wrapped_arguments().IsFixedArray();
51 52 53
}

bool Script::has_eval_from_shared() const {
54
  return eval_from_shared_or_wrapped_arguments().IsSharedFunctionInfo();
55 56
}

57
void Script::set_eval_from_shared(SharedFunctionInfo shared,
58 59 60 61 62
                                  WriteBarrierMode mode) {
  DCHECK(!is_wrapped());
  set_eval_from_shared_or_wrapped_arguments(shared, mode);
}

63
SharedFunctionInfo Script::eval_from_shared() const {
64 65 66 67
  DCHECK(has_eval_from_shared());
  return SharedFunctionInfo::cast(eval_from_shared_or_wrapped_arguments());
}

68
void Script::set_wrapped_arguments(FixedArray value, WriteBarrierMode mode) {
69 70 71 72
  DCHECK(!has_eval_from_shared());
  set_eval_from_shared_or_wrapped_arguments(value, mode);
}

73
FixedArray Script::wrapped_arguments() const {
74 75 76 77
  DCHECK(is_wrapped());
  return FixedArray::cast(eval_from_shared_or_wrapped_arguments());
}

78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105
Script::CompilationType Script::compilation_type() {
  return BooleanBit::get(flags(), kCompilationTypeBit) ? COMPILATION_TYPE_EVAL
                                                       : COMPILATION_TYPE_HOST;
}
void Script::set_compilation_type(CompilationType type) {
  set_flags(BooleanBit::set(flags(), kCompilationTypeBit,
                            type == COMPILATION_TYPE_EVAL));
}
Script::CompilationState Script::compilation_state() {
  return BooleanBit::get(flags(), kCompilationStateBit)
             ? COMPILATION_STATE_COMPILED
             : COMPILATION_STATE_INITIAL;
}
void Script::set_compilation_state(CompilationState state) {
  set_flags(BooleanBit::set(flags(), kCompilationStateBit,
                            state == COMPILATION_STATE_COMPILED));
}
ScriptOriginOptions Script::origin_options() {
  return ScriptOriginOptions((flags() & kOriginOptionsMask) >>
                             kOriginOptionsShift);
}
void Script::set_origin_options(ScriptOriginOptions origin_options) {
  DCHECK(!(origin_options.Flags() & ~((1 << kOriginOptionsSize) - 1)));
  set_flags((flags() & ~kOriginOptionsMask) |
            (origin_options.Flags() << kOriginOptionsShift));
}

bool Script::HasValidSource() {
106
  Object src = this->source();
107
  if (!src.IsString()) return true;
108
  String src_str = String::cast(src);
109
  if (!StringShape(src_str).IsExternal()) return true;
110 111 112 113
  if (src_str.IsOneByteRepresentation()) {
    return ExternalOneByteString::cast(src).resource() != nullptr;
  } else if (src_str.IsTwoByteRepresentation()) {
    return ExternalTwoByteString::cast(src).resource() != nullptr;
114 115 116 117 118 119 120 121 122 123
  }
  return true;
}

}  // namespace internal
}  // namespace v8

#include "src/objects/object-macros-undef.h"

#endif  // V8_OBJECTS_SCRIPT_INL_H_