diff --git a/melange-parser/alignment.dylan b/melange-parser/alignment.dylan
index 4509f45..5f5233e 100644
--- a/melange-parser/alignment.dylan
+++ b/melange-parser/alignment.dylan
@@ -133,8 +133,8 @@ define function do-coalesce-members (decl :: <structured-type-declaration>)
 				composite := make(<coalesced-bitfields>, name: name, dylan-name: name);
 				result := pair(composite, result);
       end if;
-      decl-type.composite-field := composite;
-      decl-type.start-bit := composite.bit-size;
+//unused      decl-type.composite-field := composite;
+//unused      decl-type.start-bit := composite.bit-size;
       composite.fields := add!(composite.fields, member);
       let size = composite.bit-size + decl-type.bits-in-field;
       if (size > composite.type.unix-type-size)
diff --git a/melange-parser/c-decl-state.dylan b/melange-parser/c-decl-state.dylan
index 2a459ca..380fa25 100644
--- a/melange-parser/c-decl-state.dylan
+++ b/melange-parser/c-decl-state.dylan
@@ -74,7 +74,7 @@ copyright: see below
 define abstract class <parse-state> (<object>)
   slot objects :: <table>;
   slot structs :: <table>;
-  slot tokenizer :: <tokenizer>, required-init-keyword: #"tokenizer";
+  constant slot tokenizer :: <tokenizer>, required-init-keyword: #"tokenizer";
   slot pointers :: <table>;
   slot vectors :: <table>;
   slot verbose :: <boolean>;
@@ -91,11 +91,11 @@ define class <parse-file-state> (<parse-state>)
   // ".h" file.
   slot declarations :: <deque> = make(<deque>);
   slot current-file :: <string> = "<top-level>";
-  slot recursive-files-stack :: <deque> = make(<deque>);
+  constant slot recursive-files-stack :: <deque> = make(<deque>);
   // maps a filename into a sequence of files which it recursively includes
-  slot recursive-include-table :: <table> = make(<string-table>);
+  constant slot recursive-include-table :: <table> = make(<string-table>);
   // maps a filename into a sequence of declarations from that file
-  slot recursive-declaration-table :: <table> = make(<string-table>);
+  constant slot recursive-declaration-table :: <table> = make(<string-table>);
 end class;
 
 define method initialize (value :: <parse-file-state>, #key)
diff --git a/melange-parser/c-decl-write-c-ffi.dylan b/melange-parser/c-decl-write-c-ffi.dylan
index b5bd09d..33f0cae 100644
--- a/melange-parser/c-decl-write-c-ffi.dylan
+++ b/melange-parser/c-decl-write-c-ffi.dylan
@@ -12,6 +12,25 @@ define method write-declaration (decl :: <declaration>, back-end :: <c-ffi-back-
   format(back-end.stream, " /* Ignoring declaration for %= %=*/\n", decl, decl.dylan-name)
 end;
 
+define method write-declaration (decl :: <variable-declaration>, back-end :: <c-ffi-back-end>)
+ => ()
+  register-written-name(back-end.written-names, decl.dylan-name, decl);
+  let stream = back-end.stream;
+  if ( instance?(decl.type, <struct-declaration>) | instance?(decl.type, <union-declaration>) )
+    format(stream, "define c-address %s :: %s\n", decl.dylan-name, decl.type.dylan-name);
+  else
+    format(stream, "define c-variable %s :: %s\n", decl.dylan-name, decl.mapped-name);
+  end;
+  if ( decl.read-only )
+    format(stream, "  setter: #f,\n");
+  end;
+  if ( decl.external-linkage == #t )
+    format(stream, "  import: #t,\n");
+  end;
+  format(stream, "  c-name: \"%s\"\n", decl.simple-name);
+  format(stream, "end;\n\n"); 
+end;
+
 define method write-declaration (decl :: <struct-declaration>, back-end :: <c-ffi-back-end>)
  => ();
   register-written-name(back-end.written-names, decl.dylan-name, decl);
diff --git a/melange-parser/c-decl-write.dylan b/melange-parser/c-decl-write.dylan
index c59c3da..77c1f8f 100644
--- a/melange-parser/c-decl-write.dylan
+++ b/melange-parser/c-decl-write.dylan
@@ -78,7 +78,7 @@ define generic write-declaration
 //------------------------------------------------------------------------
 
 define class <written-name-record> (<object>)
-  slot written-name-table :: <table> /* <symbol> => <declaration> */
+  constant slot written-name-table :: <table> /* <symbol> => <declaration> */
     = make(<table>);
 end class <written-name-record>;
 
diff --git a/melange-parser/c-decl.dylan b/melange-parser/c-decl.dylan
index 2219a9c..9316d50 100644
--- a/melange-parser/c-decl.dylan
+++ b/melange-parser/c-decl.dylan
@@ -93,7 +93,7 @@ copyright: see below
 //       <object-declaration>
 //           operations include equated and read-only
 //         <variable-declaration>
-//             operations include getter and setter
+//             operations include getter and setter, read-only, external-linkage
 //         <slot-declaration>
 //             operations include excluded?
 //         <result-declaration>
@@ -101,7 +101,7 @@ copyright: see below
 //         <arg-declaration>
 //             operations include direction, original-type,
 //             argument-direction-setter
-//           <varargs-declaration>
+//          <varargs-declaration>
 //     <constant-declaration>
 //         operations include constant-value
 //       <enum-slot-declaration>
@@ -126,8 +126,8 @@ define abstract class <declaration> (<object>)
     init-value: #f, init-keyword: #"dylan-name";
   slot map-type :: false-or(<string>), init-value: #f;
   slot declared? :: <boolean>, init-value: #f;
-  constant slot abstract-type? :: <boolean>, 
-    init-value: #f, init-keyword: abstract-type?:;
+//unused  constant slot abstract-type? :: <boolean>, 
+//    init-value: #f, init-keyword: abstract-type?:;
 end class <declaration>;
 
 define abstract class <typed> (<object>)
@@ -167,7 +167,7 @@ define generic dylan-name-setter
 //
 define generic compute-dylan-name
     (decl :: <declaration>, mapper :: <function>, prefix :: <string>,
-     containers :: <sequence>, rd-only :: <boolean>, sealing :: <string>)
+     containers :: <sequence>, rd-only :: <boolean>, sealing :: <string>, external :: <boolean>)
  => (result :: <string>);
 
 // Find-dylan-name provlides low level support for "apply-options".  It checks
@@ -177,7 +177,7 @@ define generic compute-dylan-name
 //
 define generic find-dylan-name
     (decl :: <declaration>, mapper :: <function>, prefix :: <string>,
-     containers :: <sequence>, read-only :: <boolean>, sealing :: <string>)
+     containers :: <sequence>, read-only :: <boolean>, sealing :: <string>, external :: <boolean>)
  => (result :: <string>);
 
 // Sets the dylan name for this object or type.  (External interface.)
@@ -220,7 +220,7 @@ define generic pointer-to
 //
 define generic apply-options
     (decl :: <declaration>, map-function :: <function>, prefix :: <string>,
-     read-only :: <boolean>, sealing :: <string>)
+     read-only :: <boolean>, sealing :: <string>, external :: <boolean>)
  => ();
 
 //------------------------------------------------------------------------
