To protect your data, the CISO officer has suggested users to enable 2FA as soon as possible.
Currently 2.7% of users enabled 2FA.

universe.py 22.3 KB
Newer Older
Tobias Pape's avatar
Tobias Pape committed
1
from rpython.rlib.rrandom import Random
Carl Friedrich Bolz's avatar
Carl Friedrich Bolz committed
2
from rpython.rlib import jit
Tobias Pape's avatar
Tobias Pape committed
3

Stefan Marr's avatar
Stefan Marr committed
4
from som.interpreter.interpreter import Interpreter
Stefan Marr's avatar
Stefan Marr committed
5
from som.interpreter.bytecodes   import Bytecodes 
Stefan Marr's avatar
Stefan Marr committed
6
7
from som.vm.symbol_table         import SymbolTable
from som.vmobjects.object        import Object
8
9
10
from som.vmobjects.clazz         import Class
from som.vmobjects.array         import Array
from som.vmobjects.symbol        import Symbol
Stefan Marr's avatar
Stefan Marr committed
11
from som.vmobjects.method        import Method
Stefan Marr's avatar
Stefan Marr committed
12
from som.vmobjects.integer       import Integer
13
from som.vmobjects.string        import String
14
from som.vmobjects.block         import Block, block_evaluation_primitive
15
from som.vmobjects.frame         import Frame
16
from som.vmobjects.biginteger    import BigInteger
17
from som.vmobjects.double        import Double
Stefan Marr's avatar
Stefan Marr committed
18

Stefan Marr's avatar
Stefan Marr committed
19
20
from som.vm.shell import Shell

21
22
import som.compiler.sourcecode_compiler as sourcecode_compiler

Stefan Marr's avatar
Stefan Marr committed
23
import os
Tobias Pape's avatar
Tobias Pape committed
24
25
import time

26

27
28
from rlib.exit  import Exit
from rlib.osext import path_split
Stefan Marr's avatar
Stefan Marr committed
29

Carl Friedrich Bolz's avatar
Carl Friedrich Bolz committed
30
31
32
33

class GlobalVersion(object):
    pass

Stefan Marr's avatar
Stefan Marr committed
34
class Universe(object):
Carl Friedrich Bolz's avatar
Carl Friedrich Bolz committed
35
36
37
38
    _immutable_fields_ = [
            "_global_version?",
            ]

39
    def __init__(self, avoid_exit = False):
Stefan Marr's avatar
Stefan Marr committed
40
41
42
43
        self._interpreter    = Interpreter(self)
        self._symbol_table   = SymbolTable()
        
        self._globals        = {}
Carl Friedrich Bolz's avatar
Carl Friedrich Bolz committed
44
45
        self._global_version = GlobalVersion()

Tobias Pape's avatar
Tobias Pape committed
46
47
48
49
50
51
        self.nilObject      = None
        self.trueObject     = None
        self.falseObject    = None
        self.objectClass    = None
        self.classClass     = None
        self.metaclassClass = None
Stefan Marr's avatar
Stefan Marr committed
52
        
Tobias Pape's avatar
Tobias Pape committed
53
54
55
56
57
58
59
60
61
62
        self.nilClass       = None
        self.integerClass   = None
        self.bigintegerClass= None
        self.arrayClass     = None
        self.methodClass    = None
        self.symbolClass    = None
        self.frameClass     = None
        self.primitiveClass = None
        self.systemClass    = None
        self.blockClass     = None
63
        self.blockClasses   = None
Tobias Pape's avatar
Tobias Pape committed
64
65
        self.stringClass    = None
        self.doubleClass    = None
Stefan Marr's avatar
Stefan Marr committed
66
67
        
        self._last_exit_code = 0
68
        self._avoid_exit     = avoid_exit
Tobias Pape's avatar
Tobias Pape committed
69
        self._dump_bytecodes = False
Stefan Marr's avatar
Stefan Marr committed
70
        self.classpath       = None
Tobias Pape's avatar
Tobias Pape committed
71
72
73
        self.start_time      = time.time() # a float of the time in seconds
        self.random          = Random(abs(int(time.clock() * time.time())))

74

75
76
77
78
    def exit(self, error_code):
        if self._avoid_exit:
            self._last_exit_code = error_code
        else:
79
            raise Exit(error_code)
80
81
82
83
    
    def last_exit_code(self):
        return self._last_exit_code
    
84
85
86
    def get_interpreter(self):
        return self._interpreter
    
