Changeset 136 for NEWT0/trunk

Timestamp:

02/17/09 04:50:42 (3 years ago)

Author:

matthiasm

Message:

Added 'MakeBinaryFromHex(hex, class)'. Added 'LoadBinary(filename)'. Added 'SaveBinary(bin, filename)'. Added global variable 'printBinaries' which will print binary objects so that they can be recompiled into the original binary.

Location:

NEWT0/trunk/src

Files:

• newt_core/NewtEnv.c (modified) (1 diff)
• newt_core/NewtFile.c (modified) (1 diff)
• newt_core/NewtFns.c (modified) (1 diff)
• newt_core/NewtObj.c (modified) (1 diff)
• newt_core/NewtPrint.c (modified) (4 diffs)
• newt_core/NewtVM.c (modified) (2 diffs)
• newt_core/incs/NewtEnv.h (modified) (2 diffs)
• newt_core/incs/NewtFile.h (modified) (1 diff)
• newt_core/incs/NewtFns.h (modified) (2 diffs)
• version.h (modified) (2 diffs)

NEWT0/trunk/src/newt_core/NewtEnv.c

@@ -199 +199 @@
     // for print
     INITSYM(printDepth);
+    INITSYM(printIndent);
     INITSYM(printLength);
+    INITSYM(printBinaries);
 
     // for regex

NEWT0/trunk/src/newt_core/NewtFile.c

@@ -759 +759 @@
     return NewtExpandPath(NewtRefToString(r));
 }
+
+
+/*------------------------------------------------------------------------*/
+/** Read a file and create a binary object.
+ *
+ * @param rcvr      [in] receiver
+ * @param r     [in] filename
+ *
+ * @return      binary object containing the entire file data
+ */
+
+newtRef NsLoadBinary(newtRefArg rcvr, newtRefArg r)
+{
+    if (NewtRefIsString(r)) {
+        char *filename = NewtRefToString(r);
+        FILE *f = fopen(filename, "rb");
+        if (!f)
+            return NewtThrow(kNErrFileNotFound, r);
+        fseek(f, 0, SEEK_END);
+        size_t size = ftell(f);
+        fseek(f, 0, SEEK_SET);
+        uint8_t *data = (uint8_t*)malloc(size);
+        int err = fread(data, size, 1, f);
+        fclose(f);
+        return NewtMakeBinary(NSSYM(data), data, size, false); 
+    } else {
+        return NewtThrow(kNErrNotAString, r);
+    }
+}
+
+/*------------------------------------------------------------------------*/
+/** Save a binary object to a file.
+ *
+ * @param rcvr      [in] receiver
+ * @param r1        [in] binary object
+ * @param r2        [in] filename
+ *
+ * @return      error code
+ */
+
+newtRef NsSaveBinary(newtRefArg rcvr, newtRefArg r1, newtRefArg r2)
+{
+    if (NewtRefIsBinary(r1)) {
+        if (NewtRefIsString(r2)) {
+            char *filename = NewtRefToString(r2);
+            FILE *f = fopen(filename, "wb");
+            if (!f)
+                return NewtThrow(kNErrFileNotFound, r2);
+            uint8_t *data = NewtRefToBinary(r1);
+            int size = NewtBinaryLength(r1);
+            fwrite(data, size, 1, f);
+            fclose(f);
+            return kNewtRefNIL;
+        } else {
+            return NewtThrow(kNErrNotAString, r2);
+        }
+    } else {
+        return NewtThrow(kNErrNotABinaryObject, r1);
+    }
+}
+
+

NEWT0/trunk/src/newt_core/NewtFns.c

@@ -1384 +1384 @@
 
 
+/*------------------------------------------------------------------------*/
+/** Create a binary object from a string containing hexadecimal numbers.
+ *
+ * @param rcvr      [in] receiver
+ * @param hex       [in] hexadecimal number pairs
+ * @param klass     [in] class of new binary object
+ *
+ * @return          a new binary object
+ */
+
+newtRef NsMakeBinaryFromHex(newtRefArg rcvr, newtRefArg hex, newtRefArg klass)
+{
+    if (! NewtRefIsString(hex))
+        return NewtThrow(kNErrNotAString, hex);
+
+    return NewtMakeBinaryFromHex(klass, NewtRefToString(hex), false);
+}
+
+
 #if 0
 #pragma mark -

