src/global_setup.c

   1 /*
   2 Copyright (C) 2001-2008, Parrot Foundation.
   3 $Id$
   4
   5 =head1 NAME
   6
   7 src/global_setup.c - Global setup
   8
   9 =head1 DESCRIPTION
  10
  11 Performs all the global setting up of things. This includes the very
  12 few global variables that Parrot totes around.
  13
  14 I<What are these global variables?>
  15
  16 =head2 Functions
  17
  18 =over 4
  19
  20 =cut
  21
  22 */
  23
  24 #define INSIDE_GLOBAL_SETUP
  25 #include "parrot/parrot.h"
  26 #include "global_setup.str"
  27
  28 /* These functions are defined in the auto-generated file core_pmcs.c */
  29 /* XXX Get it into some public place */
  30 extern void Parrot_initialize_core_pmcs(PARROT_INTERP, int pass);
  31 void Parrot_register_core_pmcs(PARROT_INTERP, PMC* registry);
  32
  33 static const unsigned char* parrot_config_stored = NULL;
  34 static unsigned int parrot_config_size_stored = 0;
  35
  36 /* HEADERIZER HFILE: include/parrot/global_setup.h */
  37
  38 /* HEADERIZER BEGIN: static */
  39 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
  40
  41 static void parrot_global_setup_2(PARROT_INTERP)
  42         __attribute__nonnull__(1);
  43
  44 static void parrot_set_config_hash_interpreter(PARROT_INTERP)
  45         __attribute__nonnull__(1);
  46
  47 #define ASSERT_ARGS_parrot_global_setup_2 __attribute__unused__ int _ASSERT_ARGS_CHECK = (\
  48        PARROT_ASSERT_ARG(interp))
  49 #define ASSERT_ARGS_parrot_set_config_hash_interpreter \
  50      __attribute__unused__ int _ASSERT_ARGS_CHECK = (\
  51        PARROT_ASSERT_ARG(interp))
  52 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
  53 /* HEADERIZER END: static */
  54
  55
  56 /*
  57
  58 =item C<void Parrot_set_config_hash_internal(const unsigned char* parrot_config,
  59 unsigned int parrot_config_size)>
  60
  61 Called by Parrot_set_config_hash with the serialised hash which
  62 will be used in subsequently created Interpreters.
  63
  64 =cut
  65
  66 */
  67
  68 PARROT_EXPORT
  69 void
  70 Parrot_set_config_hash_internal(ARGIN(const unsigned char* parrot_config),
  71                                  unsigned int parrot_config_size)
  72 {
  73     ASSERT_ARGS(Parrot_set_config_hash_internal)
  74     parrot_config_stored      = parrot_config;
  75     parrot_config_size_stored = parrot_config_size;
  76 }
  77
  78 /*
  79
  80 =item C<static void parrot_set_config_hash_interpreter(PARROT_INTERP)>
  81
  82 Used internally to associate the config hash with an Interpreter
  83 using the last registered config data.
  84
  85 =cut
  86
  87 */
  88
  89 static void
  90 parrot_set_config_hash_interpreter(PARROT_INTERP)
  91 {
  92     ASSERT_ARGS(parrot_set_config_hash_interpreter)
  93     PMC *iglobals = interp->iglobals;
  94
  95     PMC *config_hash = NULL;
  96
  97     if (parrot_config_size_stored > 1) {
  98         STRING * const config_string =
  99             Parrot_str_new_init(interp,
 100                                (const char *)parrot_config_stored, parrot_config_size_stored,
 101                                PARROT_DEFAULT_ENCODING, PARROT_DEFAULT_CHARSET,
 102                                PObj_external_FLAG|PObj_constant_FLAG);
 103
 104         config_hash = Parrot_thaw(interp, config_string);
 105     }
 106     else {
 107         config_hash = Parrot_pmc_new(interp, enum_class_Hash);
 108     }
 109
 110     VTABLE_set_pmc_keyed_int(interp, iglobals,
 111                              (INTVAL) IGLOBALS_CONFIG_HASH, config_hash);
 112 }
 113
 114 /*
 115
 116 =item C<void init_world_once(PARROT_INTERP)>
 117
 118 Call init_world() if it hasn't been called before.
 119
 120 C<interp> should be the root interpreter created in C<Parrot_new(NULL)>.
 121
 122 =cut
 123
 124 */
 125
 126 void
 127 init_world_once(PARROT_INTERP)
 128 {
 129     ASSERT_ARGS(init_world_once)
 130     if (!interp->world_inited) {
 131         /* init_world() sets up some vtable stuff.
 132          * It must only be called once.
 133          */
 134
 135         interp->world_inited = 1;
 136         init_world(interp);
 137     }
 138 }
 139
 140
 141 /*
 142
 143 =item C<void init_world(PARROT_INTERP)>
 144
 145 This is the actual initialization code called by C<init_world_once()>.
 146
 147 It sets up the Parrot system, running any platform-specific init code if
 148 necessary, then initializing the string subsystem, and setting up the
 149 base vtables and core PMCs.
 150
 151 C<interp> should be the root interpreter created in C<Parrot_new(NULL)>.
 152
 153 =cut
 154
 155 */
 156
 157 void
 158 init_world(PARROT_INTERP)
 159 {
 160     ASSERT_ARGS(init_world)
 161     PMC *iglobals, *self, *pmc;
 162
 163 #ifdef PARROT_HAS_PLATFORM_INIT_CODE
 164     Parrot_platform_init_code();
 165 #endif
 166
 167     /* Call base vtable class constructor methods */
 168     parrot_global_setup_2(interp);
 169     Parrot_initialize_core_pmcs(interp, 1);
 170
 171     iglobals = interp->iglobals;
 172     VTABLE_set_pmc_keyed_int(interp, iglobals,
 173             (INTVAL)IGLOBALS_CLASSNAME_HASH, interp->class_hash);
 174
 175     self           = Parrot_pmc_new_noinit(interp, enum_class_ParrotInterpreter);
 176     VTABLE_set_pointer(interp, self, interp);
 177     /* PMC_data(self) = interp; */
 178
 179     VTABLE_set_pmc_keyed_int(interp, iglobals,
 180             (INTVAL)IGLOBALS_INTERPRETER, self);
 181
 182     parrot_set_config_hash_interpreter(interp);
 183
 184     /* lib search paths */
 185     parrot_init_library_paths(interp);
 186
 187     /* load_bytecode and dynlib loaded hash */
 188     pmc = Parrot_pmc_new(interp, enum_class_Hash);
 189     VTABLE_set_pmc_keyed_int(interp, iglobals, IGLOBALS_PBC_LIBS, pmc);
 190
 191     pmc = Parrot_pmc_new(interp, enum_class_Hash);
 192     VTABLE_set_pmc_keyed_int(interp, iglobals, IGLOBALS_DYN_LIBS, pmc);
 193
 194     pmc = Parrot_pmc_new(interp, enum_class_Hash);
 195     VTABLE_set_pmc_keyed_int(interp, iglobals, IGLOBALS_NCI_FUNCS, pmc);
 196     Parrot_nci_load_core_thunks(interp);
 197 #if PARROT_HAS_EXTRA_NCI_THUNKS
 198     Parrot_nci_load_extra_thunks(interp);
 199 #endif
 200 }
 201
 202 /*
 203
 204 =item C<static void parrot_global_setup_2(PARROT_INTERP)>
 205
 206 called from inmidst of PMC bootstrapping between pass 0 and 1
 207
 208 =cut
 209
 210 */
 211
 212 static void
 213 parrot_global_setup_2(PARROT_INTERP)
 214 {
 215     ASSERT_ARGS(parrot_global_setup_2)
 216     PMC *classname_hash;
 217
 218     create_initial_context(interp);
 219
 220     /* create the namespace root stash */
 221     interp->root_namespace = Parrot_pmc_new(interp, enum_class_NameSpace);
 222     Parrot_init_HLL(interp);
 223
 224     Parrot_pcc_set_namespace(interp, CURRENT_CONTEXT(interp),
 225         VTABLE_get_pmc_keyed_int(interp, interp->HLL_namespace, 0));
 226
 227     /* We need a class hash */
 228     interp->class_hash = classname_hash = Parrot_pmc_new(interp, enum_class_NameSpace);
 229     Parrot_register_core_pmcs(interp, classname_hash);
 230
 231     /* init the interpreter globals array */
 232     interp->iglobals = Parrot_pmc_new_init_int(interp,
 233             enum_class_FixedPMCArray, (INTVAL)IGLOBALS_SIZE);
 234 }
 235
 236 /*
 237  * Local variables:
 238  *   c-file-style: "parrot"
 239  * End:
 240  * vim: expandtab shiftwidth=4:
 241  */