87
88
89
90
91
92
93
94
95
96
    def execute_method(self, class_name, selector):
        self._initialize_object_system()

        clazz = self.load_class(self.symbol_for(class_name))

        # Lookup the invokable on class
        invokable = clazz.get_class().lookup_invokable(self.symbol_for(selector))

        bootstrap_method = self._create_bootstrap_method()
        bootstrap_frame  = self._create_bootstrap_frame(bootstrap_method, clazz)
Stefan Marr's avatar
Stefan Marr committed
97
        
98
        return self.start(bootstrap_frame, invokable)
Stefan Marr's avatar
Stefan Marr committed
99
    
100
101
    def _create_bootstrap_method(self):
        # Create a fake bootstrap method to simplify later frame traversal
102
103
104
        bootstrap_method = self.new_method(self.symbol_for("bootstrap"), 1, 0,
                                           self.new_integer(0),
                                           self.new_integer(2))
105
        bootstrap_method.set_bytecode(0, Bytecodes.halt)
Tobias Pape's avatar
Tobias Pape committed
106
        bootstrap_method.set_holder(self.systemClass)
107
        return bootstrap_method
108
    
109
110
    def _create_bootstrap_frame(self, bootstrap_method, receiver, arguments = None):
        # Create a fake bootstrap frame with the system object on the stack
111
        bootstrap_frame = self._interpreter.push_new_frame(bootstrap_method, self.nilObject)
112
113
114
        bootstrap_frame.push(receiver)
        
        if arguments:
115
            bootstrap_frame.push(arguments)
116
        return bootstrap_frame
117
118
        
    
Stefan Marr's avatar
Stefan Marr committed
119
120
    def interpret(self, arguments):
        # Check for command line switches
121
        arguments = self.handle_arguments(arguments)
Stefan Marr's avatar
Stefan Marr committed
122
123

        # Initialize the known universe
124
125
        system_object = self._initialize_object_system()
        bootstrap_method = self._create_bootstrap_method()
Stefan Marr's avatar
Stefan Marr committed
126
        
127
128
129
130
131
132
133
        # Start the shell if no filename is given
        if len(arguments) == 0:
            shell = Shell(self, self._interpreter)
            shell.set_bootstrap_method(bootstrap_method)
            shell.start()
            return
        else:
134
135
136
            # Convert the arguments into an array
            arguments_array = self.new_array_with_strings(arguments)
            bootstrap_frame = self._create_bootstrap_frame(bootstrap_method, system_object, arguments_array)
137
            # Lookup the initialize invokable on the system class
Tobias Pape's avatar
Tobias Pape committed
138
            initialize = self.systemClass.lookup_invokable(self.symbol_for("initialize:"))
139
140
141
142
143
144
145
146
147

            self.start(bootstrap_frame, initialize)
    
    def start(self, bootstrap_frame, invokable):
        # Invoke the initialize invokable
        invokable.invoke(bootstrap_frame, self._interpreter)

        # Start the interpreter
        return self._interpreter.start()
Stefan Marr's avatar
Stefan Marr committed
148
    
149
    def handle_arguments(self, arguments):
Stefan Marr's avatar
Stefan Marr committed
150
151
152
153
154
155
156
157
        got_classpath  = False
        remaining_args = []

        i = 0
        while i < len(arguments):
            if arguments[i] == "-cp":
                if i + 1 >= len(arguments):
                    self._print_usage_and_exit()
158
                self.setup_classpath(arguments[i + 1])
Stefan Marr's avatar
Stefan Marr committed
159
160
161
162
                i += 1    # skip class path
                got_classpath = True
            elif arguments[i] == "-d":
                self._dump_bytecodes = True
Tobias Pape's avatar
Tobias Pape committed
163
164
            elif arguments[i] in ["-h", "--help", "-?"]:
                self._print_usage_and_exit()
Stefan Marr's avatar
Stefan Marr committed
165
166
            else:
                remaining_args.append(arguments[i])
Tobias Pape's avatar
Tobias Pape committed
167
            i += 1
Stefan Marr's avatar
Stefan Marr committed
168
169
170
    
        if not got_classpath:
            # Get the default class path of the appropriate size
Tobias Pape's avatar
Tobias Pape committed
171
            self.classpath = self._setup_default_classpath()
Stefan Marr's avatar
Stefan Marr committed
172
173
174
175
176
177
178

        # check remaining args for class paths, and strip file extension
        i = 0
        while i < len(remaining_args):
            split = self._get_path_class_ext(remaining_args[i])

            if split[0] != "":  # there was a path