@@ -246,11 +246,11 @@ end method remap;
 //
 define method find-dylan-name
     (decl :: <declaration>, mapper :: <function>, prefix :: <string>,
-     containers :: <sequence>, read-only :: <boolean>, sealing :: <string>)
+     containers :: <sequence>, read-only :: <boolean>, sealing :: <string>, external :: <boolean>)
  => (result :: <string>);
   decl.d-name
     | (decl.d-name := compute-dylan-name(decl, mapper, prefix, containers,
-					 read-only, sealing));
+					 read-only, sealing, external));
 end method find-dylan-name;
 
 define method dylan-name (decl :: <declaration>) => (result :: <string>);
@@ -289,9 +289,9 @@ end method compute-closure;
 
 define method apply-options
     (decl :: <declaration>, map-function :: <function>, prefix :: <string>,
-     read-only :: <boolean>, sealing :: <string>)
+     read-only :: <boolean>, sealing :: <string>, external :: <boolean>)
  => ();
-  find-dylan-name(decl, map-function, prefix, #(), read-only, sealing);
+  find-dylan-name(decl, map-function, prefix, #(), read-only, sealing, external );
 end method apply-options;
 
 // Exclude-decl -- exported.
@@ -333,7 +333,7 @@ end method equate;
 
 define method compute-dylan-name
     (decl :: <type-declaration>, mapper :: <function>, prefix :: <string>,
-     containers :: <sequence>, rd-only :: <boolean>, sealing :: <string>)
+     containers :: <sequence>, rd-only :: <boolean>, sealing :: <string>, external :: <boolean>)
  => (result :: <string>);
   mapper(#"type", prefix, decl.simple-name, containers);
 end method compute-dylan-name;
@@ -403,7 +403,7 @@ define generic make-struct-type
 define generic apply-container-options
     (decl :: <structured-type-declaration>,
      map-function :: <function>, prefix :: <string>, read-only :: <boolean>,
-     sealing :: <string>)
+     sealing :: <string>, external :: <boolean>)
  => ();
 
 define method compute-closure 
@@ -544,18 +544,18 @@ end method exclude-slots;
 define method find-dylan-name
     (decl :: <structured-type-declaration>, mapper :: <function>,
      prefix :: <string>, containers :: <sequence>, read-only :: <boolean>,
-     sealing :: <string>)
+     sealing :: <string>, external :: <boolean>)
  => (result :: <string>);
   unless (decl.d-name)
     decl.d-name := compute-dylan-name(decl, mapper, prefix, containers,
-                                      read-only, sealing);
+                                      read-only, sealing, external);
     // Take care of the contained objects as well.  Some of these may
     // already have been handled by "container" declarations.
     let sub-containers = list(decl.simple-name);
     if (decl.members)
       for (sub-decl in decl.members)
         find-dylan-name(sub-decl, mapper, prefix, sub-containers,
-                        read-only, sealing);
+                        read-only, sealing, external);
       end for;
     end if;
   end;
@@ -565,13 +565,13 @@ end method find-dylan-name;
 define method apply-container-options
     (decl :: <structured-type-declaration>,
      map-function :: <function>, prefix :: <string>, read-only :: <boolean>,
-     sealing :: <string>)
+     sealing :: <string>, external :: <boolean>)
  => ();
   let sub-containers = list(decl.simple-name);
   if (decl.members)
     for (elem in decl.members)
       find-dylan-name(elem, map-function, prefix, sub-containers, read-only,
-		      sealing);
+		      sealing, external);
     end for;
   end if;
 end method apply-container-options;