NEWT0/trunk/src/newt_core/NewtObj.c

@@ -1211 +1211 @@
 
 /*------------------------------------------------------------------------*/
+/** Make a binary object from a string of hexadecimal numbers.
+ *
+ * @param klass         [in] new class 
+ * @param hex           [in] string of hexadecimal numbers
+ * @param literal       [in] make new object a literal
+ *
+ * @return                      new binary object
+ */
+
+newtRef NewtMakeBinaryFromHex(newtRefArg klass, const char *hex, bool literal)
+{
+    uint32_t size = strlen(hex)/2;
+    newtObjRef obj = NewtMakeBinary(klass, 0, size, literal);
+    if (obj) {
+        uint32_t i;
+        const char *src = hex;
+        uint8_t *dst = NewtRefToBinary(obj);
+        for (i=0; i<size; i++) {
+            uint8_t c = *src++, v = 0;
+            if (c>='a') v = c-'a'+10; else if (c>='A') v = c-'A'+10; else v = c-'0';
+            c = *src++; v = v<<4;
+            if (c>='a') v += c-'a'+10; else if (c>='A') v += c-'A'+10; else v += c-'0';
+            *dst++ = v;
+        }
+        return obj;
+    }
+    return kNewtRefUnbind;
+}
+
+
+/*------------------------------------------------------------------------*/
 /** バイナリオブジェクトのオブジェクトデータのサイズを変更する
  *

NEWT0/trunk/src/newt_core/NewtPrint.c

@@ -25 +25 @@
 static int32_t      NewtGetPrintLength(void);
 static int32_t      NewtGetPrintDepth(void);
+static int32_t      NewtGetPrintIndent(void);
+static int32_t      NewtGetPrintBinaries(void);
 
 static bool         NewtSymbolIsPrint(char * str, int len);
@@ -105 +107 @@
 
 
+/*------------------------------------------------------------------------*/
+/** Get the number of tabs (or spaces if negative) for indenting.
+ *
+ * @return          number of characters to indent
+ */
+
+int32_t NewtGetPrintIndent(void)
+{
+    newtRefVar  n;
+    int32_t     indent = 1;
+
+    n = NcGetGlobalVar(NSSYM0(printIndent));
+
+    if (NewtRefIsInteger(n))
+        indent = NewtRefToInteger(n);
+
+    return indent;
+}
+
+
+/*------------------------------------------------------------------------*/
+/** If set, brint binary objects as well.
+ *
+ * @return          0 or 1
+ */
+
+int32_t NewtGetPrintBinaries(void)
+{
+    newtRefVar  n;
+    int32_t     pb = 0;
+
+    n = NcGetGlobalVar(NSSYM0(printBinaries));
+
+    if (NewtRefIsInteger(n))
+        pb = NewtRefToInteger(n);
+
+    return pb;
+}
+
+
 #if 0
 #pragma mark -
@@ -472 +514 @@
     ptr = r;
     len = NewtBinaryLength(r);
-    NIOFputs("<Binary, ", f);
-
-    //
     klass = NcClassOf(r);
-
-    if (NewtRefIsSymbol(klass))
+    if (newt_env._printBinaries)
     {
-        NIOFputs("class \"", f);
-        NIOPrintObj2(f, klass, 0, true);
-        NIOFputs("\", ", f);
+        uint8_t *data = NewtRefToBinary(r);
+        NIOFputs("MakeBinaryFromHex(\"", f);
+        int i; for (i=0; i<len; i++) NIOFprintf(f, "%02X", data[i]);
+        if (NewtRefIsSymbol(klass))
+        {
+            NIOFputs("\", '", f);
+            NIOPrintObj2(f, klass, 0, true);
+            NIOFputs(")", f);
+        } else {
+            NIOFputs("\", NIL)", f);
+        }
+    } else {
+        NIOFputs("<Binary, ", f);
+        if (NewtRefIsSymbol(klass))
+        {
+            NIOFputs("class \"", f);
+            NIOPrintObj2(f, klass, 0, true);
+            NIOFputs("\", ", f);
+        }
+        NIOFprintf(f, "length %d>", len);
     }
-
-    NIOFprintf(f, "length %d>", len);
 }
 
@@ -911 +964 @@
     int32_t depth = NewtGetPrintDepth();
     newt_env._indentDepth = depth;