Tobias Pape's avatar
Tobias Pape committed
179
                self.classpath.insert(0, split[0])
Stefan Marr's avatar
Stefan Marr committed
180
181
182
183
184
185
        
            remaining_args[i] = split[1]
            i += 1
        
        return remaining_args
    
186
    def setup_classpath(self, cp):
Tobias Pape's avatar
Tobias Pape committed
187
        self.classpath = cp.split(os.pathsep)
Stefan Marr's avatar
Stefan Marr committed
188
    
189
190
191
    def _setup_default_classpath(self):
        return ['.']
    
Stefan Marr's avatar
Stefan Marr committed
192
193
194
    # take argument of the form "../foo/Test.som" and return
    # "../foo", "Test", "som"
    def _get_path_class_ext(self, path):
195
        return path_split(path)
196
197
198
    
    def _print_usage_and_exit(self):
        # Print the usage
199
200
201
202
        std_println("Usage: som [-options] [args...]                          ")
        std_println("                                                         ")
        std_println("where options include:                                   ")
        std_println("    -cp <directories separated by " + os.pathsep     + ">")
Tobias Pape's avatar
Tobias Pape committed
203
204
205
        std_println("        set search path for application classes")
        std_println("    -d  enable disassembling")
        std_println("    -h  print this help")
206
207
208

        # Exit
        self.exit(0)
Stefan Marr's avatar
Stefan Marr committed
209

210
    def _initialize_object_system(self):
Stefan Marr's avatar
Stefan Marr committed
211
        # Allocate the nil object
Tobias Pape's avatar
Tobias Pape committed
212
        self.nilObject = Object(None)
Stefan Marr's avatar
Stefan Marr committed
213
214

        # Allocate the Metaclass classes
Tobias Pape's avatar
Tobias Pape committed
215
        self.metaclassClass = self.new_metaclass_class()
Stefan Marr's avatar
Stefan Marr committed
216
217

        # Allocate the rest of the system classes
Tobias Pape's avatar
Tobias Pape committed
218
219
220
221
222
223
224
225
226
227
228
229
        self.objectClass     = self.new_system_class()
        self.nilClass        = self.new_system_class()
        self.classClass      = self.new_system_class()
        self.arrayClass      = self.new_system_class()
        self.symbolClass     = self.new_system_class()
        self.methodClass     = self.new_system_class()
        self.integerClass    = self.new_system_class()
        self.bigintegerClass = self.new_system_class()
        self.frameClass      = self.new_system_class()
        self.primitiveClass  = self.new_system_class()
        self.stringClass     = self.new_system_class()
        self.doubleClass     = self.new_system_class()
Stefan Marr's avatar
Stefan Marr committed
230
231

        # Setup the class reference for the nil object
Tobias Pape's avatar
Tobias Pape committed
232
        self.nilObject.set_class(self.nilClass)
Stefan Marr's avatar
Stefan Marr committed
233
234

        # Initialize the system classes
Tobias Pape's avatar
Tobias Pape committed
235
236
237
238
239
240
241
242
243
244
245
246
247
        self._initialize_system_class(self.objectClass,                 None, "Object")
        self._initialize_system_class(self.classClass,      self.objectClass, "Class")
        self._initialize_system_class(self.metaclassClass,   self.classClass, "Metaclass")
        self._initialize_system_class(self.nilClass,        self.objectClass, "Nil")
        self._initialize_system_class(self.arrayClass,      self.objectClass, "Array")
        self._initialize_system_class(self.methodClass,      self.arrayClass, "Method")
        self._initialize_system_class(self.symbolClass,     self.objectClass, "Symbol")
        self._initialize_system_class(self.integerClass,    self.objectClass, "Integer")
        self._initialize_system_class(self.bigintegerClass, self.objectClass, "BigInteger")
        self._initialize_system_class(self.frameClass,       self.arrayClass, "Frame")
        self._initialize_system_class(self.primitiveClass,  self.objectClass, "Primitive")
        self._initialize_system_class(self.stringClass,     self.objectClass, "String")
        self._initialize_system_class(self.doubleClass,     self.objectClass, "Double")
Stefan Marr's avatar
Stefan Marr committed
248
249

        # Load methods and fields into the system classes
