Start.

js2/src/epimetheus.cpp

@@ -0,0 +1,224 @@
+// -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+//
+// The contents of this file are subject to the Netscape Public
+// License Version 1.1 (the "License"); you may not use this file
+// except in compliance with the License. You may obtain a copy of
+// the License at http://www.mozilla.org/NPL/
+//
+// Software distributed under the License is distributed on an "AS
+// IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+// implied. See the License for the specific language governing
+// rights and limitations under the License.
+//
+// The Original Code is the JavaScript 2 Prototype.
+//
+// The Initial Developer of the Original Code is Netscape
+// Communications Corporation.  Portions created by Netscape are
+// Copyright (C) 1998 Netscape Communications Corporation. All
+// Rights Reserved.
+
+
+//
+// JS2 shell.
+//
+
+#ifdef _WIN32
+ // Turn off warnings about identifiers too long in browser information
+ #pragma warning(disable: 4786)
+#endif
+
+#define EXITCODE_RUNTIME_ERROR 3
+
+#include <algorithm>
+#include <assert.h>
+
+#include "world.h"
+#include "reader.h"
+#include "parser.h"
+
+#include "js2metadata.h"
+
+#ifdef DEBUG
+#include "tracer.h"
+#include "collector.h"
+#endif
+
+#if defined(XP_MAC) && !defined(XP_MAC_MPW)
+#include <SIOUX.h>
+#include <MacTypes.h>
+
+static char *mac_argv[] = {"js2", 0};
+
+static void initConsole(StringPtr consoleName,
+                        const char* startupMessage,
+                        int &argc, char **&argv)
+{
+    SIOUXSettings.autocloseonquit = false;
+    SIOUXSettings.asktosaveonclose = false;
+    SIOUXSetTitle(consoleName);
+
+    // Set up a buffer for stderr (otherwise it's a pig).
+    static char buffer[BUFSIZ];
+    setvbuf(stderr, buffer, _IOLBF, BUFSIZ);
+
+    JavaScript::stdOut << startupMessage;
+
+    argc = 1;
+    argv = mac_argv;
+}
+
+#endif
+
+using namespace JavaScript::JS2Runtime;
+
+
+JavaScript::World world;
+JavaScript::Arena a;
+
+
+namespace JavaScript {
+namespace Shell {
+
+// Interactively read a line from the input stream in and put it into
+// s. Return false if reached the end of input before reading anything.
+static bool promptLine(LineReader &inReader, string &s, const char *prompt)
+{
+    if (prompt) {
+        stdOut << prompt;
+      #ifdef XP_MAC_MPW
+        // Print a CR after the prompt because MPW grabs the entire
+        // line when entering an interactive command.
+        stdOut << '\n';
+      #endif
+    }
+    return inReader.readLine(s) != 0;
+}
+
+
+/* "filename" of the console */
+const String ConsoleName = widenCString("<console>");
+const bool showTokens = false;
+
+#define INTERPRET_INPUT 1
+//#define SHOW_ICODE 1
+
+
+
+static int readEvalPrint(FILE *in)
+{
+    int result = 0;
+    String buffer;
+    string line;
+    LineReader inReader(in);
+    while (promptLine(inReader, line, buffer.empty() ? "ep> " : "> ")) {
+        appendChars(buffer, line.data(), line.size());
+        try {
+            Pragma::Flags flags = Pragma::es4;
+            Parser p(world, a, flags, buffer, ConsoleName);
+            if (showTokens) {
+                Lexer &l = p.lexer;
+                while (true) {
+                    const Token &t = l.get(true);
+                    if (t.hasKind(Token::end))
+                        break;
+                    stdOut << ' ';
+                    t.print(stdOut, true);
+                }
+                stdOut << '\n';
+            } else {
+                StmtNode *parsedStatements = p.parseProgram();
+                ASSERT(p.lexer.peek(true).hasKind(Token::end));
+                if (true)
+                {
+                    PrettyPrinter f(stdOut, 30);
+                    {
+                        PrettyPrinter::Block b(f, 2);
+                        f << "Program =";
+                        f.linearBreak(1);
+                        StmtNode::printStatements(f, parsedStatements);
+                    }
+                    f.end();
+                    stdOut << '\n';
+                }
+            }
+            clear(buffer);
+        } catch (Exception &e) {
+            // If we got a syntax error on the end of input, then wait for a continuation
+            // of input rather than printing the error message.
+            if (!(e.hasKind(Exception::syntaxError) && e.lineNum && e.pos == buffer.size() &&
+                  e.sourceFile == ConsoleName)) {
+                stdOut << '\n' << e.fullMessage();
+                clear(buffer);
+                result = EXITCODE_RUNTIME_ERROR;
+            }
+        }
+    }
+    stdOut << '\n';
+    return result;
+}
+
+static bool processArgs(int argc, char **argv, int *result)
+{
+    bool doInteractive = true;
+    for (int i = 0; i < argc; i++)  {    
+        if (argv[i][0] == '-') {
+            switch (argv[i][1]) {
+            default:
+                stdOut << "unrecognized command line switch\n";
+                i = argc;
+                break;
+            case 'f':
+                {
+                    try {
+//                        cx->readEvalFile(JavaScript::widenCString(argv[++i]));
+                    } catch (Exception &e) {
+                        stdOut << '\n' << e.fullMessage();
+                        *result = EXITCODE_RUNTIME_ERROR;
+                        return false;
+                    }
+                    doInteractive = false;
+                }
+                break;
+            }
+        }
+        else {
+            if ((argv[i][0] == '/') && (argv[i][1] == '/')) {
+                // skip rest of command line
+                break;
+            }
+        }
+    }
+    return doInteractive;
+}
+
+} /* namespace Shell */
+} /* namespace JavaScript */
+
+
+int main(int argc, char **argv)
+{
+    using namespace JavaScript;
+    using namespace Shell;
+    
+#if defined(XP_MAC) && !defined(XP_MAC_MPW)
+    initConsole("\pJavaScript Shell", "Welcome to Epimetheus.\n", argc, argv);
+#else
+    stdOut << "Welcome to Epimetheus.\n";
+#endif
+
+    try {
+        bool doInteractive = true;
+        int result = 0;
+        if (argc > 1) {
+            doInteractive = processArgs(argc - 1, argv + 1, &result);
+        }
+        if (doInteractive)
+            result = readEvalPrint(stdin);
+
+        return result;
+    }
+    catch (Exception &e) {
+        stdOut << '\n' << e.fullMessage();
+        return EXITCODE_RUNTIME_ERROR;
+    }
+}