+    int32_t indent = NewtGetPrintIndent();
+    newt_env._indent = indent;
+    int32_t pb = NewtGetPrintBinaries();
+    newt_env._printBinaries = pb;
     NIOPrintObj2(f, r, depth, false);
 }

NEWT0/trunk/src/newt_core/NewtVM.c

@@ -3609 +3609 @@
     NewtDefGlobalFunc(NSSYM(Require),   NsRequire,          1, "Require(str)");
 
+    NewtDefGlobalFunc(NSSYM(LoadBinary),        NsLoadBinary,       1, "LoadBinary(filename)");
+    NewtDefGlobalFunc(NSSYM(SaveBinary),        NsSaveBinary,       2, "SaveBinary(data, filename)");
+    NewtDefGlobalFunc(NSSYM(MakeBinaryFromHex),     NsMakeBinaryFromHex,    2, "MakeBinaryFromHex(hexString, class)");
+
     NewtDefGlobalFunc(NSSYM(MakeNSOF),  NsMakeNSOF,         2, "MakeNSOF(obj, ver)");
     NewtDefGlobalFunc(NSSYM(ReadNSOF),  NsReadNSOF,         1, "ReadNSOF(nsof)");
@@ -3674 +3678 @@
 {
     NcDefGlobalVar(NSSYM0(printDepth), NSINT(3));
+    NcDefGlobalVar(NSSYM0(printIndent), NSINT(1));
     NcDefGlobalVar(NSSYM0(printLength), NSINT(10));
+    NcDefGlobalVar(NSSYM0(printBinaries), NSINT(0));
 
     NcDefGlobalVar(NSSYM0(_STDOUT_), kNewtRefNIL);

NEWT0/trunk/src/newt_core/incs/NewtEnv.h

@@ -99 +99 @@
     int32_t     _indent;        ///< number of tabs for indenting a printout
     int32_t     _indentDepth;   ///< base for calculating the indent depth
+    int32_t     _printBinaries; ///< print binary objects so that they can be regenerated from the printout
 } newt_env_t;
 
@@ -198 +199 @@
     // for print
     newtRefVar  printDepth;         ///< printDepth
+    newtRefVar  printIndent;            ///< printIndent
     newtRefVar  printLength;        ///< printLength
+    newtRefVar  printBinaries;      ///< printBinaries
 
     // for regex

NEWT0/trunk/src/newt_core/incs/NewtFile.h

@@ -62 +62 @@
 newtRef     NsExpandPath(newtRefArg rcvr, newtRefArg r);
 
+newtRef     NsLoadBinary(newtRefArg rcvr, newtRefArg r);
+newtRef     NsSaveBinary(newtRefArg rcvr, newtRefArg r1, newtRefArg r2);
 
 #ifdef __cplusplus

NEWT0/trunk/src/newt_core/incs/NewtFns.h

@@ -52 +52 @@
 #define NcMakeFrame()               NsMakeFrame(kNewtRefNIL)
 #define NcMakeBinary(len, klass)    NsMakeBinary(kNewtRefNIL, len, klass)
+#define NcMakeBinaryFromHex(hex, klass) NsMakeBinaryFromHex(kNewtRefNIL, hex, klass)
 #define NcPrintObject(r)            NsPrintObject(kNewtRefNIL, r)
 #define NcPrint(r)                  NsPrint(kNewtRefNIL, r)
@@ -119 +120 @@
 newtRef     NsMakeFrame(newtRefArg rcvr);
 newtRef     NsMakeBinary(newtRefArg rcvr, newtRefArg length, newtRefArg klass);
+newtRef     NsMakeBinaryFromHex(newtRefArg rcvr, newtRefArg hex, newtRefArg klass);
 
 newtRef     NcBAnd(newtRefArg r1, newtRefArg r2);                   // bytecode

NEWT0/trunk/src/version.h

@@ -34 +34 @@
                         "  --newton,--nos2 Newton OS 2.0 compatible \n" \
                         "  --copyright     print copyright\n"           \
-                        "  --version       print version number\n"
+                        "  --version       print version number\n"  \
+                        "  --staff         list of developers\n"
 
 /// スタッフロール
@@ -42 +43 @@
                         "Contribute\n"                                  \
                         "  Paul Guyot\n"                                \
-                        "  Matthias\n"                                  \
+                        "  Matthias Melcher\n"                                  \
                         "\n"                                            \
                         "Special Thanks\n"                              \