Tobias Pape's avatar
Tobias Pape committed
250
251
252
253
254
255
256
257
258
259
260
261
262
        self._load_system_class(self.objectClass)
        self._load_system_class(self.classClass)
        self._load_system_class(self.metaclassClass)
        self._load_system_class(self.nilClass)
        self._load_system_class(self.arrayClass)
        self._load_system_class(self.methodClass)
        self._load_system_class(self.symbolClass)
        self._load_system_class(self.integerClass)
        self._load_system_class(self.bigintegerClass)
        self._load_system_class(self.frameClass)
        self._load_system_class(self.primitiveClass)
        self._load_system_class(self.stringClass)
        self._load_system_class(self.doubleClass)
Stefan Marr's avatar
Stefan Marr committed
263
264

        # Load the generic block class
Tobias Pape's avatar
Tobias Pape committed
265
        self.blockClass = self.load_class(self.symbol_for("Block"))
Stefan Marr's avatar
Stefan Marr committed
266
267

        # Setup the true and false objects
268
269
270
271
272
273
274
        trueClassName    = self.symbol_for("True")
        trueClass        = self.load_class(trueClassName)
        self.trueObject  = self.new_instance(trueClass)
        
        falseClassName   = self.symbol_for("False")
        falseClass       = self.load_class(falseClassName)
        self.falseObject = self.new_instance(falseClass)
Stefan Marr's avatar
Stefan Marr committed
275
276

        # Load the system class and create an instance of it
Tobias Pape's avatar
Tobias Pape committed
277
278
        self.systemClass = self.load_class(self.symbol_for("System"))
        system_object = self.new_instance(self.systemClass)
Stefan Marr's avatar
Stefan Marr committed
279
280

        # Put special objects and classes into the dictionary of globals
Tobias Pape's avatar
Tobias Pape committed
281
282
283
        self.set_global(self.symbol_for("nil"),    self.nilObject)
        self.set_global(self.symbol_for("true"),   self.trueObject)
        self.set_global(self.symbol_for("false"),  self.falseObject)
284
        self.set_global(self.symbol_for("system"), system_object)
Tobias Pape's avatar
Tobias Pape committed
285
286
        self.set_global(self.symbol_for("System"), self.systemClass)
        self.set_global(self.symbol_for("Block"),  self.blockClass)
287
288
289
290
291
        
        self.set_global(self.symbol_for("Nil"),    self.nilClass)
        
        self.set_global( trueClassName,  trueClass)
        self.set_global(falseClassName, falseClass)
292
293
294
295

        self.blockClasses = [self.blockClass] + \
                [self._make_block_class(i) for i in [1, 2, 3]]

296
297
        return system_object
    
298
299
300
301
302
303
304
305
306
    def symbol_for(self, string):
        # Lookup the symbol in the symbol table
        result = self._symbol_table.lookup(string)
        if result:
            return result
        
        # Create a new symbol and return it
        result = self.new_symbol(string)
        return result
307
308
309
    
    def new_array_with_length(self, length):
        # Allocate a new array and set its class to be the array class
310
        result = Array(self.nilObject, length)
Tobias Pape's avatar
Tobias Pape committed
311
        result.set_class(self.arrayClass)
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336

        # Return the freshly allocated array
        return result
  
    def new_array_from_list(self, values):
        # Allocate a new array with the same length as the list
        result = self.new_array_with_length(len(values))

        # Copy all elements from the list into the array
        for i in range(len(values)):
            result.set_indexable_field(i, values[i])
    
        # Return the allocated and initialized array
        return result
  
    def new_array_with_strings(self, strings):
        # Allocate a new array with the same length as the string array
        result = self.new_array_with_length(len(strings))

        # Copy all elements from the string array into the array
        for i in range(len(strings)):
            result.set_indexable_field(i, self.new_string(strings[i]))
    
        # Return the allocated and initialized array
        return result
337
    
338
339
    def new_block(self, method, context_frame, arguments):
        # Allocate a new block and set its class to be the block class
340
        result = Block(self.nilObject, method, context_frame)
341
342
343
344
345
346
347
        result.set_class(self._get_block_class(arguments))

        # Return the freshly allocated block
        return result

    def new_class(self, class_class):
        # Allocate a new class and set its class to be the given class class
Stefan Marr's avatar
Stefan Marr committed
348
        result = Class(self, class_class.get_number_of_instance_fields())
349
350
351
352
353
        result.set_class(class_class)

        # Return the freshly allocated class
        return result

354
    def new_frame(self, previous_frame, method, context):
355
356
357
358
359
360
361
        # Compute the maximum number of stack locations (including arguments,
        # locals and extra buffer to support doesNotUnderstand) and set the
        # number of indexable fields accordingly
        length = (method.get_number_of_arguments() +
                  method.get_number_of_locals().get_embedded_integer() +
                  method.get_maximum_number_of_stack_elements().get_embedded_integer() + 2)

