RE: building an image

I've added headless scripting capability to Strongtalk, which should help
with testing ports to other OSes without the GUI.  Now, the command line can
take -script <filepath> (path can be double-quoted if has imbedded spaces).
The script file must be in chunk/fileIn format (So for example a simple doit
can be done with syntax like "Transcript show: 'hello world'; cr !").

The script runs in the startup (scheduler) Smalltalk process, so it may be
simpler to debug as you may be able to avoid having to switch processes as
much.

(As an aside, this changes the command line syntax for benchmark running;
benchmark args must now be preceded by -benchmark, and not be intermixed
with other arguments.)

I will commit the changes, which are in runtime\arguments.cpp for the VM,
and SourceHandler.dlt, SystemInitializer.dlt, and Platform.dlt on the
Smalltalk side.  I have attached the new arguments.cpp, and a patch file
containing the Smalltalk side modifications.  My first attempt to commit the
changes failed for some reason (and was incredibly slow), so use the
attached files for now.

-Dave
  -----Original Message-----
  From: [email protected]
[mailto:[email protected]]On Behalf Of Dave Raymer
  Sent: Monday, March 05, 2007 11:55 AM
  To: [email protected]
  Subject: Re: building an image


  Dave,

  And getting the VM to run without the UI on Linux was indeed my plan;
  get a basic headless mode up and running, that basically provides a
  command line "shell" to the VM.

  I'll wait for your "command line arg" work and move forward from there.

  thanks for the response.
  -- the other Dave


  On 3/5/07, David Griswold <[email protected]> wrote:

    Hi,

    Sorry I've been off the list for a while.  I'll be more engaged going
    forward.

    Yes, your description looks pretty accurate.  As you said, the method
that
    is the hook for starting the Smalltalk level code executing is
    ProcessorScheduler>>start.  That calls SystemInitializer class>>run,
which
    runs all the non-scheduling specific startup code, including class
    initializers (class initializers don't run automatically right now, you
have
    to invoke them explicitely some where.  Critical library initializers
are
    called from SystemInitializer class>>runBaseClassInitializers.  Other
    non-core initializers are currently called from
    SystemInitializer>>runNonCriticalClassInitializers.  A better method is
    needed for organizing class initializers.)  If there are no command line
    arguments, the UI is started when SystemInitializer class>>run by
forking
    [UI start], the processorscheduler then enters into it's main loop which
    then schedules and executes the [UI start] block.  Generally, each
    application runs in a separate process.

    As much code as possible is written in Smalltalk, which of course means
the
    UI code is *entirely* written in Smalltalk, including all the
    platform-dependent code.  However, that doesn't mean the GUI is
    non-portable, since while the UI implementation contains lots of Win32
    specific code, device dependent code is factored out by class or
category
    and the interface it presents to applications is designed to be fully
    portable, with device independent ways of doing rendering, event
processing,
    etc.  So obviously the GUI isn't going to run out-of-the-box on
non-Windows
    systems; there is a big project involved to port the implementation,
however
    none of the applications or interfaces should have to be modified (that
I
    know of).

    But given that porting the GUI is a big project that isn't going to
happen
    anytime real soon, I think the focus should be on getting the VM running
    without the UI on Linux, since that would still be useful for a Squeak
port
    etc.   To do that, remember that the GUI only starts if there are no
command
    line arguments.  So we need to modify SystemInitializer
    class>>processArguments: with another option that takes a filename to
    file-in and execute, then we can test the VM reasonably without the GUI
(as
    well as use it to run scripts). I'll set that command-line arg up.  But
    there is still a significant piece of work to port the VM code that
    automatically loads and invokes external library DLLs, since all
Smalltalk
    I/O goes through that.  And then the basic non-GUI I/O code must be
ported
    to call Linux libs (not hard, although a socket implementation is
missing).
    At that point we would be able to run headless code that does basic file
    manipulation.

    As for rebuilding the image file from within Smalltalk, that doesn't
work
    yet, partly because there is a single method in the system right now
that
    currently causes the bytecode compiler to crash.  I will be looking into
    getting image bootstrapping working again, so that we can recompile and
    bootstrap the entire image, which would be an excellent first piece of
code
    for putting in an automated test suite for the VM, since it could be
done
    without needing the UI.  As part of that, I've been looking into the
image
    format, and I'll post some info on that when I set up the wiki, which I