@@ -579,13 +579,13 @@ end method apply-container-options;
 //------------------------------------------------------------------------
 
 define class <pointer-declaration> (<new-static-pointer>, <type-declaration>)
-  slot referent :: <type-declaration>, required-init-keyword: #"referent";
-  slot accessors-written?, init-value: #f;
+  constant slot referent :: <type-declaration>, required-init-keyword: #"referent";
+//unused  slot accessors-written?, init-value: #f;
 end class;
 
 define class <vector-declaration> (<new-static-pointer>, <type-declaration>)
-  slot pointer-equiv :: <type-declaration>, required-init-keyword: #"equiv";
-  slot length :: false-or(<integer>),
+  constant slot pointer-equiv :: <type-declaration>, required-init-keyword: #"equiv";
+  constant slot length :: false-or(<integer>),
     required-init-keyword: #"length";
 end class <vector-declaration>;
 
@@ -653,10 +653,10 @@ end method canonical-name;
 
 define method compute-dylan-name
     (decl :: <pointer-declaration>, mapper :: <function>, prefix :: <string>,
-     containers :: <sequence>, rd-only :: <boolean>, sealing :: <string>)
+     containers :: <sequence>, rd-only :: <boolean>, sealing :: <string>, external :: <boolean>)
  => (result :: <string>);
   if (decl.simple-name = decl.referent.simple-name)
