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