will
    do "Real Soon Now".

    -Dave

    > -----Original Message-----
    > From: [email protected]
    > [mailto:[email protected]]On Behalf Of oe
    > Sent: Monday, March 05, 2007 8:57 AM
    > To: Strongtalk-general
    > Subject: Re: building an image
    >
    >
    >
    > Hello,
    >
    > I'm still trying to figure out, like a high level model of the VM. The
    > available documentation doesn't help me much here, I have to say, and
    > it took some time to get into this. So not sure what you mean exactly
    > with
    >
    > > trying to sort out how the image gets built so I can track the
    > > entrypoint into the runtime environment and see what how the UI gets
    > > loaded.
    >
    > , but I'll try to explain briefly what I've found out about how the VM
    > starts into the GUI.
    >
    > - VM starts in shell.cpp, initialization (bootstrap.cpp, mainly
    > bootstrap::parse_file())
    > - in process.cpp: VMProcess::activate_system(). This is where things
    > get interesting (and difficult, at least for me ;). The VM process
    > tries to retrieve a 'Delta level Processor' (see comments there) from
    > the system dictionary, which was (supposedly) previously loaded from
    > the image by the bootstrap code. I guess that the OOPs (processOop
    > etc.) involved are actually C++ representations of Smalltalk classes/
    > objects stored in the image (if this makes sense). You can inspect the
    > Smalltalk code by opening Strongtalk, then Browse->All Classes-
    > >Processor(->ProcessorScheduler).
    > - then, the "initial process" is created (new DeltaProcess) to call
    > the "start" method of scheduler just created (a method written in
    > Smalltalk, see Strongtalk class browser: Class ProcessorScheduler-
    > >Instance side->restricted->start).
    > - the actual call to "start" originates in the delta process once it
    > is run (that is, control is transfered by the scheduler): process.cpp
    > DeltaProcess::launch_delta, then delta.cpp Delta::call, all the way
    > down to interpreter_asm.asm call_delta, where the actual call takes
    > place. So I assume this is the point where Smalltalk code takes over
    > and drives further initialization of the system and GUI.
    > - also, if you look at the Smalltalk classes, especially
    > ExternalProxy, External* and Win32, I believe that there is a lot of
    > platform specific code written in Smalltalk, using Windows DLL calls
    > to interface with the OS (hence all the dll stuff/primitives in the C+
    > + code)... just speculating, though!
    >
    > So, that's about my quick tour of the VM startup, hope it helps -- or
    > maybe I've just missed the point of your post?  I haven't even manage
    > to build a new image file from within the Strongtalk GUI, but it's
    > been a while.Some information about the image file format and its
    > contents would definitely be helpful; I have to look at this again
    > when time permits.
    >
    > Oliver
    >
    >
    >
    

--~--~---------~--~----~------------~-------~--~----~
You received this message because you are subscribed to the Google Groups "Strongtalk-general" group.
To post to this group, send email to [email protected]
To unsubscribe from this group, send email to [email protected]
For more options, visit this group at http://groups.google.com/group/strongtalk-general?hl=en
-~----------~----~----~----~------~----~------~--~---

/* Copyright 1994, 1995 LongView Technologies L.L.C. $Revision: 1.13 $ */
/* Copyright (c) 2006, Sun Microsystems, Inc.
All rights reserved.

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the 
following conditions are met:

    * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
    * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following 
	  disclaimer in the documentation and/or other materials provided with the distribution.
    * Neither the name of Sun Microsystems nor the names of its contributors may be used to endorse or promote products derived 
	  from this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT 
NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL 
THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE 
OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE


*/

# include "incls/_precompiled.incl"
# include "incls/_arguments.cpp.incl"
# include <ctype.h>

// Recipe for setting flags for the VM:
// 1. Read the file .deltarc
// 2. Process the arguments

//char* boot_filename = "delta.bst";
char* boot_filename = SYSTEM_NAME ".bst";
char* rc_filename   = "." SYSTEM_NAME "rc";

static void set_bool_flag(char* name, bool value) {
  bool s = value;
  if (!debugFlags::boolAtPut(name, &s))
    fprintf(stderr, "Boolean flag %s unknown.\n", name);
}

static void set_int_flag(char* name, int value) {
  int v = value;
  if (!debugFlags::intAtPut(name, &v))
    fprintf(stderr, "Integer flag %s unknown.\n", name);
}