-    find-dylan-name(decl.referent, mapper, prefix, #(), rd-only, sealing);
+    find-dylan-name(decl.referent, mapper, prefix, #(), rd-only, sealing, external );
   else
     mapper(#"type", prefix, decl.simple-name, containers);
   end if;
@@ -675,7 +675,7 @@ end method compute-closure;
 
 define method compute-dylan-name
     (decl :: <vector-declaration>, mapper :: <function>, prefix :: <string>,
-     containers :: <sequence>, rd-only :: <boolean>, sealing :: <string>)
+     containers :: <sequence>, rd-only :: <boolean>, sealing :: <string>, external :: <boolean>)
  => (result :: <string>);
   mapper(#"type", prefix, decl.simple-name, containers);
 end method compute-dylan-name;
@@ -735,8 +735,8 @@ end method vector-of;
 //------------------------------------------------------------------------
 
 define class <function-type-declaration> (<type-declaration>)
-  slot result :: <result-declaration>, required-init-keyword: #"result";
-  slot parameters :: <sequence>, required-init-keyword: #"params";
+  constant slot result :: <result-declaration>, required-init-keyword: #"result";
+  constant slot parameters :: <sequence>, required-init-keyword: #"params";
   slot local-name-mapper :: false-or(<function>) = #f;
   slot callback-maker-name :: false-or(<symbol>) = #f;
   slot callout-function-name :: false-or(<symbol>) = #f;
@@ -758,25 +758,25 @@ end method canonical-name;
 define method find-dylan-name
     (decl :: <function-type-declaration>, mapper :: <function>,
      prefix :: <string>, containers :: <sequence>, read-only :: <boolean>,
-     sealing :: <string>)
+     sealing :: <string>, external :: <boolean>)
  => (result :: <string>);
   find-dylan-name(decl.result, mapper, prefix, #(), read-only,
-		  sealing);
+		  sealing, external);
   for (elem in decl.parameters)
     if (~instance?(elem, <varargs-declaration>))
-      find-dylan-name(elem, mapper, prefix, #(), read-only, sealing);
+      find-dylan-name(elem, mapper, prefix, #(), read-only, sealing, external);
     end if; 
   end for;
 
   decl.d-name
     | (decl.d-name := compute-dylan-name(decl, mapper, prefix, containers,
-					 read-only, sealing));
+					 read-only, sealing, external));
 end method find-dylan-name;
 
 define method compute-dylan-name
     (decl :: <function-type-declaration>, mapper :: <function>,
      prefix :: <string>, containers :: <sequence>, rd-only :: <boolean>,
-     sealing :: <string>)
+     sealing :: <string>, external :: <boolean>)
  => (result :: <string>);
   mapper(#"type", prefix, decl.simple-name, containers);
 end method compute-dylan-name;
@@ -811,7 +811,7 @@ end method mapped-name;
 
 define method compute-dylan-name
     (decl :: <typedef-declaration>, mapper :: <function>, prefix :: <string>,
-     containers :: <sequence>, rd-only :: <boolean>, sealing :: <string>)
+     containers :: <sequence>, rd-only :: <boolean>, sealing :: <string>, external :: <boolean>)
  => (result :: <string>);
   mapper(#"type", prefix, decl.simple-name, containers);
 end method compute-dylan-name;
@@ -844,20 +844,20 @@ end method true-type;
 define class <incomplete-type-declaration> (<type-declaration>) end class;
 
 define class <predefined-type-declaration> (<type-declaration>) 
-  slot type-size-slot :: <integer>, required-init-keyword: #"size";
+  constant slot type-size-slot :: <integer>, required-init-keyword: #"size";
 end class;
 
 define class <integer-type-declaration> (<predefined-type-declaration>)
   // Accessor-name specifies the "dereference" function to call in order to
   // retrieve the correct number of bytes.
-  slot accessor-name :: <string>, required-init-keyword: #"accessor";
+//unused  slot accessor-name :: <string>, required-init-keyword: #"accessor";
 end class;
 
 define class <signed-integer-type-declaration>   (<integer-type-declaration>) end class;
 define class <unsigned-integer-type-declaration> (<integer-type-declaration>) end class;
 
 define class <float-type-declaration> (<predefined-type-declaration>)
-  slot accessor-name :: <string>, required-init-keyword: #"accessor";
+//unused  slot accessor-name :: <string>, required-init-keyword: #"accessor";
 end class;
 
 define constant unknown-type = make(<incomplete-type-declaration>,
@@ -867,7 +867,7 @@ define constant unsigned-type = make(<incomplete-type-declaration>,
 define constant signed-type = make(<incomplete-type-declaration>,
 				   name: "unknown-type");
 define constant void-type = make(<predefined-type-declaration>,
-				 dylan-name: "<void>",
+				 dylan-name: "<c-void>",
                                  abstract-type?: #t,
 				 name: "void-type", size: 0);
 
@@ -964,10 +964,10 @@ end method compute-closure;
 // "do-coalesce-members" function).
 
 define class <bitfield-declaration> (<type-declaration>)
-  slot bits-in-field :: <integer>, required-init-keyword: #"bits";
-  slot base-type :: <type-declaration>, required-init-keyword: #"base";
-  slot composite-field :: false-or(<coalesced-bitfields>) = #f;
-  slot start-bit :: <integer> = 0;	// only meaningful if composite ~= #f
+  constant slot bits-in-field :: <integer>, required-init-keyword: #"bits";
+//unused  slot base-type :: <type-declaration>, required-init-keyword: #"base";
+//unused  slot composite-field :: false-or(<coalesced-bitfields>) = #f;
+//unused  slot start-bit :: <integer> = 0;	// only meaningful if composite ~= #f
 end class <bitfield-declaration>;
 
 define class <coalesced-bitfields> (<declaration>)
@@ -997,6 +997,7 @@ end class;
 define class <variable-declaration> (<object-declaration>)
   slot getter :: false-or(<string>), init-value: #f;
   slot setter :: false-or(<string>), init-value: #f;
+  slot external-linkage :: type-union(<boolean>, <empty-list>), init-value: #();
 end class;
 define class <slot-declaration> (<object-declaration>)
   slot excluded? :: <boolean>, init-value: #f, init-keyword: #"excluded?";
@@ -1004,7 +1005,7 @@ end class;
 define class <result-declaration> (<object-declaration>) end class;
 define class <arg-declaration> (<object-declaration>)
   slot direction :: <symbol>, init-value: #"default";
-  slot original-type :: false-or(<type-declaration>),
+  constant slot original-type :: false-or(<type-declaration>),
     init-value: #f;
 end class;
 define class <varargs-declaration> (<arg-declaration>) end class;
@@ -1041,19 +1042,19 @@ end method equate;
 
 define method find-dylan-name
     (decl :: <function-declaration>, mapper :: <function>, prefix :: <string>,
-     containers :: <sequence>, read-only :: <boolean>, sealing :: <string>)
+     containers :: <sequence>, read-only :: <boolean>, sealing :: <string>, external :: <boolean>)
  => (result :: <string>);
-  find-dylan-name(decl.type, mapper, prefix, #(), read-only, sealing);
+  find-dylan-name(decl.type, mapper, prefix, #(), read-only, sealing, external);
   decl.d-name
     | (decl.d-name := compute-dylan-name(decl, mapper, prefix, containers,
-					 read-only, sealing));
+					 read-only, sealing, external));
 end method find-dylan-name;
 
 define method compute-dylan-name
     (decl :: <function-declaration>, mapper :: <function>, prefix :: <string>,
-     containers :: <sequence>, rd-only :: <boolean>, sealing :: <string>)
+     containers :: <sequence>, rd-only :: <boolean>, sealing :: <string>, external :: <boolean>)
  => (result :: <string>);
-  find-dylan-name(decl.type, mapper, prefix, containers, rd-only, sealing);
+  find-dylan-name(decl.type, mapper, prefix, containers, rd-only, sealing, external);
   mapper(#"function", prefix, decl.simple-name, containers);
 end method compute-dylan-name;
 
@@ -1089,39 +1090,40 @@ end method type-name;
 
 define method find-dylan-name
     (decl :: <value-declaration>, mapper :: <function>, prefix :: <string>,
-     containers :: <sequence>, read-only :: <boolean>, sealing :: <string>)
+     containers :: <sequence>, read-only :: <boolean>, sealing :: <string>, external :: <boolean>)
  => (result :: <string>);
   if (decl.sealed-string = "") decl.sealed-string := sealing end if;
   decl.d-name
     | (decl.d-name := compute-dylan-name(decl, mapper, prefix, containers,
-					 read-only, sealing));
+					 read-only, sealing, external));
 end method find-dylan-name;
 
 define method find-dylan-name
     (decl :: <object-declaration>, mapper :: <function>, prefix :: <string>,
-     containers :: <sequence>, rd-only :: <boolean>, sealing :: <string>)
+     containers :: <sequence>, rd-only :: <boolean>, sealing :: <string>, external :: <boolean>)
  => (result :: <string>);
   if (decl.sealed-string = "") decl.sealed-string := sealing end if;
   if (decl.read-only == #()) decl.read-only := rd-only end if;
-  find-dylan-name(decl.type, mapper, prefix, #(), rd-only, sealing);
+  find-dylan-name(decl.type, mapper, prefix, #(), rd-only, sealing, external);
   decl.d-name
     | (decl.d-name := compute-dylan-name(decl, mapper, prefix, containers,
-					 rd-only, sealing));
+					 rd-only, sealing, external));
 end method find-dylan-name;
 
 define method compute-dylan-name
     (decl :: <object-declaration>, mapper :: <function>, prefix :: <string>,
-     containers :: <sequence>, rd-only :: <boolean>, sealing :: <string>)
+     containers :: <sequence>, rd-only :: <boolean>, sealing :: <string>, external :: <boolean>)
  => (result :: <string>);
   mapper(#"variable", prefix, decl.simple-name, containers);
 end method compute-dylan-name;
 
 define method find-dylan-name
     (decl :: <variable-declaration>, mapper :: <function>, prefix :: <string>,
-     containers :: <sequence>, rd-only :: <boolean>, sealing :: <string>,
+     containers :: <sequence>, rd-only :: <boolean>, sealing :: <string>, external :: <boolean>,
      #next next-method)
  => (result :: <string>);
   next-method();
+  if (decl.external-linkage == #()) decl.external-linkage := external end if;
   decl.getter := decl.getter | decl.d-name;
   decl.setter := decl.setter | concatenate(decl.d-name, "-setter");
   decl.d-name;
@@ -1139,19 +1141,19 @@ end method compute-closure;
 
 define method find-dylan-name
     (decl :: <arg-declaration>, mapper :: <function>, prefix :: <string>,
-     containers :: <sequence>, rd-only :: <boolean>, sealing :: <string>,
+     containers :: <sequence>, rd-only :: <boolean>, sealing :: <string>, external :: <boolean>,
      #next next-method)
  => (result :: <string>);
   if (decl.original-type)
     find-dylan-name(decl.original-type, mapper, prefix, #(), rd-only,
-		    sealing);
+		    sealing, external);
   end if;
   next-method();
 end method find-dylan-name;
 
 define method compute-dylan-name
     (decl :: <arg-declaration>, mapper :: <function>, prefix :: <string>,
-     containers :: <sequence>, rd-only :: <boolean>, sealing :: <string>)
+     containers :: <sequence>, rd-only :: <boolean>, sealing :: <string>, external :: <boolean>)
  => (result :: <string>);
   mapper(#"variable", prefix, decl.simple-name, containers);
 end method compute-dylan-name;
@@ -1242,7 +1244,7 @@ end class;
 
 define method compute-dylan-name
     (decl :: <enum-slot-declaration>, mapper :: <function>, prefix :: <string>,
-     containers :: <sequence>, rd-only :: <boolean>, sealing :: <string>)
+     containers :: <sequence>, rd-only :: <boolean>, sealing :: <string>, external :: <boolean>)
  => (result :: <string>);
   
   // (Do not emit container prefixes for enum constants. C semantics
@@ -1273,7 +1275,7 @@ define generic add-cpp-declaration
 
 define method compute-dylan-name
     (decl :: <constant-declaration>, mapper :: <function>, prefix :: <string>,
-     containers :: <sequence>, rd-only :: <boolean>, sealing :: <string>)
+     containers :: <sequence>, rd-only :: <boolean>, sealing :: <string>, external :: <boolean>)
  => (result :: <string>);
   mapper(#"constant", prefix, decl.simple-name, containers);
 end method compute-dylan-name;
@@ -1304,7 +1306,7 @@ end method compute-closure;
 
 define method compute-dylan-name
     (decl :: <macro-declaration>, mapper :: <function>, prefix :: <string>,
-     containers :: <sequence>, rd-only :: <boolean>, sealing :: <string>)
+     containers :: <sequence>, rd-only :: <boolean>, sealing :: <string>, external :: <boolean>)
  => (result :: <string>);
   // If we are aliasing another declaration, we should use the same category.
   // We should only use #"constant" if we are renaming a constant or have an
diff --git a/melange-parser/c-exports.dylan b/melange-parser/c-exports.dylan
index c92029c..5bc47be 100644
--- a/melange-parser/c-exports.dylan
+++ b/melange-parser/c-exports.dylan
@@ -112,7 +112,6 @@ define module c-lexer
     exclude: { format, format-to-string, 
                split, position };
   use format;
-  use table-extensions;
   use self-organizing-list;
   use string-conversions;
   use regular-expressions;
@@ -223,7 +222,7 @@ define module c-declarations
     argument-direction-setter, constant-value-setter, getter-setter,
     setter-setter, read-only-setter, sealed-string-setter, excluded?-setter,
     exclude-slots, equate, remap, rename, superclasses-setter, pointer-equiv,
-    dylan-name, exclude-decl, 
+    dylan-name, exclude-decl, external-linkage-setter, 
 
     // "Import declarations phase" 
     declaration-closure, // also calls compute-closure
diff --git a/melange-parser/c-lexer-cpp.dylan b/melange-parser/c-lexer-cpp.dylan
index 5497067..dc9109b 100644
--- a/melange-parser/c-lexer-cpp.dylan
+++ b/melange-parser/c-lexer-cpp.dylan
@@ -49,7 +49,7 @@ copyright: see below
 // themselves have entries in the table.  Macro expansion will, therefore,
 // recursively expand each "expanded" token, recursing as deeply as necessary.
 //
-define constant default-cpp-table = make(<string-table>);
+//unused define constant default-cpp-table = make(<string-table>);
 
 // include-path -- exported constant.
 //
@@ -425,6 +425,8 @@ define method angle-include-next( state, filename )
         state.include-tokenizer
           := make(<tokenizer>, contents: "", parent: state);
       end if;
+    else
+      parse-error(state,"Filename not found %s",name);
     end if;
   else
     parse-error(state,"Filename is not absolute %s",name);
diff --git a/melange-parser/c-lexer.dylan b/melange-parser/c-lexer.dylan
index 61ef4b4..6a97d1e 100644
--- a/melange-parser/c-lexer.dylan
+++ b/melange-parser/c-lexer.dylan
@@ -102,7 +102,7 @@ define /* exported */ primary class <tokenizer> (<object>)
   slot file-name :: <string> = "<unknown-file>";
   slot contents :: <long-byte-string> = make(<long-byte-string>);
   slot position :: <integer> = 0;
-  slot unget-stack :: <deque>, init-function: curry(make, <deque>);
+  constant slot unget-stack :: <deque>, init-function: curry(make, <deque>);
   /* exported */ slot cpp-table :: <table>;
   slot cpp-stack :: <list> = #();
   /* exported */ slot cpp-decls :: false-or(<deque>) = #f;
@@ -142,8 +142,8 @@ end class <tokenizer>;
 //
 define /* exported */ abstract primary class <token> (<object>)
   constant /* exported */ slot token-id :: <integer> = -1;
-  slot string-value :: <byte-string>, required-init-keyword: #"string";
-  /* exported */ slot generator, required-init-keyword: #"generator";
+  constant slot string-value :: <byte-string>, required-init-keyword: #"string";
+  constant /* exported */ slot generator, required-init-keyword: #"generator";
   slot position, init-value: #f, init-keyword: #"position";
 end;
 
@@ -161,7 +161,7 @@ define /* exported */ abstract class <literal-token> (<token>) end class;
 // <end-include-token> will be a subclass of this.
 //
 define /* exported */ class <ei-token> (<token>)
-  slot value :: <deque>, required-init-keyword: #"value";
+  constant slot value :: <deque>, required-init-keyword: #"value";
 end class;
 define /* exported */ abstract class <name-token> (<token>) end class;
 
diff --git a/melange-parser/parse-conditions.dylan b/melange-parser/parse-conditions.dylan
index 981c8d1..426cfec 100644
--- a/melange-parser/parse-conditions.dylan
+++ b/melange-parser/parse-conditions.dylan
@@ -50,7 +50,7 @@ push(*default-parse-context*, #f);
 //  other such classes if they are needed.
 
 define abstract class <parse-condition> (<condition>)
-  slot parse-condition-source-location :: <source-location>,
+  constant slot parse-condition-source-location :: <source-location>,
     required-init-keyword: source-location:;
 end;
 
@@ -67,8 +67,8 @@ define class <simple-parse-warning> (<warning>,
 end;
 
 define class <parse-progress-report> (<format-string-parse-condition>)
-  slot parse-progress-level :: <parse-progress-level> = $parse-progress-level-all,
-    init-keyword: level:;
+  constant slot parse-progress-level :: <parse-progress-level> = $parse-progress-level-all,
+    required-init-keyword: level:;
 end;
 
 
diff --git a/melange-parser/source-location.dylan b/melange-parser/source-location.dylan
index 7e6487b..daf30cf 100644
--- a/melange-parser/source-location.dylan
+++ b/melange-parser/source-location.dylan
@@ -109,9 +109,9 @@ define class <file-source-location> (<source-location>)
   constant slot source-line :: <integer>,
     required-init-keyword: line:;
 
-  constant slot source-line-position :: false-or(<integer>),
-    init-keyword: line-position:,
-    init-value: #f;
+//  constant slot source-line-position :: false-or(<integer>),
+//    init-keyword: line-position:,
+//    init-value: #f;
 end;
 
 define sealed domain make (singleton(<file-source-location>));
diff --git a/melange/exports.dylan b/melange/exports.dylan
index f3e1b45..93632a8 100644
--- a/melange/exports.dylan
+++ b/melange/exports.dylan
@@ -120,7 +120,7 @@ define module int-lexer
     <setter-token>, <read-only-token>, <seal-token>, <seal-functions-token>,
     <boolean-token>, <sealed-token>, <open-token>, <inline-token>,
     <value-token>, <function-type-token>, <callback-maker-token>,
-    <callout-function-token>, <literal-token>;
+    <callout-function-token>, <literal-token>, <external-linkage-token>;
 end module int-lexer;
 
 define module int-parse
@@ -139,7 +139,7 @@ define module int-parse
     mappings, equates, read-only, seal-string, <clause>, <function-clause>,
     <struct-clause>, <union-clause>, <pointer-clause>, <constant-clause>,
     <variable-clause>, <function-type-clause>, name, options, <undefined>,
-    undefined;
+    undefined, external-linkage;
 end module int-parse;
 
 define module name-mappers
diff --git a/melange/int-lexer.dylan b/melange/int-lexer.dylan
index 7530f46..c3c8157 100644
--- a/melange/int-lexer.dylan
+++ b/melange/int-lexer.dylan
@@ -89,11 +89,11 @@ copyright: see below
 // The public view of tokenizers is described above.  
 //
 define primary class <tokenizer> (<object>)
-  slot file-name :: false-or(<string>),
+  constant slot file-name :: false-or(<string>),
     init-value: #f, init-keyword: #"source-file";
-  slot contents :: <string>, required-init-keyword: #"source-string";
+  constant slot contents :: <string>, required-init-keyword: #"source-string";
   slot position :: <integer>, init-keyword: #"start", init-value: 0;
-  slot unget-stack :: <deque>, init-function: curry(make, <deque>);
+  constant slot unget-stack :: <deque>, init-function: curry(make, <deque>);
 end class <tokenizer>;
 
 // Exported operations -- described in module header
@@ -133,8 +133,8 @@ define generic unget-token
 
 define abstract primary class <token> (<object>)
   constant slot token-id :: <integer> = -1;
-  slot string-value :: <string>, required-init-keyword: #"string";
-  slot generator, required-init-keyword: #"generator";
+  constant slot string-value :: <string>, required-init-keyword: #"string";
+  constant slot generator, required-init-keyword: #"generator";
   slot position, init-value: #f, init-keyword: #"position";
 end;
 
@@ -218,14 +218,15 @@ define token <value-token> :: <reserved-word-token> = 49;
 define token <function-type-token> :: <reserved-word-token> = 50;
 define token <callback-maker-token> :: <reserved-word-token> = 51;
 define token <callout-function-token> :: <reserved-word-token> = 52;
+define token <external-linkage-token> :: <reserved-word-token> = 53;
 
 // A whole bunch of punctuation
 
-define token <semicolon-token> :: <punctuation-token> = 53;
-define token <comma-token> :: <punctuation-token> = 54;
-define token <lbrace-token> :: <punctuation-token> = 55;
-define token <rbrace-token> :: <punctuation-token> = 56;
-define token <arrow-token> :: <punctuation-token> = 57;
+define token <semicolon-token> :: <punctuation-token> = 54;
+define token <comma-token> :: <punctuation-token> = 55;
+define token <lbrace-token> :: <punctuation-token> = 56;
+define token <rbrace-token> :: <punctuation-token> = 57;
+define token <arrow-token> :: <punctuation-token> = 58;
 
 define sealed generic string-value (token :: <token>) => (result :: <string>);
 define sealed generic value (token :: <token>) => (result :: <object>);
@@ -432,6 +433,7 @@ define constant reserved-words
 	   "function-type", <function-type-token>,
 	   "callback-maker:", <callback-maker-token>,
 	   "callout-function:", <callout-function-token>,
+	   "external:", <external-linkage-token>, 
 	   "#t", <true-token>,
 	   "#f", <false-token>,
 	   ",", <comma-token>,
@@ -779,6 +781,8 @@ define sealed domain make(singleton(<function-type-token>));
 define sealed domain make(singleton(<callback-maker-token>));
 // <callout-function-token> -- subclass of <reserved-word-token>
 define sealed domain make(singleton(<callout-function-token>));
+// <external-linkage-token> -- subclass of <reserved-word-token>
+define sealed domain make(singleton(<external-linkage-token>));
 // <semicolon-token> -- subclass of <punctuation-token>
 define sealed domain make(singleton(<semicolon-token>));
 // <comma-token> -- subclass of <punctuation-token>
diff --git a/melange/int-parse.input b/melange/int-parse.input
index 1f42a2b..2430074 100644
--- a/melange/int-parse.input
+++ b/melange/int-parse.input
@@ -48,10 +48,6 @@ copyright: see below
 // Simple parser support 
 //----------------------------------------------------------------------
 
-// Designates an "optional" string.
-//
-define constant <string?> = false-or(<string>);
-
 // Undefined values are useful for values that may need to be defaulted.  This
 // is superior to simply filling in the default value at the start, since it
 // allows us to merge several <container-option>s before doing the defaulting.
@@ -69,9 +65,9 @@ define class <container-options> (<object>)
   // each element of imports is either #"all" or an import list
   slot global-import-mode
     :: one-of(#"all", #"all-recursive", #"none", #"undecided") = #"undecided";
-  slot global-imports :: <sequence> = make(<stretchy-vector>);
-  slot file-import-modes = make(<string-table>) /* of #"all", #"none" */;
-  slot file-imports = make(<string-table>) /* of <sequence> */;
+  constant slot global-imports :: <sequence> = make(<stretchy-vector>);
+  constant slot file-import-modes = make(<string-table>) /* of #"all", #"none" */;
+  constant slot file-imports = make(<string-table>) /* of <sequence> */;
   slot prefix :: type-union(<string>, <undefined>), init-value: undefined;
   constant slot exclude = make(<deque>);
   constant slot excluded-files = make(<deque>);
@@ -79,6 +75,7 @@ define class <container-options> (<object>)
   slot mappings :: <sequence>, init-value: #();
   slot equates :: <sequence>, init-value: #();
   slot read-only :: type-union(<boolean>, <undefined>), init-value: undefined;
+  slot external-linkage :: type-union(<boolean>, <undefined>), init-value: undefined;
   slot seal-string :: type-union(<string>, <undefined>), init-value: undefined;
 end class <container-options>;
 
@@ -91,10 +88,10 @@ end class <container-options>;
 // order. 
 //
 define class <parse-state> (<object>)
-  slot tokenizer :: <tokenizer>, required-init-keyword: #"tokenizer";
+  constant slot tokenizer :: <tokenizer>, required-init-keyword: #"tokenizer";
   slot include-files :: false-or(<sequence>) = #f;
-  slot macro-defines :: <deque>, init-function: curry(make, <deque>);
-  slot macro-undefines :: <deque>, init-function: curry(make, <deque>);
+  constant slot macro-defines :: <deque>, init-function: curry(make, <deque>);
+  constant slot macro-undefines :: <deque>, init-function: curry(make, <deque>);
   slot container-options :: <container-options>;
   slot clauses :: <sequence>, init-value: #();
 end class <parse-state>;
@@ -178,6 +175,8 @@ define method process-container-options
                       	         result.equates, item.second);
       #"read-only" =>
         result.read-only := item.second;
+      #"external" =>
+        result.external-linkage := item.second;
       #"seal" =>
         result.seal-string := item.second;
       otherwise =>
@@ -195,12 +194,11 @@ end method process-container-options;
 // some of the options in a more convenient format.
 //
 define class <clause> (<object>) 
-  slot name :: <string>, required-init-keyword: #"name";
-  slot options :: <sequence>, required-init-keyword: #"options";
+  constant slot name :: <string>, required-init-keyword: #"name";
+  constant slot options :: <sequence>, required-init-keyword: #"options";
 end class;
 
 define class <function-clause> (<clause>) end class;
-define class <variable-clause> (<clause>) end class;
 define class <constant-clause> (<clause>) end class;
 define class <pointer-clause> (<clause>) end class;
 define class <function-type-clause> (<clause>) end class;
@@ -211,6 +209,7 @@ end class <container-clause>;
 
 define class <struct-clause> (<container-clause>) end class;
 define class <union-clause> (<container-clause>) end class;
+define class <variable-clause> (<container-clause>) end class;
 
 
 define constant <source-location> = false-or(<parse-state>);
@@ -281,6 +280,7 @@ define constant <source-location> = false-or(<parse-state>);
 :token <function-type-token> <reserved-word-token> 
 :token <callback-maker-token> <reserved-word-token>
 :token <callout-function-token> <reserved-word-token>
+:token <external-linkage-token> <reserved-word-token> 
 
 ;; A whole bunch of punctuation
 
@@ -542,6 +542,10 @@ container-option (<read-only-token> BOOLEAN)
   list(#"read-only", %2.value);
 %
 
+container-option (<external-linkage-token> BOOLEAN)
+  list(#"external", %2.value);
+%
+
 interface-clause (<function-token> <string-literal-token>
                   function-option-list)
   @0.clauses := add!(@0.clauses,
@@ -756,6 +760,10 @@ variable-option (<read-only-token> BOOLEAN)
   pair(#"read-only", %2.value);
 %
 
+variable-option (<external-linkage-token> BOOLEAN)
+  pair(#"external", %2.value);
+%
+
 variable-option (<mapping-token> <identifier-token>)
   pair(#"map", %2.string-value);
 %
diff --git a/melange/interface.dylan b/melange/interface.dylan
index aae12da..29f5642 100644
--- a/melange/interface.dylan
+++ b/melange/interface.dylan
@@ -241,15 +241,17 @@ end method process-imports;
 define method merge-container-options
     (first :: <container-options>, #rest rest)
  => (mapper :: <function>, prefix :: <string>, read-only :: <boolean>,
-     sealing :: <string>);
+     sealing :: <string>, external-linkage :: <boolean>);
   let mapper = first.name-mapper;
   let pre = first.prefix;
   let rd-only = first.read-only;
+  let ext-linkage = first.external-linkage;
   let sealing = first.seal-string;
   for (next in rest)
     if (mapper == undefined) mapper := next.name-mapper end if;
     if (pre == undefined) pre := next.prefix end if;
     if (rd-only == undefined) rd-only := next.read-only end if;
+    if (ext-linkage == undefined) ext-linkage := next.external-linkage end if;
     if (sealing == undefined) sealing := next.seal-string end if;
   end for;
   if (mapper == undefined)
@@ -257,8 +259,9 @@ define method merge-container-options
   end if;
   if (pre == undefined) pre := "" end if;
   if (rd-only == undefined) rd-only := #f end if;
+  if (ext-linkage == undefined) ext-linkage := #f end if;
   if (sealing == undefined) sealing := "sealed" end if;
-  values(curry(map-name, mapper), pre, rd-only, sealing);
+  values(curry(map-name, mapper), pre, rd-only, sealing, ext-linkage);
 end method merge-container-options;
 
 //----------------------------------------------------------------------
@@ -308,6 +311,7 @@ define method process-clause
       #"setter" => if (body) decl.setter := body else decl.read-only := #t end;
       #"getter" => decl.getter := body;
       #"read-only" => decl.read-only := body;
+      #"external" => decl.external-linkage := body;
       #"seal" => decl.sealed-string := body;
       #"equate" => equate(decl, body);
       #"map" => remap(decl, body);