362
363
364
        # Allocate a new frame and set its class to be the frame class
        result = Frame(self.nilObject, length, method, context, previous_frame)
        result.set_class(self.frameClass)
365
366
367
368
369
370
371
372

        # Reset the stack pointer and the bytecode index
        result.reset_stack_pointer()
        result.set_bytecode_index(0)

        # Return the freshly allocated frame
        return result

373
374
    def new_method(self, signature, num_bytecodes, num_literals,
                   num_locals, maximum_number_of_stack_elements):
375
        # Allocate a new method and set its class to be the method class
376
377
378
379
380
381
        result = Method(self.nilObject,
                        num_literals,
                        num_locals,
                        maximum_number_of_stack_elements,
                        num_bytecodes,
                        signature)
Tobias Pape's avatar
Tobias Pape committed
382
        result.set_class(self.methodClass)
383
384
385
386
387
388

        # Return the freshly allocated method
        return result

    def new_instance(self, instance_class):
        # Allocate a new instance and set its class to be the given class
Tobias Pape's avatar
Tobias Pape committed
389
        result = Object(self.nilObject, instance_class.get_number_of_instance_fields())
390
391
392
393
394
395
396
        result.set_class(instance_class)
 
        # Return the freshly allocated instance
        return result

 
    def new_integer(self, value):
Tobias Pape's avatar
Tobias Pape committed
397
        assert isinstance(value, int)
398
        # Allocate a new integer and set its class to be the integer class
399
        result = Integer(self.nilObject, value)
Tobias Pape's avatar
Tobias Pape committed
400
        result.set_class(self.integerClass)
401
402
403
404
     
        # Return the freshly allocated integer
        return result
 
405
    def new_biginteger(self, value):
406
        # Allocate a new integer and set its class to be the integer class
407
        result = BigInteger(self.nilObject, value)
Tobias Pape's avatar
Tobias Pape committed
408
        result.set_class(self.bigintegerClass)
409
410
411
412
413
414
415
 
        # Return the freshly allocated integer
        return result
 
 
    def new_double(self, value):
        # Allocate a new integer and set its class to be the double class
416
        result = Double(self.nilObject, value)
Tobias Pape's avatar
Tobias Pape committed
417
        result.set_class(self.doubleClass)
418
419
420
421
 
        # Return the freshly allocated double
        return result
    
422
423
424
425
426
427
428
429
430
431
    def new_metaclass_class(self):
        # Allocate the metaclass classes
        result = Class(self)
        result.set_class(Class(self))

        # Setup the metaclass hierarchy
        result.get_class().set_class(result)

        # Return the freshly allocated metaclass class
        return result
432
433
434

    def new_string(self, embedded_string):
        # Allocate a new string and set its class to be the string class
435
        result = String(self.nilObject, embedded_string)
Tobias Pape's avatar
Tobias Pape committed
436
        result.set_class(self.stringClass)
437
  
438
439
        # Return the freshly allocated string
        return result
440
    
441
442
    def new_symbol(self, string):
        # Allocate a new symbol and set its class to be the symbol class
443
        result = Symbol(self.nilObject, string)
Tobias Pape's avatar
Tobias Pape committed
444
        result.set_class(self.symbolClass)
445
446
447
448
449
450
451

        # Insert the new symbol into the symbol table
        self._symbol_table.insert(result)

        # Return the freshly allocated symbol
        return result
      
452
453
454
455
456
457
    def new_system_class(self):
        # Allocate the new system class
        system_class = Class(self)

        # Setup the metaclass hierarchy
        system_class.set_class(Class(self))
Tobias Pape's avatar
Tobias Pape committed
458
        system_class.get_class().set_class(self.metaclassClass)
459
460
461
462
463
464
465

        # Return the freshly allocated system class
        return system_class
    
    def _initialize_system_class(self, system_class, super_class, name):
        # Initialize the superclass hierarchy
        if super_class:
466
            system_class.set_super_class(super_class)
467
468
            system_class.get_class().set_super_class(super_class.get_class())
        else:
Tobias Pape's avatar
Tobias Pape committed
469
            system_class.get_class().set_super_class(self.classClass)
