Changeset 343

Timestamp:

08/22/08 09:44:18 (3 months ago)

Author:

JarrettBillingsley

Message:

charlib.

Files:

• branches/v2new/minid/api.d (modified) (2 diffs)
• branches/v2new/minid/charlib.d (modified) (3 diffs)
• branches/v2new/minid/interpreter.d (modified) (1 diff)
• branches/v2new/minid/parser.d (modified) (1 diff)
• branches/v2new/minid/vm.d (modified) (1 diff)
• branches/v2new/samples/simple.md (modified) (1 diff)
• branches/v2new/test.d (modified) (1 diff)

branches/v2new/minid/api.d

@@ -42 +42 @@
-
-import minid.baselib;
+import minid.charlib;
-
-// ================================================================================================================================================
@@ -99 +100 @@
-
-/**
+This enumeration is used with the NewContext function to specify which standard libraries you
+want to load into the new context.  The base library is always loaded, so there is no
+flag for it.  You can choose which libraries you want to load by ORing together multiple
+flags.
+*/
+public enum MDStdlib
+{
+    /**
+    Nothing but the base library will be loaded if you specify this flag.
+    */
+    None =      0,
+
+    /**
+    Array manipulation.
+    */
+    Array =     1,
+
+    /**
+    Character classification.
+    */
+    Char =      2,
+
+    /**
+    Stream-based input and output.
+    */
+    IO =        4,
+
+    /**
+    Standard math functions.
+    */
+    Math =      8,
+
+    /**
+    String manipulation.
+    */
+    String =   16,
+
+    /**
+    Table manipulation.
+    */
+    Table =    32,
+
+    /**
+    OS-specific functionality.
+    */
+    OS =       64,
+
+    /**
+    Regular expressions.
+    */
+    Regexp =  128,
+
+    /**
+    This flag is an OR of Array, Char, Math, String, Table, and Regexp.  It represents all
+    the libraries which are "safe", i.e. malicious scripts would not be able to use the IO
+    or OS libraries to do bad things.
+    */
+    Safe = Array | Char | Math | String | Table | Regexp,
+
+    /**
+    All available standard libraries.
+    */
+    All = Safe | IO | OS,
+}
+
+/**
+Load the standard libraries into the context of the given thread.  
+
+Params:
+    libs = An ORing together of any standard libraries you want to load (see the MDStdlib enum).
+        Defaults to MDStdlib.All.
+*/
+public void loadStdlibs(MDThread* t, uint libs = MDStdlib.All)
+{
+//  if(libs & MDStdlib.Array)
+//      ArrayLib.init(ret);
+
+    if(libs & MDStdlib.Char)
+        CharLib.init(t);
+
+//  if(libs & MDStdlib.IO)
+//      IOLib.init(ret);
+// 
+//  if(libs & MDStdlib.Math)
+//      MathLib.init(ret);
+// 
+//  if(libs & MDStdlib.OS)
+//      OSLib.init(ret);
+// 
+//  if(libs & MDStdlib.Regexp)
+//      RegexpLib.init(ret);
+// 
+//  if(libs & MDStdlib.String)
+//      StringLib.init(ret);
+// 
+//  if(libs & MDStdlib.Table)
+//      TableLib.init(ret);
+}
+
+/**
-Closes a VM object and deallocates all memory associated with it.
-

branches/v2new/minid/charlib.d

@@ -1 +1 @@
-/******************************************************************************
-License:
-7
+8
-
-This software is provided 'as-is', without any express or implied warranty.
@@ -24 +24 @@
-module minid.charlib;
-
+import minid.ex;
+import minid.interpreter;
-import minid.types;
-
@@ -29 +31 @@
-import Uni = tango.text.Unicode;
-
-final class
+struct
-{
-static:
-Context contex
+Thread* 
-    {
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-    }
-
-int toLower(MDState s, uint
+uword toLower(MDThread* t, uword
-    {
-
-
+
+
+
+
-        return 1;
-    }
-
-int toUpper(MDState s, uint
+uword toUpper(MDThread* t, uword
-    {
-
-
+
+
+
+
-        return 1;
-    }
-
-int isAlpha(MDState s, uint
+uword isAlpha(MDThread* t, uword
-    {
-s.push(Uni.isLetter(s.getContext!(dchar
+pushBool(t, Uni.isLetter(checkCharParam(t, 0
-        return 1;
-    }
-
-int isAlNum(MDState s, uint
+uword isAlNum(MDThread* t, uword
-    {
-
-
-
-
-
-
-
+
-        return 1;
-    }
-
-int isUpper(MDState s, uint
+uword isLower(MDThread* t, uword
-    {
-s.push(Uni.isUpper(s.getContext!(dchar
+pushBool(t, Uni.isLower(checkCharParam(t, 0
-        return 1;
-    }
-
-int isDigit(MDState s, uint
+uword isUpper(MDThread* t, uword
-    {
-s.push(Uni.isDigit(s.getContext!(dchar
+pushBool(t, Uni.isUpper(checkCharParam(t, 0
-        return 1;
-    }
-
-int isCtrl(MDState s, uint
+uword isDigit(MDThread* t, uword
-    {
-s.push(cast(bool)iscntrl(s.getContext!(dchar
+pushBool(t, Uni.isDigit(checkCharParam(t, 0
-        return 1;
-    }
-
-int isPunct(MDState s, uint
+
+uword isCtrl(MDThread* t, uword
-    {
-s.push(cast(bool)ispunct(s.getContext!(dchar
+pushBool(t, cast(bool)iscntrl(checkCharParam(t, 0
-        return 1;
-    }
-
-int isSpace(MDState s, uint
+
+uword isPunct(MDThread* t, uword
-    {
-s.push(cast(bool)isspace(s.getContext!(dchar
+pushBool(t, cast(bool)ispunct(checkCharParam(t, 0
-        return 1;
-    }
-
-int isHexDigit(MDState s, uint
+
+uword isSpace(MDThread* t, uword
-    {
-s.push(cast(bool)isxdigit(s.getContext!(dchar
+pushBool(t, cast(bool)isspace(checkCharParam(t, 0
-        return 1;
-    }
-
-int isAscii(MDState s, uint
+
+uword isHexDigit(MDThread* t, uword
-    {
-s.push(s.getContext!(dchar) <= 0x7f
+pushBool(t, cast(bool)isxdigit(checkCharParam(t, 0))
-        return 1;
-    }
-
-int isValid(MDState s, uint
+
+uword isAscii(MDThread* t, uword
-    {
-
-
+
+
+
+
+
+
+
+
-        return 1;
-    }

branches/v2new/minid/interpreter.d

@@ -2809 +2809 @@
-
-    return stackSize(t) - 1;
+}
+
+/**
+An odd sort of protective function.  You can use this function to wrap a call to a library function etc. which
+could throw an exception, but when you don't want to have to bother with catching the exception yourself.  Useful
+for writing native MiniD libraries.
+
+Say you had a function which opened a file:
+
+-----
+File f = OpenFile("filename");
+-----
+
+Say this function could throw an exception if it failed.  Since the interpreter can only catch (and make meaningful
+stack traces about) exceptions which derive from MDException, any exceptions that this throws would just percolate
+up out of the interpreter stack.  You could catch the exception yourself, but that's kind of tedious, especially when
+you call a lot of native functions.
+
+Instead, you can wrap the call to this unsafe function with a call to safeCode().
+
+-----
+File f = safeCode(t, OpenFile("filename"));
+-----
+
+What safeCode() does is it tries to execute the code it is passed.  If it succeeds, it simply returns any value that
+the code returns.  If it throws an exception derived from MDException, it rethrows the exception.  And if it throws
+an exception that derives from Exception, it throws a new MDException with the original exception's message as the
+message.
+
+safeCode() is templated to allow any return value.
+
+Params:
+    code = The code to be executed.  This is a lazy parameter, so it's not actually executed until inside the call to
+        safeCode.
+
+Returns:
+    Whatever the code parameter returns.
+*/
+public T safeCode(T)(MDThread* t, lazy T code)
+{
+    try
+        return code;
+    catch(MDException e)
+        throw e;
+    catch(Exception e)
+        throwException(t, "{}", e);
+        
+    assert(false);
-}
-

branches/v2new/minid/parser.d

@@ -2146 +2146 @@
-
-        if(l.type == Token.True)
+        {
+            l.expect(Token.True);
-            return new(c) BoolExp(c, loc, true);
+        }
-        else
-        {

branches/v2new/minid/vm.d

@@ -192 +192 @@
-// ================================================================================================================================================
-
-//  1.  See if already loaded.
-
-//  2.  See if that name is taken.
-
-//  3.  Look for .md and .mdm.  If found, create closure with new namespace env, call.
-//      if it succeeds, put that namespace in the owning namespace.
-
-//  4.  Look for custom loader.  If found, call with name of module to get loader func.
-//      call that with new namespace as env, and if it succeeds, put ns in owning ns.
-
-//  5.  [Optional] Look for dynlib, same procedure as 4.
-
-package void openVMImpl(MDVM* vm, MemFunc memFunc, void* ctx = null)
-{

branches/v2new/samples/simple.md

@@ -1 +1 @@
-module simple
-
-
-
-
-
-
+
-
-/+

branches/v2new/test.d

@@ -34 +34 @@
-    auto vm = new MDVM;
-    auto t = openVM(vm);
+    loadStdlibs(t);
-
-    // This is all stdlib crap!