Add opaque object array handling dispatch fix from Glulxe

Author: David Kinder

README.txt

@@ -192,6 +192,9 @@ also to Eliuk Blau for tracking down bugs in the memory management opcodes.
 
 * Version History
 
+1.3.0 2011-12-16  Fixed a bug in glkop.c dispatching, to do with arrays
+                  of opaque objects, following a similar fix in Glulxe.
+
 1.2.9 2011-08-28  Fixed a bug in glkop.c dispatching, to do with optional
                   array arguments, following a similar fix in Glulxe.
                   Glk array and string operations are now checked for memory

git.h

@@ -21,13 +21,8 @@
 #define _str2(s) #s
 #define _str(s) _str2(s)
 
-#if GIT_PATCH == 0
-#define GIT_VERSION_STR \
-_str(GIT_MAJOR) "." _str(GIT_MINOR)
-#else
 #define GIT_VERSION_STR \
 _str(GIT_MAJOR) "." _str(GIT_MINOR) "." _str(GIT_PATCH)
-#endif
 
 // git.c
 

glkop.c

@@ -24,6 +24,11 @@
      These macros are responsible for fixing byte-order and alignment
      (if the C ABI does not match the VM's). The passin, passout hints
      may be used to avoid unnecessary copying.
+   - A Glk object array is a sequence of integers in VM memory. It is
+     turned into a C pointer array (remember that C pointers may be more
+     than 4 bytes!) The pointer array is allocated by
+     CapturePtrArray(addr, len, objclass) and released by ReleasePtrArray().
+     Again, the macros handle the conversion.
    - A Glk structure (such as event_t) is a set of integers somewhere
      in VM memory, which can be read and written with the macros
      ReadStructField(addr, fieldnum) and WriteStructField(addr, fieldnum).
@@ -70,6 +75,10 @@
     (grab_temp_array(addr, len, passin))
 #define ReleaseIArray(ptr, addr, len, passout)  \
     (release_temp_array(ptr, addr, len, passout))
+#define CapturePtrArray(addr, len, objclass, passin)  \
+    (grab_temp_ptr_array(addr, len, objclass, passin))
+#define ReleasePtrArray(ptr, addr, len, objclass, passout)  \
+    (release_temp_ptr_array(ptr, addr, len, objclass, passout))
 #define ReadStructField(addr, fieldnum)  \
     (((addr) == 0xffffffff) \
       ? (gStackPointer -= 1, Stk4(gStackPointer)) \
@@ -228,6 +237,8 @@ static void glulxe_retained_unregister(void *array, glui32 len,
 
 static glui32 *grab_temp_array(glui32 addr, glui32 len, int passin);
 static void release_temp_array(glui32 *arr, glui32 addr, glui32 len, int passout);
+static void **grab_temp_ptr_array(glui32 addr, glui32 len, int objclass, int passin);
+static void release_temp_ptr_array(void **arr, glui32 addr, glui32 len, int objclass, int passout);
 
 static void prepare_glk_args(char *proto, dispatch_splot_t *splot);
 static void parse_glk_args(dispatch_splot_t *splot, char **proto, int depth,
@@ -277,16 +288,16 @@ glui32 git_perform_glk(glui32 funcnum, glui32 numargs, glui32 *arglist)
        directly -- instead of bothering with the whole prototype 
        mess. */
 
-  case 0x0047: /* stream_set_current */
-    if (numargs != 1)
-      goto WrongArgNum;
-    glk_stream_set_current(git_find_stream_by_id(arglist[0]));
-    break;
-  case 0x0048: /* stream_get_current */
-    if (numargs != 0)
-      goto WrongArgNum;
-    retval = git_find_id_for_stream(glk_stream_get_current());
-    break;
+  case 0x0047: /* stream_set_current */
+    if (numargs != 1)
+      goto WrongArgNum;
+    glk_stream_set_current(git_find_stream_by_id(arglist[0]));
+    break;
+  case 0x0048: /* stream_get_current */
+    if (numargs != 0)
+      goto WrongArgNum;
+    retval = git_find_id_for_stream(glk_stream_get_current());
+    break;
   case 0x0080: /* put_char */
     if (numargs != 1)
       goto WrongArgNum;
@@ -307,16 +318,16 @@ glui32 git_perform_glk(glui32 funcnum, glui32 numargs, glui32 *arglist)
       goto WrongArgNum;
     retval = glk_char_to_upper(arglist[0] & 0xFF);
     break;
-  case 0x0128: /* put_char_uni */
-    if (numargs != 1)
-      goto WrongArgNum;
-    glk_put_char_uni(arglist[0]);
-    break;
-  case 0x012B: /* put_char_stream_uni */
-    if (numargs != 2)
-      goto WrongArgNum;
-    glk_put_char_stream_uni(git_find_stream_by_id(arglist[0]), arglist[1]);
-    break;
+  case 0x0128: /* put_char_uni */
+    if (numargs != 1)
+      goto WrongArgNum;
+    glk_put_char_uni(arglist[0]);
+    break;
+  case 0x012B: /* put_char_stream_uni */
+    if (numargs != 2)
+      goto WrongArgNum;
+    glk_put_char_stream_uni(git_find_stream_by_id(arglist[0]), arglist[1]);
+    break;
 
   WrongArgNum:
     fatalError("Wrong number of arguments to Glk function.");
@@ -355,11 +366,11 @@ glui32 git_perform_glk(glui32 funcnum, glui32 numargs, glui32 *arglist)
     gidispatch_call(funcnum, argnum, splot.garglist);
 
     /* Phase 3. */
-    argnum2 = 0;
+    argnum2 = 0;
     cx = proto;
     unparse_glk_args(&splot, &cx, 0, &argnum2, 0, 0);
-    if (argnum != argnum2)
-      fatalError("Argument counts did not match.");
+    if (argnum != argnum2)
+      fatalError("Argument counts did not match.");
 
     break;
   }
@@ -582,11 +593,11 @@ static void parse_glk_args(dispatch_splot_t *splot, char **proto, int depth,
 
         switch (typeclass) {
         case 'C':
-          /* This test checks for a giant array length, and cuts it down to
-             something reasonable. Future releases of this interpreter may
-             treat this case as a fatal error. */
-          if (varglist[ix+1] > gEndMem || varglist[ix]+varglist[ix+1] > gEndMem)
-            varglist[ix+1] = gEndMem - varglist[ix];
+          /* This test checks for a giant array length, and cuts it down to
+             something reasonable. Future releases of this interpreter may
+             treat this case as a fatal error. */
+          if (varglist[ix+1] > gEndMem || varglist[ix]+varglist[ix+1] > gEndMem)
+            varglist[ix+1] = gEndMem - varglist[ix];
 
           garglist[gargnum].array = (void*) AddressOfArray(varglist[ix]);
           gargnum++;
@@ -596,9 +607,9 @@ static void parse_glk_args(dispatch_splot_t *splot, char **proto, int depth,
           cx++;
           break;
         case 'I':
-          /* See comment above. */
-          if (varglist[ix+1] > gEndMem/4 || varglist[ix+1] > (gEndMem-varglist[ix])/4)
-              varglist[ix+1] = (gEndMem - varglist[ix]) / 4;
+          /* See comment above. */
+          if (varglist[ix+1] > gEndMem/4 || varglist[ix+1] > (gEndMem-varglist[ix])/4)
+              varglist[ix+1] = (gEndMem - varglist[ix]) / 4;
 
           garglist[gargnum].array = CaptureIArray(varglist[ix], varglist[ix+1], passin);
           gargnum++;
@@ -607,6 +618,16 @@ static void parse_glk_args(dispatch_splot_t *splot, char **proto, int depth,
           gargnum++;
           cx++;
           break;
+        case 'Q':
+          /* This case was added after the giant arrays were deprecated,
+             so we don't bother to allow for that case. */
+          garglist[gargnum].array = CapturePtrArray(varglist[ix], varglist[ix+1], (*cx-'a'), passin);
+          gargnum++;
+          ix++;
+          garglist[gargnum].uint = varglist[ix];
+          gargnum++;
+          cx++;
+          break;
         default:
           fatalError("Illegal format string.");
           break;
@@ -711,8 +732,8 @@ static void parse_glk_args(dispatch_splot_t *splot, char **proto, int depth,
       }
       else {
         cx++;
-        if (isarray)
-          ix++;
+        if (isarray)
+          ix++;
       }
     }    
   }
@@ -804,6 +825,13 @@ static void unparse_glk_args(dispatch_splot_t *splot, char **proto, int depth,
           gargnum++;
           cx++;
           break;
+        case 'Q':
+          ReleasePtrArray(garglist[gargnum].array, varglist[ix], varglist[ix+1], (*cx-'a'), passout);
+          gargnum++;
+          ix++;
+          gargnum++;
+          cx++;
+          break;
         default:
           fatalError("Illegal format string.");
           break;
@@ -919,8 +947,8 @@ static void unparse_glk_args(dispatch_splot_t *splot, char **proto, int depth,
       }
       else {
         cx++;
-        if (isarray)
-          ix++;
+        if (isarray)
+          ix++;
       }
     }    
   }
@@ -952,20 +980,20 @@ strid_t git_find_stream_by_id(glui32 objid)
   return classes_get(1, objid);
 }
 
-/* find_id_for_stream():
-   The converse of find_stream_by_id(). 
-   This is only needed in this file, so it's static.
-*/
-glui32 git_find_id_for_stream(strid_t str)
-{
-  gidispatch_rock_t objrock;
-
-  if (!str)
-    return 0;
-
-  objrock = gidispatch_get_objrock(str, 1);
-  return ((classref_t *)objrock.ptr)->id;
-}
+/* find_id_for_stream():
+   The converse of find_stream_by_id(). 
+   This is only needed in this file, so it's static.
+*/
+glui32 git_find_id_for_stream(strid_t str)
+{
+  gidispatch_rock_t objrock;
+
+  if (!str)
+    return 0;
+
+  objrock = gidispatch_get_objrock(str, 1);
+  return ((classref_t *)objrock.ptr)->id;
+}
 
 /* Build a hash table to hold a set of Glk objects. */
 static classtable_t *new_classtable(glui32 firstid)
@@ -1136,6 +1164,83 @@ static void release_temp_array(glui32 *arr, glui32 addr, glui32 len, int passout
   }
 }
 
+static void **grab_temp_ptr_array(glui32 addr, glui32 len, int objclass, int passin)
+{
+  arrayref_t *arref = NULL;
+  void **arr = NULL;
+  glui32 ix, addr2;
+
+  if (len) {
+    arr = (void **)glulx_malloc(len * sizeof(void *));
+    arref = (arrayref_t *)glulx_malloc(sizeof(arrayref_t));
+    if (!arr || !arref) 
+      fatalError("Unable to allocate space for array argument to Glk call.");
+
+    arref->array = arr;
+    arref->addr = addr;
+    arref->elemsize = sizeof(void *);
+    arref->retained = FALSE;
+    arref->len = len;
+    arref->next = arrays;
+    arrays = arref;
+
+    if (passin) {
+      for (ix=0, addr2=addr; ix<len; ix++, addr2+=4) {
+        glui32 thisval = memRead32(addr2);
+        if (thisval)
+          arr[ix] = classes_get(objclass, thisval);
+        else
+          arr[ix] = NULL;
+      }
+    }
+  }
+
+  return arr;
+}
+
+static void release_temp_ptr_array(void **arr, glui32 addr, glui32 len, int objclass, int passout)
+{
+  arrayref_t *arref = NULL;
+  arrayref_t **aptr;
+  glui32 ix, val, addr2;
+
+  if (arr) {
+    for (aptr=(&arrays); (*aptr); aptr=(&((*aptr)->next))) {
+      if ((*aptr)->array == arr)
+        break;
+    }
+    arref = *aptr;
+    if (!arref)
+      fatalError("Unable to re-find array argument in Glk call.");
+    if (arref->addr != addr || arref->len != len)
+      fatalError("Mismatched array argument in Glk call.");
+
+    if (arref->retained) {
+      return;
+    }
+
+    *aptr = arref->next;
+    arref->next = NULL;
+
+    if (passout) {
+      for (ix=0, addr2=addr; ix<len; ix++, addr2+=4) {
+        void *opref = arr[ix];
+        if (opref) {
+          gidispatch_rock_t objrock = 
+            gidispatch_get_objrock(opref, objclass);
+          val = ((classref_t *)objrock.ptr)->id;
+        }
+        else {
+          val = 0;
+        }
+        memWrite32(addr2, val);
+      }
+    }
+    glulx_free(arr);
+    glulx_free(arref);
+  }
+}
+
 gidispatch_rock_t glulxe_retained_register(void *array,
   glui32 len, char *typecode)
 {

help/glulx.htm

@@ -10,7 +10,7 @@ <h1>Glulx</h1>
 the Inform compiler could compile to, without the limitations of its original output format, Infocom's
 Z-Machine.
 <p>
-Windows Git is based on Iain Merrick's Git 1.2.9, which is a complete implementation of version 3.1.2
+Windows Git is based on Iain Merrick's Git 1.3.0, which is a complete implementation of version 3.1.2
 of the Glulx specification.
 <p>
 More information on Glulx is available from the Glulx web page:

help/overview.htm

@@ -4,7 +4,7 @@
   <link rel="stylesheet" type="text/css" href="Git.css">
  </head>
  <body>
-<h1>Windows Git 1.2.9<br><font size="-1">(Windows Glk 1.43)</font></h1>
+<h1>Windows Git 1.3.0<br><font size="-1">(Windows Glk 1.43)</font></h1>
 Windows Git is an interpreter for <a href="glulx.htm">Glulx</a> games. Windows Git
 consists of a core interpreter called Git, and an input/output library, called Windows
 Glk. Together these two components form the Windows Git package, which has been created

help/revision.htm

@@ -6,6 +6,12 @@
  <body>
 <h1>Revision History</h1>
 
+<b>Git 1.3.0 (Windows Glk 1.43)</b>
+<ul>
+<li>Updated to Git 1.3.0, which fixes a bug related to Glk call dispatching,
+following a similar fix in Glulxe.
+</ul>
+
 <b>Git 1.2.9 (Windows Glk 1.43)</b>
 <ul>
 <li>Updated to support Glk 0.7.3, which includes more control when playing sounds.

version.h

@@ -1,4 +1,4 @@
 // Automatically generated file -- do not edit!
 #define GIT_MAJOR 1
-#define GIT_MINOR 2
-#define GIT_PATCH 9
+#define GIT_MINOR 3
+#define GIT_PATCH 0