js2/src/js2metadata.h

@@ -0,0 +1,245 @@
+
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+*
+* The contents of this file are subject to the Netscape Public
+* License Version 1.1 (the "License"); you may not use this file
+* except in compliance with the License. You may obtain a copy of
+* the License at http://www.mozilla.org/NPL/
+*
+* Software distributed under the License is distributed on an "AS
+* IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+* implied. See the License for the specific language governing
+* rights and limitations under the License.
+*
+* The Original Code is the JavaScript 2 Prototype.
+*
+* The Initial Developer of the Original Code is Netscape
+* Communications Corporation.   Portions created by Netscape are
+* Copyright (C) 1998 Netscape Communications Corporation. All
+* Rights Reserved.
+*
+* Contributor(s):
+*
+* Alternatively, the contents of this file may be used under the
+* terms of the GNU Public License (the "GPL"), in which case the
+* provisions of the GPL are applicable instead of those above.
+* If you wish to allow use of your version of this file only
+* under the terms of the GPL and not to allow others to use your
+* version of this file under the NPL, indicate your decision by
+* deleting the provisions above and replace them with the notice
+* and other provisions required by the GPL.  If you do not delete
+* the provisions above, a recipient may use your version of this
+* file under either the NPL or the GPL.
+*/
+
+
+#include "world.h"
+#include "utilities.h"
+
+
+namespace JavaScript {
+namespace MetaData {
+
+
+// forward definitions:
+class JS2Class;
+typedef uint32 js2val;
+
+typedef void (Invokable)();
+typedef Invokable Callor;
+typedef Invokable Constructor;
+
+class JS2Object {
+// Every object is either undefined, null, a Boolean,
+// a number, a string, a namespace, a compound attribute, a class, a method closure, 
+// a prototype instance, a class instance, a package object, or the global object.
+public:
+};
+
+class Namespace {
+public:
+    StringAtom &name;       // The namespace's name used by toString
+};
+
+
+class QualifiedName {
+public:
+    Namespace nameSpace;    // The namespace qualifier
+    StringAtom &id;         // The name
+};
+
+
+class Object_Uninit_Future {
+public:
+    enum { Object, Uninitialized, Future } state;
+    js2val value;
+};
+
+class NamedParameter {
+public:
+    StringAtom &name;      // This parameter's name
+    JS2Class *type;        // This parameter's type
+};
+
+class Signature {
+    JS2Class **requiredPositional;      // List of the types of the required positional parameters
+    JS2Class **optionalPositional;      // List of the types of the optional positional parameters, which follow the
+                                        // required positional parameters
+    NamedParameter **optionalNamed;     // Set of the types and names of the optional named parameters
+    JS2Class *rest;                     // The type of any extra arguments that may be passed or null if no extra
+                                        // arguments are allowed
+    bool restAllowsNames;               // true if the extra arguments may be named
+    bool returnType;                    // The type of this function's result
+};
+
+class StaticMember {
+public:
+};
+
+class Variable : public StaticMember {
+public:
+    JS2Class *type;                 // Type of values that may be stored in this variable
+    Object_Uninit_Future value;     // This variable's current value; future if the variable has not been declared yet;
+                                    // uninitialised if the variable must be written before it can be read
+    bool immutable;                 // true if this variable's value may not be changed once set
+};
+
+class HoistedVar : public StaticMember {
+public:
+    js2val value;                   // This variable's current value
+};
+
+class StaticMethod : public StaticMember {
+public:
+    Signature type;         // This function's signature
+    Invokable *code;        // This function itself (a callable object)
+    enum { Static, Constructor }
+        modifier;           // static if this is a function or a static method; constructor if this is a constructor for a class
+};
+
+class Accessor : public StaticMember {
+public:
+    JS2Class *type;         // The type of the value read from the getter or written into the setter
+    Invokable *code;        // calling this object does the read or write
+};
+
+
+
+
+class StaticBinding {
+public:
+    QualifiedName qname;        // The qualified name bound by this binding
+    StaticMember content;       // The member to which this qualified name was bound
+    bool xplicit;               // true if this binding should not be imported into the global scope by an import statement
+};
+
+
+class InstanceMember {
+public:
+    bool final;             // true if this member may not be overridden in subclasses
+};
+
+class InstanceVariable : public InstanceMember {
+public:
+    JS2Class *type;                 // Type of values that may be stored in this variable
+    Invokable *evalInitialValue;    // A function that computes this variable's initial value
+    bool immutable;                 // true if this variable's value may not be changed once set
+    bool final;
+};
+
+class InstanceMethod : public InstanceMember {
+public:
+    Signature type;         // This method's signature
+    Invokable *code;        // This method itself (a callable object); null if this method is abstract
+};
+
+class InstanceAccessor : public InstanceMember {
+public:
+    JS2Class *type;         // The type of the value read from the getter or written into the setter
+    Invokable *code;        // A callable object which does the read or write; null if this method is abstract
+};
+
+class InstanceBinding {
+public:
+    QualifiedName qname;        // The qualified name bound by this binding
+    InstanceMember *content;     // The member to which this qualified name was bound
+};
+
+class StaticBindingMap {
+public:
+};
+
+class InstanceBindingMap {
+public:
+};
+
+class JS2Class {
+public:
+        
+    StaticBindingMap staticReadBindings;        // Map of qualified names to readable static members defined in this class
+    StaticBindingMap staticWriteBindings;       // Map of qualified names to writable static members defined in this class
+
+    InstanceBindingMap instanceReadBindings;    // Map of qualified names to readable instance members defined in this class    
+    InstanceBindingMap instanceWriteBindings;   // Map of qualified names to writable instance members defined in this class    
+
+    InstanceVariable **instanceInitOrder;       // List of instance variables defined in this class in the order in which they are initialised
+
+    bool complete;                              // true after all members of this class have been added to this CLASS record
+
+    JS2Class    *super;                         // This class's immediate superclass or null if none
+    JS2Object   *prototype;                     // An object that serves as this class's prototype for compatibility with ECMAScript 3; may be null
+
+    Namespace privateNamespace;                 // This class's private namespace
+
+    bool dynamic;                               // true if this class or any of its ancestors was defined with the dynamic attribute
+    bool primitive;                             // true if this class was defined with the primitive attribute
+    bool final;                                 // true if this class cannot be subclassed
+
+    Callor call;                                // A procedure to call when this class is used in a call expression
+    Constructor construct;                      // A procedure to call when this class is used in a new expression
+
+};
+
+
+
+
+class LexicalReference {
+// A LEXICALREFERENCE tuple has the fields below and represents an lvalue that refers to a variable with one
+// of a given set of qualified names. LEXICALREFERENCE tuples arise from evaluating identifiers a and qualified identifiers
+// q::a.
+public:
+    Environment *env;               // The environment in which the reference was created.
+    Multiname variableMultiname;    // A nonempty set of qualified names to which this reference can refer
+    Context *cxt;                   // The context in effect at the point where the reference was created
+};
+
+class DotReference {
+// A DOTREFERENCE tuple has the fields below and represents an lvalue that refers to a property of the base
+// object with one of a given set of qualified names. DOTREFERENCE tuples arise from evaluating subexpressions such as a.b or
+// a.q::b.
+public:
+    JS2Object *base;                // The object whose property was referenced (a in the examples above). The
+                                    // object may be a LIMITEDINSTANCE if a is a super expression, in which case
+                                    // the property lookup will be restricted to members defined in proper ancestors
+                                    // of base.limit.
+    Multiname propertyMultiname;    // A nonempty set of qualified names to which this reference can refer (b
+                                    // qualified with the namespace q or all currently open namespaces in the
+                                    // example above)
+};
+
+class BracketReference {
+// A BRACKETREFERENCE tuple has the fields below and represents an lvalue that refers to the result of
+// applying the [] operator to the base object with the given arguments. BRACKETREFERENCE tuples arise from evaluating
+// subexpressions such as a[x] or a[x,y].
+public:
+    JS2Object *base;                // The object whose property was referenced (a in the examples above). The object may be a
+                                    // LIMITEDINSTANCE if a is a super expression, in which case the property lookup will be
+                                    // restricted to definitions of the [] operator defined in proper ancestors of base.limit.
+    ArgumentList args;              // The list of arguments between the brackets (x or x,y in the examples above)
+};
+
+
+
+
+}; // namespace MetaData
+}; // namespace Javascript