static void process_token(char* token) {
       if (token[0] == '-') set_bool_flag(&token[1], false);
  else if (token[0] == '+') set_bool_flag(&token[1], true);
  else {
    char name[100];
    int  value;
    if (sscanf(token, "%[a-zA-Z]=%d", name, &value) == 2) {
      set_int_flag(name, value);
    }
  }
}

void process_settings_file(char* file_name, bool quiet) {
  FILE* stream = fopen(file_name, "rb");
  if (stream == NULL) {
    if (quiet) return;
    fprintf(stderr, "Could not open %s\n", file_name);
    exit(-1);
  }

  char token[1024];
  int  pos = 0;

  bool in_white_space = true;
  bool in_comment     = false;

  int c = getc(stream);
  while(c != EOF) {
    if (in_white_space) {
      if (in_comment) {
	if (c == '\n') in_comment = false;
      } else {
        if (c == '#') in_comment = true;
        else if (!isspace(c)) {
          in_white_space = false;
	  token[pos++] = c;
        }
      }
    } else {
      if (isspace(c)) {
        token[pos] = '\0';
        process_token(token);
	pos = 0;
	in_white_space = true;
      } else {
        token[pos++] = c;
      }
    }
    c = getc(stream);
  }
  if (pos>0) {
    token[pos] = '\0';
    process_token(token);
  }
  fclose(stream);
}

void print_credits() {
  // string minimaly encrypted to make it more difficult to
  // tamper with it by looking for it in the executable...
  const char credits[] = "\
\x11\x5a\x04\x1e\x7a\x76\x08\x38\x0b\x6e\x5b\x50\x1e\x04\x2e\x34\x6b\x21\x47\x2e\
\x73\x57\x41\x7b\x65\x18\x3c\x54\x03\x2e\x79\x0e\x1a\x49\x17\x1f\x2f\x44\x45\x73\
\x75\x21\x7e\x5c\x00\x11\x6a\x53\x5b\x3a\x43\x3e\x7e\x5b\x08\x29\x1a\x4c\x1d\x53\
\x13\x22\x73\x0e\x1a\x49\x1f\x1e\x2d\x5b\x05\x37\x0b\x6e\x49\x4b\x01\x45\x02\x7b\
\x4c\x3f\x5c\x21\x7e\x3c\
";
  int mask = 0xa729b65d;
  for (int i = 0; i < sizeof(credits) - 1; i++) {
    fputc((credits[i] ^ mask) & 0x7f, stdout);
    mask = (mask << 1) | (mask >> 31) & 1; // rotate mask
  }
}

void parse_arguments(int argc, char* argv[]) {
  bool parse_files = true;

  if (argc > 1 && strcmp(argv[1], "-t") == 0) {
    fprintf(stdout, "Timers turned off, flags file and -f arguments are ignored.\n");
    UseTimers   = false;
    EnableTasks = false;
    parse_files = false;
  } 

  if (parse_files) {
    process_settings_file(rc_filename, true);
  }

  for (int index = parse_files ? 1 : 2; index < argc; index++) {
    if (strcmp(argv[index], "-?") == 0) {
      debugFlags::printFlags();
      exit(0);
    } else if (strcmp(argv[index], "-credits") == 0) {
      print_credits();
      exit(0);
    } else if (strcmp(argv[index], "-b") == 0) {
      index++;
      if (index >= argc) {
        fprintf(stderr, "file name expected after '-b'\n");
	exit(-1);
      }
      boot_filename = argv[index];
    } else if (strcmp(argv[index], "-f") == 0) {
      index++;
      if (index >= argc) {
        fprintf(stderr, "file name expected after '-f'\n");
	exit(-1);
      }
      if (parse_files) {
        process_settings_file(argv[index]);
      }
    } else if (strcmp(argv[index], "-script") == 0) {
       // The script file name is read and processed by Smalltalk
       // code, not here.  Here we just recognize it and skip over it.
      index++;
      if (index >= argc) {
        fprintf(stderr, "file name expected after '-script'\n");
	exit(-1);
      }
    } else if (strcmp(argv[index], "-benchmark") == 0) {
	// signals to ignore the rest of the command line, which will be 
	// interpreted by Smalltalk code as benchmark commands.
	return;
    } else process_token(argv[index]);
  }
}