470
471
472
473
474
475
476
477
478
479
480
481
    

        # Initialize the array of instance fields
        system_class.set_instance_fields(self.new_array_with_length(0))
        system_class.get_class().set_instance_fields(self.new_array_with_length(0))

        # Initialize the array of instance invokables
        system_class.set_instance_invokables(self.new_array_with_length(0))
        system_class.get_class().set_instance_invokables(self.new_array_with_length(0))

        # Initialize the name of the system class
        system_class.set_name(self.symbol_for(name))
482
        system_class.get_class().set_name(self.symbol_for(name + " class"))
483
484
485
486
487
488
489

        # Insert the system class into the dictionary of globals
        self.set_global(system_class.get_name(), system_class)
    
    
    def get_global(self, name):
        # Return the global with the given name if it's in the dictionary of globals
Carl Friedrich Bolz's avatar
Carl Friedrich Bolz committed
490
491
492
493
494
495
        # if not, return None
        jit.promote(self)
        return self._get_global(name, self._global_version)

    @jit.elidable
    def _get_global(self, name, version):
496
        return self._globals.get(name, None)
497
498
499
500

    def set_global(self, name, value):
        # Insert the given value into the dictionary of globals
        self._globals[name] = value
Carl Friedrich Bolz's avatar
Carl Friedrich Bolz committed
501
        self._global_version = GlobalVersion()
502
503
504
505

    def has_global(self, name):
        # Returns if the universe has a value for the global of the given name
        return name in self._globals
506
507
508
509
510

    def _get_block_class(self, number_of_arguments):
        return self.blockClasses[number_of_arguments]

    def _make_block_class(self, number_of_arguments):
511
512
513
514
515
        # Compute the name of the block class with the given number of
        # arguments
        name = self.symbol_for("Block" + str(number_of_arguments))

        # Get the block class for blocks with the given number of arguments
Stefan Marr's avatar
Stefan Marr committed
516
        result = self._load_class(name, None)
517
518

        # Add the appropriate value primitive to the block class
519
        result.add_instance_primitive(block_evaluation_primitive(number_of_arguments, self))
520
521
522
523
524
525
526
527
528

        # Insert the block class into the dictionary of globals
        self.set_global(name, result)

        # Return the loaded block class
        return result

    def load_class(self, name):
        # Check if the requested class is already in the dictionary of globals
529
530
531
        result = self.get_global(name)
        if result is not None:
            return result
532
533
534
535
536
537
538
539
540
541
542
543
544
545

        # Load the class
        result = self._load_class(name, None)

        # Load primitives (if necessary) and return the resulting class
        if result and result.has_primitives():
            result.load_primitives()
    
        return result

    def _load_system_class(self, system_class):
        # Load the system class
        result = self._load_class(system_class.get_name(), system_class)

546
547
548
549
550
551
552
        if not result:
            error_println(system_class.get_name().get_string()
                   + " class could not be loaded. It is likely that the "
                   + " class path has not been initialized properly. "
                   + "Please make sure that the '-cp' parameter is given on the command-line.")
            self.exit(200)

553
554
555
556
557
558
        # Load primitives if necessary
        if result.has_primitives():
            result.load_primitives()

    def _load_class(self, name, system_class):
        # Try loading the class from all different paths
Tobias Pape's avatar
Tobias Pape committed
559
        for cpEntry in self.classpath:
560
561
            try:
                # Load the class from a file and return the loaded class
562
                result = sourcecode_compiler.compile_class_from_file(cpEntry, name.get_string(), system_class, self)
563
                if self._dump_bytecodes:
564
565
566
                    from som.compiler.disassembler import dump
                    dump(result.get_class())
                    dump(result)
567
568
569
570
571
572
573
574

                return result
            except IOError:
                # Continue trying different paths
                pass

        # The class could not be found.
        return None
575
576
577
578
    
    def load_shell_class(self, stmt):
        # Load the class from a stream and return the loaded class
        result = sourcecode_compiler.compile_class_from_string(stmt, None, self)
Stefan Marr's avatar
Stefan Marr committed
579
        if self._dump_bytecodes:
580
581
            from som.compiler.disassembler import dump
            dump(result)
582
583
        return result

584
def error_print(msg):
585
    os.write(2, msg)
586

587
def error_println(msg = ""):
588
    os.write(2, msg + "\n")
589

590
def std_print(msg):
591
    print msg,
592

593
def std_println(msg=""):
594
595
    print msg

596
597
598
599
600
601
def main(args):
    u = Universe()
    u.interpret(args[1:])
    u.exit(0)

if __name__ == '__main__':
602
603
604
605
606
    import sys
    try:
        main(sys.argv)
    except Exit as e:
        sys.exit(e.code)