js2/src/numerics.cpp

@@ -36,7 +36,7 @@
 #include <cfloat>
 #include "numerics.h"
 #include "parser.h"
-#include "js2runtime.h"
+//#include "js2runtime.h"
 
 #include "fdlibm_ns.h"
 
@@ -248,7 +248,7 @@ InitNumerics::InitNumerics()
     JS::maxValue = 1.7976931348623157E+308;
 }
 
-
+#ifdef DIKDIK
 // had to move these here since they depend upon the values
 // initialized above, and we can't guarantee order other than
 // lexically in a single file.
@@ -261,7 +261,7 @@ js2val JS::JS2Runtime::kNegativeZero = JSValue::newNumber(-0.0);
 js2val JS::JS2Runtime::kPositiveZero = JSValue::newNumber(0.0);
 js2val JS::JS2Runtime::kNegativeInfinity = JSValue::newNumber(negativeInfinity);
 js2val JS::JS2Runtime::kPositiveInfinity = JSValue::newNumber(positiveInfinity);
-
+#endif
 //
 // Portable double-precision floating point to string and back conversions
 //

js2/src/parser.h

@@ -40,10 +40,13 @@
 #include "lexer.h"
 #include <vector>
 
+#ifdef DIKDIK
 #include "property.h"
+#endif
 
 namespace JavaScript {
 
+#ifdef DIKDIK
     // forward declarations to classes in the back-end
     namespace JS2Runtime {
         class JSFunction;
@@ -51,7 +54,7 @@ namespace JavaScript {
         class JSObject;
         class Attribute;
     }
-
+#endif
 
 //
 // Pragmas
@@ -125,8 +128,10 @@ namespace JavaScript {
         ExprNode *initializer;          // Initial value expression or nil if not provided
         bool constant;                  // true for const variables and parameters
 
+#ifdef DikDik
         JS2Runtime::Property *prop;     // the sematics/codegen passes stuff their data in here.
         JS2Runtime::JSObject *scope;    // ditto
+#endif
 
         VariableBinding(size_t pos, const StringAtom *name, ExprNode *type, ExprNode *initializer, bool constant):
                 ParseNode(pos), next(0), name(name), type(type), initializer(initializer), constant(constant) {}
@@ -505,7 +510,9 @@ namespace JavaScript {
     struct AttributeStmtNode: StmtNode {
         ExprNode *attributes;           // Directive's attributes; nil if none
 
+#ifdef DIKDIK
         JS2Runtime::Attribute *attributeValue;      // used by backend
+#endif
 
         AttributeStmtNode(size_t pos, Kind kind, ExprNode *attributes): StmtNode(pos, kind), attributes(attributes) {}
 
@@ -590,7 +597,9 @@ namespace JavaScript {
         bool constant;                  // true for const variables
         StmtNode *stmt;                 // The catch clause's body; non-nil only
 
+#ifdef DIKDIK
         JS2Runtime::Property *prop;     // the sematics/codegen passes stuff their data in here.
+#endif
 
         CatchClause(size_t pos, const StringAtom &name, ExprNode *type, bool constant, StmtNode *stmt):
                 ParseNode(pos), next(0), name(name), type(type), constant(constant), stmt(stmt) {ASSERT(stmt);}
@@ -637,8 +646,9 @@ namespace JavaScript {
 
     struct FunctionStmtNode: AttributeStmtNode {
         FunctionDefinition function;    // Function definition
+#ifdef DIKDIK
         JS2Runtime::JSFunction *mFunction; // used by backend
-
+#endif
         FunctionStmtNode(size_t pos, Kind kind, ExprNode *attributes): AttributeStmtNode(pos, kind, attributes) {}
 
         void print(PrettyPrinter &f, bool noSemi) const;
@@ -657,7 +667,9 @@ namespace JavaScript {
         ExprNode *superclass;           // Superclass expression (classes only); nil if omitted
         BlockStmtNode *body;            // The class's body; nil if omitted
 
+#ifdef DIKDIK
         JS2Runtime::JSType *mType;      // used by backend
+#endif
 
         ClassStmtNode(size_t pos, ExprNode *attributes, const StringAtom &name, ExprNode *superclass, BlockStmtNode *body):
                 NamespaceStmtNode(pos, Class, attributes, name), superclass(superclass), body(body) {}
@@ -716,7 +728,10 @@ namespace JavaScript {
         IdentifierList *packageIdList;  // The package name as a list of identifiers; may be nil
         BlockStmtNode *body;            // The package's body; non-nil only
 
+#ifdef DIKDIK
         JS2Runtime::JSObject *scope;    // the sematics/codegen passes stuff their data in here.
+#endif
+
 
         PackageStmtNode(size_t pos, IdentifierList *packageIdList, BlockStmtNode *body):
                 StmtNode(pos, Package), packageIdList(packageIdList), body(body) {ASSERT(body);}

js2/src/winbuild/Epimetheus/Epimetheus.dsp

@@ -0,0 +1,200 @@
+# Microsoft Developer Studio Project File - Name="Epimetheus" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Console Application" 0x0103
+
+CFG=Epimetheus - Win32 Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE 
+!MESSAGE NMAKE /f "Epimetheus.mak".
+!MESSAGE 
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "Epimetheus.mak" CFG="Epimetheus - Win32 Debug"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "Epimetheus - Win32 Release" (based on "Win32 (x86) Console Application")
+!MESSAGE "Epimetheus - Win32 Debug" (based on "Win32 (x86) Console Application")
+!MESSAGE 
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+RSC=rc.exe
+
+!IF  "$(CFG)" == "Epimetheus - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
+# ADD CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
+# ADD BASE RSC /l 0x409 /d "NDEBUG"
+# ADD RSC /l 0x409 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib  kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib  kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
+
+!ELSEIF  "$(CFG)" == "Epimetheus - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "Debug"
+# PROP Intermediate_Dir "Debug"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ  /c
+# ADD CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /FR /YX /FD /GZ  /c
+# ADD BASE RSC /l 0x409 /d "_DEBUG"
+# ADD RSC /l 0x409 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib  kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib  kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
+
+!ENDIF 
+
+# Begin Target
+
+# Name "Epimetheus - Win32 Release"
+# Name "Epimetheus - Win32 Debug"
+# Begin Group "Source Files"
+
+# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
+# Begin Source File
+
+SOURCE=..\..\epimetheus.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\exception.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\formatter.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\hash.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\lexer.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\mem.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\numerics.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\parser.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\reader.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\strings.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\token.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\utilities.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\world.cpp
+# End Source File
+# End Group
+# Begin Group "Header Files"
+
+# PROP Default_Filter "h;hpp;hxx;hm;inl"
+# Begin Source File
+
+SOURCE=..\..\exception.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\formatter.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\hash.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\lexer.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\mem.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\numerics.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\parser.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\reader.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\stlcfg.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\strings.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\token.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\utilities.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\world.h
+# End Source File
+# End Group
+# Begin Group "Resource Files"
+
+# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"
+# End Group
+# End Target
+# End Project

js2/src/winbuild/Epimetheus/Epimetheus.dsw

@@ -0,0 +1,29 @@
+Microsoft Developer Studio Workspace File, Format Version 6.00
+# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
+
+###############################################################################
+
+Project: "Epimetheus"=.\Epimetheus.dsp - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+}}}
+
+###############################################################################
+
+Global:
+
+Package=<5>
+{{{
+}}}
+
+Package=<3>
+{{{
+}}}
+
+###############################################################################
+