Changeset 230

Show
Ignore:
Timestamp:
01/24/07 17:04:53 (2 years ago)
Author:
hauptmech
Message:

changing bindings dir to src/gtkc

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • branches/070125merge/gtkD/wrap/APILookup.txt

    r222 r230  
    137137package: gdk gdk 
    138138package: gtk gtk 
    139 src: lib 
     139bind: gtkc 
    140140 
    141141srcdir: srcgl 
    142142package: glgdk glgdk 
    143143package: glgtk glgtk 
    144 src: lib 
     144bind: gtkglc 
    145145# define other packages to create 
    146146 
    …… 
    176176### predifined: lib 
    177177########################################################### 
    178 wrap: lib 
    179  
     178wrap: gtkc 
    180179copy: paths.d 
    181180copy: Loader.d 
    182  
     181#wrap: gtkglc 
     182#srcout: srcgl 
     183#copy: paths.d 
     184#copy: Loader.d 
     185 
     186srcdir: src 
     187bindDir: gtkc 
    183188lookup: APILookupGLib.txt 
    184189lookup: APILookupGThread.txt 
    …… 
    190195lookup: APILookupGdk.txt 
    191196lookup: APILookupGtk.txt 
     197srcdir: srcgl 
     198bindDir: gtkglc 
    192199lookup: APILookupGLd.txt 
    193200lookup: APILookupGLt.txt 

  • branches/070125merge/gtkD/wrap/APILookupAtk.txt

    r216 r230  
    2929addTypedefs: start 
    3030 
    31 public import glib.glibtypes; 
    32 public import gobject.gobjecttypes; 
     31public import gtkc.glibtypes; 
     32public import gtkc.gobjecttypes; 
    3333public alias void* AtkFocusHandler; 
    3434public struct AtkStateSet; 

  • branches/070125merge/gtkD/wrap/APILookupCairo.txt

    r216 r230  
    3232addTypedefs: start 
    3333 
    34 public import glib.glibtypes; 
     34public import gtkc.glibtypes; 
    3535 
    3636//public import std.c.windows.windows; 

  • branches/070125merge/gtkD/wrap/APILookupGLd.txt

    r216 r230  
    2929addTypedefs: start 
    3030 
    31 public import glib.glibtypes; 
    32 public import gdk.gdktypes; 
     31public import gtkc.glibtypes; 
     32public import gtkc.gdktypes; 
    3333alias uint VisualID; 
    3434 
    …… 
    6161 
    6262wrap: glgdk 
    63 srcout: srcgl 
     63#srcout: srcgl 
    6464 
    6565########################################################### 

  • branches/070125merge/gtkD/wrap/APILookupGLt.txt

    r222 r230  
    2929addTypedefs: start 
    3030 
    31 public import glib.glibtypes; 
    32 public import glgdk.glgdktypes; 
    33 public import gtk.gtktypes; 
     31public import gtkc.glibtypes; 
     32public import gtkglc.glgdktypes; 
     33public import gtkc.gtktypes; 
    3434 
    3535addTypedefs: end 
    …… 
    133133private import glgdk.GLDrawable; 
    134134public import gdk.Event; 
    135 public import lib.gl; 
     135public import gtkglc.gl; 
    136136 
    137137 

  • branches/070125merge/gtkD/wrap/APILookupGObject.txt

    r216 r230  
    2929addTypedefs: start 
    3030 
    31 public import glib.glibtypes; 
     31public import gtkc.glibtypes; 
    3232 
    3333addTypedefs: end 

  • branches/070125merge/gtkD/wrap/APILookupGThread.txt

    r216 r230  
    2929addTypedefs: start 
    3030 
    31 public import glib.glibtypes; 
     31public import gtkc.glibtypes; 
    3232 
    3333addTypedefs: end 

  • branches/070125merge/gtkD/wrap/APILookupGdk.txt

    r222 r230  
    2929addTypedefs: start 
    3030 
    31 public import glib.glibtypes; 
    32 public import gobject.gobjecttypes; 
    33 public import pango.pangotypes; 
    34 public import gdkpixbuf.gdkpixbuftypes; 
     31public import gtkc.glibtypes; 
     32public import gtkc.gobjecttypes; 
     33public import gtkc.pangotypes; 
     34public import gtkc.gdkpixbuftypes; 
    3535 
    3636alias void* GdkAtom; 
    …… 
    128128class: Screen 
    129129prefix: gdk_screen_ 
    130 import: cairoLib.cairoLibtypes 
     130import: gtkc.cairoLibtypes 
    131131import: glib.Str 
    132132import: gdk.Screen 

  • branches/070125merge/gtkD/wrap/APILookupGdkPixbuf.txt

    r216 r230  
    2929addTypedefs: start 
    3030 
    31 public import glib.glibtypes; 
    32 public import gobject.gobjecttypes; 
    33 public import gdk.gdktypes; 
     31public import gtkc.glibtypes; 
     32public import gtkc.gobjecttypes; 
     33public import gtkc.gdktypes; 
    3434public alias void* AtkFocusHandler; 
    3535public struct AtkStateSet; 

  • branches/070125merge/gtkD/wrap/APILookupGtk.txt

    r225 r230  
    3131 
    3232addTypedefs: start 
    33 public import glib.glibtypes; 
    34 public import gobject.gobjecttypes; 
    35 public import pango.pangotypes; 
    36 public import atk.atktypes; 
    37 public import gdkpixbuf.gdkpixbuftypes; 
    38 public import gdk.gdktypes; 
     33public import gtkc.glibtypes; 
     34public import gtkc.gobjecttypes; 
     35public import gtkc.pangotypes; 
     36public import gtkc.atktypes; 
     37public import gtkc.gdkpixbuftypes; 
     38public import gtkc.gdktypes; 
    3939alias void GtkAccelGroupEntry; 
    4040alias void GtkContainerClass; 
    …… 
    128128#structWrap: GdkModifierType* ModifierType 
    129129import: glib.Str 
    130 import: lib.gtk 
    131 import: gtk.gtktypes 
    132 import: lib.gtk 
    133 import: gtk.gtktypes 
     130import: gtkc.gtk 
    134131import: gthread.Thread; 
    135132import: gdk.Threads; 
    …… 
    882879file:  
    883880class: PopupBox 
    884 import: gtk.gtktypes 
    885881import: gtk.MessageDialog; 
    886882import: gtk.Window; 
    887  
    888 import: gtk.gtktypes 
    889883 
    890884code: start 
    …… 
    13321326structWrap: GtkWidget* Widget 
    13331327import: gtk.Image 
    1334 import: gtk.gtktypes 
    13351328import: gtk.Button 
    13361329 
    …… 
    54365429import: gdk.Screen 
    54375430structWrap: GdkScreen* Screen 
    5438 import: lib.gdk 
     5431import: gtkc.gdk 
    54395432import: gdk.Cursor 
    54405433 

  • branches/070125merge/gtkD/wrap/APILookupPango.txt

    r216 r230  
    3030addTypedefs: start 
    3131 
    32 public import glib.glibtypes; 
    33 public import gobject.gobjecttypes; 
     32public import gtkc.glibtypes; 
     33public import gtkc.gobjecttypes; 
    3434 
    3535//public import std.c.windows.windows; 

  • branches/070125merge/gtkD/wrap/HTODopenGL.txt

    r219 r230  
    3333#prefile: wrap/cHeaders/GL/gl.hpp 
    3434pack: glgdk 
     35bindDir: gtkglc 
    3536lib: GL 
    3637dynload: yes 
    3738file: wrap/cHeaders/GL/gl.d 
    38 outfile: srcgl/lib/gl.d 
     39outfile: srcgl/gtkglc/gl.d 
    3940 
    4041#runthis: wine ~/dm/bin/htod.exe wrap/cHeaders/GL/glu.hpp wrap/cHeaders/GL/glu.d -Iwrap/cHeaders 
    4142#prefile: wrap/cHeaders/GL/glu.hpp 
    4243pack: glgdk 
     44bindDir: gtkglc 
    4345lib: GLU 
    4446dynload: yes 
    4547file: wrap/cHeaders/GL/glu.d 
    46 outfile: srcgl/lib/glu.d 
     48outfile: srcgl/gtkglc/glu.d 
    4749 
    4850 

  • branches/070125merge/gtkD/wrap/Loader.d

    r212 r230  
    1515 */ 
    1616  
    17 module lib.Loader; 
     17module gtkc.Loader; 
    1818 
    1919//debug = loadLib; 
    …… 
    6464} 
    6565 
    66 private import lib.paths; 
     66private import gtkc.paths; 
    6767 
    6868/* 

  • branches/070125merge/gtkD/wrap/Makefile

    r224 r230  
    2323 
    2424clean:  
    25     rm obj/*.o ${DTARG}  
     25    rm -rf obj ${DTARG}  
    2626 
    2727     

  • branches/070125merge/gtkD/wrap/paths.d

    r216 r230  
    99 */ 
    1010 
    11 module lib.paths; 
     11module gtkc.paths; 
    1212 
    1313/*  

  • branches/070125merge/gtkD/wrap/utils/GtkDClass.d

    r213 r230  
    5353public class GtkDClass 
    5454{ 
    55      
     55 
    5656    private import std.ctype; 
    5757    private import std.path; 
    …… 
    227227 
    228228        // moved to class level 
    229         gtkDText ~= "private import "~convParms.outPack ~ "."~convParms.outPack~"types;\n\n"; 
    230         gtkDText ~= "private import lib."~convParms.outPack ~ ";\n\n"; 
     229        gtkDText ~= "private import " ~convParms.bindDir~ "." ~convParms.outPack~ "types;\n\n"; 
     230        gtkDText ~= "private import " ~convParms.bindDir~ "." ~convParms.outPack ~ ";\n\n"; 
    231231         
    232232        // moved back to class level 
    …… 
    925925            text ~= "// imports for the signal processing";  
    926926            text ~= "private import gobject.Signals;"; 
    927             text ~= "private import gdk.gdktypes;"; 
     927            text ~= "private import gtkc.gdktypes;"; 
    928928            if ( !isInterface ) 
    929929            { 

  • branches/070125merge/gtkD/wrap/utils/GtkWrapper.d

    r216 r230  
    1919module utils.GtkWrapper; 
    2020 
    21 //debug=copyFile; 
    22 //debug=wrapFile; 
    23 //debug=wrapParameter; 
    24 //debug=createPackage; 
    25 //debug=aliases; 
    26 //debug=lookup; 
    27 //debug=file; 
     21debug=copyFile; 
     22debug=wrapFile; 
     23debug=wrapParameter; 
     24debug=createPackage; 
     25debug=aliases; 
     26debug=lookup; 
     27debug=file; 
    2828debug=writeFile; 
    2929 
    3030struct WError 
    3131{ 
    32    private import std.stdio; 
    33  
    34    int lineNumber; 
    35    int code; 
    36    char[] message; 
    37      
    38      
    39    static WError* create(int lineNumber, int code, char[] message) 
    40    { 
    41        WError* error = new WError; 
    42        error.lineNumber = lineNumber; 
    43        error.code = code; 
    44        error.message = message; 
    45        return error; 
    46    } 
    47      
    48    void print () 
    49    { 
    50        writefln("(line %s, code %s: %s)", lineNumber, code, message); 
    51    } 
     32    private import std.stdio; 
     33 
     34    int lineNumber; 
     35    int code; 
     36    char[] message; 
     37     
     38     
     39    static WError* create(int lineNumber, int code, char[] message) 
     40    { 
     41        WError* error = new WError; 
     42        error.lineNumber = lineNumber; 
     43        error.code = code; 
     44        error.message = message; 
     45        return error; 
     46    } 
     47     
     48    void print () 
     49    { 
     50        writefln("(line %s, code %s: %s)", lineNumber, code, message); 
     51    } 
    5252} 
    5353 
    …… 
    5555private import utils.WrapperIF; 
    5656private import utils.HTODConvert; 
     57 
     58 
     59/* 
     60Paths: 
     61  outputRoot: Where all the wrapper files go. 
     62  srcDir: Wrapper files subdir (src vs srcgl) 
     63  inputRoot: Where the html files are 
     64  apiRoot: Where the API files are 
     65 
     66  buildDir: Where the build files go. 
     67  bindingsDir: Where the C Bindings files go. 
     68 
     69*/ 
     70 
     71char[] joinRootDirFile(char[] root,char[] dir, char[]file) 
     72{ 
     73  return std.path.join(std.path.join(root,dir),file); 
     74} 
    5775 
    5876/** 
    …… 
    6280{ 
    6381 
    64     private import utils.DefReader; 
    65     private import utils.GtkDClass; 
    66     private import utils.convparms; 
    67      
    68     private import std.file; 
    69     private import std.path; 
    70     private import std.stdio; 
    71      
    72     private char[] buildText;   /// to build the build.d  
    73     private char[] buildTextLibs;   /// to build the build.d libs  
    74  
    75     char[] srcOut = "src";      /// the src output directory 
    76     char[] srcDir; 
    77     char[] apiLookupDefinitionBaseDirectory;     
    78     char[] inputRoot; 
    79     char[] outputRoot; 
    80     char[] buildDir = "build"; 
    81     char[] buildPath; 
    82     char[] buildFile =  "gtkD.d"; 
    83  
    84     public static char[] license = 
     82    private import utils.DefReader; 
     83    private import utils.GtkDClass; 
     84    private import utils.convparms; 
     85     
     86    private import std.file; 
     87    private import std.path; 
     88    private import std.stdio; 
     89     
     90    private char[] buildText;   /// to build the build.d  
     91    private char[] buildTextLibs;   /// to build the build.d libs  
     92 
     93    char[] srcOut = "src";      /// the src output directory 
     94    char[] srcDir; 
     95    char[] apiRoot;     
     96    char[] inputRoot; 
     97    char[] outputRoot; 
     98    char[] buildDir = "build"; 
     99    char[] buildPath; 
     100    char[] buildFile =  "gtkD.d"; 
     101    char[] bindingsDir; 
     102 
     103    public static char[] license = 
    85104"/*" 
    86105"\n * This file is part of gtkD." 
    …… 
    106125; 
    107126 
    108     private bit currIncludeComments; 
    109  
    110     enum { 
    111          
    112         ERR_NONE = 1000, 
    113         ERR_UNKNOWNE, 
    114         ERR_NO_LICENSE, 
    115         ERR_INVALID_ALIAS, 
    116         ERR_NO_IN_ROOT, 
    117         ERR_NO_OUT_ROOT, 
    118         ERR_COPY_FILE, 
    119         ERR_FILE_DEFINITION, 
    120         ERR_CREATE_PACKAGE, 
    121     } 
    122      
    123     char[][char[]] aliases; 
    124      
    125     char[][char[]] enumTypes; 
    126      
    127     DefReader defReader; 
    128      
    129      
    130     char[][char[]] packages; 
    131  
    132     WError*[] errors; 
    133  
    134     private char[][] externalDeclarations;  /// the information to build the loader tables 
    135  
    136     private char[][] collectedAliases;  /// public, module level type aliases 
    137     private char[][] collectedEnums;    /// public, module level definitions of enums 
    138     private char[][] stockEnums;        /// special enums for StockID 
    139     private char[][] stockChars;        /// the char[] values for StockIDs 
    140     private char[][] gTypes;            /// special enums for G_TYPE_* 
    141     private char[][] collectedStructs;  /// public, module level definitions of structs 
    142     private char[][] collectedTypes;    /// public, module level definitions of other types 
    143     private char[][] collectedFuncts;   /// public, module level definitions of functions 
    144     private char[][] collectedUnions;   /// public, module level definitions of unions 
    145     private char[][] collectedConstants;/// public, module level type contants 
    146      
    147     private char[][] lookupTypedefs;    /// lookup file definitions to be included on the typedefs.d 
    148     private char[][] lookupAliases;     /// lookup file aliases definitions  
    149     private char[][] lookupEnums;       /// lookup file enum definitions  
    150     private char[][] lookupStructs;     /// lookup file struct definitions  
    151     private char[][] lookupTypes;       /// lookup file type definitions  
    152     private char[][] lookupFuncts;      /// lookup file functs definitions  
    153     private char[][] lookupUnions;      /// lookup file unions definitions  
    154     private char[][] lookupConstants;   /// lookup file constants definitions  
    155      
    156     DefReader[] defReaders; 
    157      
    158     this(char[] apiLookupDefinitionBaseDirectory) 
    159     { 
    160         this.apiLookupDefinitionBaseDirectory = apiLookupDefinitionBaseDirectory; 
    161         //srcOut = "src"; 
    162         //if (!std.file.exists(std.path.join(outputRoot,srcOut))) 
    163         //{ 
    164         //  std.file.mkdir(std.path.join(outputRoot,srcOut)); 
    165         //} 
    166         buildPath = std.path.join(std.path.join(outputRoot,srcOut),buildDir); 
    167          
    168     } 
    169      
    170      
    171     private void startBuildText() 
    172     { 
    173         buildText =  
    174               "/*" 
    175             "\n * Automatically generated build imports from" 
    176             "\n * the initial version generouselly given by:" 
    177             "\n * John Reimer" 
    178             "\n */" 
    179             "\n" 
    180             "\nmodule build;" 
    181             "\n" 
    182             "\nversion( build )" 
    183             "\n{" 
    184             "\n pragma (nolink);" 
    185             "\n" 
    186             "\n version (Windows)     pragma (target, \"GtkD.lib\"  );" 
    187             "\n version (linux)   pragma (target, \"libgtkd.a\" );" 
    188             "\n}" 
    189             "\n" 
    190             ; 
    191  
    192         buildTextLibs.length = 0; 
    193      
    194     } 
    195      
    196     public void writeBuildText() 
    197     { 
    198          
    199         writefln("writeBuildText start"); 
    200         if (!std.file.exists(buildPath)) 
    201         { 
    202             std.file.mkdir(buildPath); 
    203         } 
    204          
    205         std.file.write(std.path.join(buildPath,buildFile), buildText~"\n\n"~buildTextLibs); 
    206     } 
    207      
    208     int process(char[] apiLookupDefinition) 
    209     { 
    210          
    211         startBuildText(); 
    212          
    213         int status = ERR_NONE; 
    214         defReader = new DefReader(std.path.join(apiLookupDefinitionBaseDirectory,apiLookupDefinition)); 
    215  
    216         if ( status==ERR_NONE && "license" == defReader.next() ) 
    217         { 
    218             loadLicense(); 
    219         } 
    220         else 
    221         { 
    222             status = ERR_NO_LICENSE; 
    223             errors ~= WError.create(defReader.getLineNumber(), status, "Missing license as the first definition"); 
    224         } 
    225          
    226         if ( "includeComments" == defReader.next() ) 
    227         { 
    228             currIncludeComments = defReader.getValueBit(); 
    229             defReader.next(); 
    230         } 
    231          
    232         debug(aliases) writefln("key before alias = ",defReader.getKey()); 
    233         while ( "alias" == defReader.getKey() ) 
    234         { 
    235             status = loadAA(aliases, defReader, errors); 
    236             defReader.next(); 
    237         } 
    238          
    239         while ( "enumType" == defReader.getKey() ) 
    240         { 
    241             status = loadAA(enumTypes, defReader, errors); 
    242             defReader.next(); 
    243         } 
    244          
    245         debug(aliases) writefln("key after alias = ",defReader.getKey()); 
    246  
    247         debug(aliases) foreach(char[] key ; aliases.keys.sort) 
    248                         { 
    249                             writefln("alias %s = %s",key, aliases[key]); 
    250                         } 
    251         if ( status==ERR_NONE && "inputRoot" == defReader.getKey() ) 
    252         { 
    253             inputRoot = defReader.getValue(); 
    254         } 
    255         else 
    256         { 
    257             status = ERR_NO_IN_ROOT; 
    258             errors ~= WError.create(defReader.getLineNumber(), status, "Cannot determine input root"); 
    259         } 
    260          
    261         if ( status==ERR_NONE && "outputRoot" == defReader.next() ) 
    262         { 
    263             outputRoot = defReader.getValue(); 
    264         } 
    265         else 
    266         { 
    267             status = ERR_NO_OUT_ROOT; 
    268             errors ~= WError.create(defReader.getLineNumber(), status, "Cannot determine output root"); 
    269         } 
    270          
    271         char[] key = defReader.next(); 
    272          
    273         while ( status==ERR_NONE && ( "srcdir" ==  key )) 
    274         { 
    275             srcDir = defReader.getValue(); 
    276             char[] chkdir = std.path.join(outputRoot,srcDir); 
    277             if (!std.file.exists(chkdir)) 
    278             { 
    279               std.file.mkdir(chkdir); 
    280             } 
    281             key = defReader.next(); 
    282             while ( status==ERR_NONE  
    283                 && ( "package" ==  key 
    284                     || "src" == key ) 
    285                  
    286             ) 
    287             { 
    288                 status = createPackage(outputRoot, defReader.getValue()); 
    289                 key = defReader.next(); 
    290             }     
    291         } 
    292  
    293          
    294          
    295         if ( status==ERR_NONE ) 
    296         { 
    297             char[] pack; 
    298             char[] outPack; 
    299             char[] nextPack; 
    300             while ( status==ERR_NONE 
    301                     && defReader !is null 
    302                     //&& ("wrap" == defReader.getKey() || "lookup" == defReader.getKey()) 
    303                   ) 
    304             { 
    305                 debug(lookup)writefln("(%s) %s=%s", defReader.getFileName(), defReader.getKey(), defReader.getValue() ); 
    306                 switch ( defReader.getKey() ) 
    307                 { 
    308                     case "addTypedefs": lookupTypedefs ~= loadTextMultiLine("addTypedefs"); defReader.next();break; 
    309                     case "addAliases": lookupAliases ~= loadTextMultiLine("addAliases"); defReader.next();break; 
    310                     case "addEnums": lookupEnums ~= loadTextMultiLine("addEnums"); defReader.next();break; 
    311                     case "addStructs": lookupStructs ~= loadTextMultiLine("addStructs"); defReader.next();break; 
    312                     case "addTypes": lookupTypes ~= loadTextMultiLine("addTypes"); defReader.next();break; 
    313                     case "addFuncts": lookupFuncts ~= loadTextMultiLine("addFuncts"); defReader.next();break; 
    314                     case "addUnions": lookupUnions ~= loadTextMultiLine("addUnions"); defReader.next();break; 
    315                     case "addConstants": lookupConstants ~= loadTextMultiLine("addConstants"); defReader.next();break; 
    316                     case "srcout": srcOut = defReader.getValue(); break; 
    317                      
    318                     case "wrap": 
    319                         pack = defReader.getValue(); 
    320                         outPack = packages[pack]; 
    321                         debug(lookup)writefln("wrap %s", outPack); 
    322                         if ( outPack !is null ) 
    323                         { 
    324                             buildText ~= "\n"; 
    325                             if ( outPack != "lib" ) 
    326                             { 
    327                                 buildTextLibs ~= "private import lib."~outPack~";\n"; 
    328                             } 
    329                             status = wrapFile(pack, outPack); 
    330                         } 
    331                         if ( nextPack.length>0 && outPack!=nextPack ) 
    332                         { 
    333                             buildTypedefs(outPack); 
    334                             buildLoaderTable(outPack, externalDeclarations); 
    335                             externalDeclarations.length = 0; 
    336                         } 
    337                         nextPack = outPack.dup; 
    338                         break; 
    339  
    340                     case "lookup": 
    341                         defReaders ~= defReader; 
    342                         defReader = new DefReader(std.path.join(apiLookupDefinitionBaseDirectory,defReader.getValue())); 
    343                         defReader.next(); 
    344                         debug(lookup)writefln("lookup on file %s (%s=%s)", defReader.getFileName(), defReader.getKey(), defReader.getValue() ); 
    345                         break; 
    346  
    347                     case "htod": 
    348                         // not as clean as lookup... 
    349                         // WARNING!!! writefln's are needed to avoid hang. 
    350                         writefln("start htod"); 
    351                         new HTODConvert(defReader.getValue()); 
    352                         writefln("end htod"); 
    353                         defReader.next(); 
    354                         break; 
    355                          
    356                     default: 
    357                         if ( defReader.getKey().length == 0 ) 
    358                         { 
    359                             if ( defReaders.length > 0 ) 
    360                             { 
    361                                 defReader = defReaders[defReaders.length-1]; 
    362                                 defReaders.length = defReaders.length -1; 
    363                                 debug(lookup)writefln("lookup back to %s (%s=%s)", defReader.getFileName(), defReader.getKey(), defReader.getValue() ); 
    364                                 defReader.next(); 
    365                                 debug(lookup)writefln("lookup next == %s (%s=%s)", defReader.getFileName(), defReader.getKey(), defReader.getValue() ); 
    366                             } 
    367                             else 
    368                             { 
    369                                 defReader = null; 
    370                             } 
    371                         } 
    372                         break; 
    373                 } 
    374                 debug(lookup)if(defReader!is null)writefln("loop (%s) %s=%s", defReader.getFileName(), defReader.getKey(), defReader.getValue() ); 
    375             } 
    376         } 
    377         else 
    378         { 
    379             //writefln("status = %s",status); 
    380         } 
    381          
    382         return status; 
    383     } 
    384  
    385     /** 
    386      * Creates an entry on a char[][char[]] associative array 
    387      * Params: 
    388      *      aa =     
    389      *      defReader =      
    390      * Returns:  
    391      */ 
    392     private static int loadAA(inout char[][char[]] aa, DefReader defReader, inout WError*[] errors = null) 
    393     { 
    394         int status = ERR_NONE; 
    395         char[][] vals = std.string.split(defReader.getValue()); 
    396         if ( vals.length == 1 ) 
    397         { 
    398             vals ~= ""; 
    399         } 
    400         if ( vals.length == 2 ) 
    401         { 
    402             aa[vals[0]] = vals[1]; 
    403             debug(aa) writefln("added alias %s = %s", vals[0], vals[1]); 
    404         } 
    405         else 
    406         { 
    407             status = ERR_INVALID_ALIAS; 
    408             if ( errors !is null ) 
    409             { 
    410                 errors ~= WError.create(defReader.getLineNumber(), status, "Invalid alias"); 
    411             } 
    412         } 
    413         return status; 
    414     } 
    415      
    416     private char[] loadLicense() 
    417     { 
    418         license = loadText("license"); 
    419         return license; 
    420     } 
    421  
    422     private char[] loadText(char[] key) 
    423     { 
    424         char[] text; 
    425          
    426         while ( key!=defReader.next(false) && "end"!=defReader.getValue() ) 
    427         { 
    428             if ( text.length > 0 ) 
    429             { 
    430                 text ~= "\n" ~ defReader.getFullLine(); 
    431             } 
    432             else 
    433             { 
    434                 text ~= defReader.getFullLine(); 
    435             } 
    436         } 
    437          
    438         return text; 
    439     } 
    440      
    441     private char[][] loadTextMultiLine(char[] key) 
    442     { 
    443         char[][] text; 
    444          
    445         while ( key!=defReader.next(false) && "end"!=defReader.getValue() ) 
    446         { 
    447             text ~= defReader.getFullLine(); 
    448         } 
    449          
    450         return text; 
    451     } 
    452      
    453     private int copyFile(char[] fromDir, char[] toDir, char[] fileName) 
    454     { 
    455         debug(writeFile)writefln("GtkWrapper.copyFile %s", fileName); 
    456         int status = ERR_NONE; 
    457         debug(file)writefln("(1)GtkWrapper.copyFile %s %s", fromDir, fileName); 
    458         void[] text = std.file.read(std.path.join(fromDir, fileName)); 
    459         try 
    460         { 
    461             //debug(copyFile) 
    462             writefln("copying file [%s] to [%s]", std.path.join(fromDir, fileName), std.path.join(toDir, fileName)); 
    463             if (!std.file.exists(toDir)) 
    464         { 
    465             std.file.mkdir(toDir); 
    466         } 
    467             std.file.write(std.path.join(toDir, fileName), text); 
    468         } 
    469         catch ( Exception e) 
    470         { 
    471             status = ERR_COPY_FILE; 
    472             errors ~= WError.create(defReader.getLineNumber(), status, "Cannot copy  file "~fileName); 
    473         } 
    474          
    475         return status; 
    476     } 
    477      
    478     private int wrapFile(char[] pack, char[] outPack) 
    479     { 
    480         debug(file)writefln("GtkWrapper.wrapFile pack=%s outPack=%s", pack, outPack); 
    481         int status = ERR_NONE; 
    482  
    483         GtkDClass gtkDClass; 
    484          
    485         ConvParms* convParms = new ConvParms; 
    486         convParms.outPack = outPack; 
    487         char[] text; 
    488          
    489         char[] key = defReader.next(); 
    490          
    491         char[] keys = " file text struct realStruct ctorStruct class template interface extend implements prefix strictPrefix" 
    492                       " openFile mergeFile closeFile outFile" 
    493                       " copy import structWrap alias" 
    494                       " noprefix nostruct nocode" 
    495                       " code interfaceCode" 
    496                       " srcout" 
    497                       ; 
    498          
    499         while ( std.string.find(keys, key) > 0 ) 
    500         { 
    501             debug(wrapParameter)writefln("wrapFile [%s] = %s", key, defReader.getValue()); 
    502             switch ( key ) 
    503             { 
    504                 case "copy": status = copyFile( 
    505                             apiLookupDefinitionBaseDirectory,  
    506                             std.path.join(srcOut,outPack),  
    507                             defReader.getValue());  
    508                     buildTextLibs ~= "private import " 
    509                                 ~outPack 
    510                                 ~"."~defReader.getValue()~";\n"; 
    511                     break; 
    512                 case "srcout": srcOut = defReader.getValue(); 
    513                              
    514  
    515                  break; 
    516                  
    517                 case "struct": convParms.strct = defReader.getValue(); break; 
    518                 case "realStruct": convParms.realStrct = defReader.getValue(); break; 
    519                 case "ctorStruct": convParms.ctorStrct = defReader.getValue(); break; 
    520                 case "class": convParms.clss = defReader.getValue(); break; 
    521                 case "extend": convParms.extend = defReader.getValue(); break; 
    522                 case "implements": convParms.impl ~= defReader.getValue(); break; 
    523                 case "template": convParms.templ ~= defReader.getValue(); break; 
    524                 case "prefix": convParms.prefixes ~= defReader.getValue(); break; 
    525                 case "strictPrefix": convParms.strictPrefix = defReader.getValueBit(); break; 
    526                 case "noprefix": convParms.noPrefixes ~= defReader.getValue(); break; 
    527                 case "nocode": convParms.noCode ~= defReader.getValue(); break; 
    528                 case "nostruct": convParms.noStructs ~= defReader.getValue(); break; 
    529                 case "import": convParms.imprts ~= defReader.getValue(); break; 
    530                 case "structWrap": loadAA(convParms.structWrap, defReader, errors); break; 
    531                 case "alias": loadAA(convParms.aliases, defReader, errors); break; 
    532                 case "text":  
    533                     convParms.text ~= loadTextMultiLine("text"); 
    534                     break; 
    535                 case "code":  
    536                     convParms.classCode ~= loadText("code"); 
    537                     break; 
    538                 case "interfaceCode":  
    539                     convParms.interfaceCode ~= loadText("interfaceCode"); 
    540                     break; 
    541                  
    542                 case "openFile":  
    543                     gtkDClass = openFile(outPack, text, convParms); 
    544                     text.length = 0; 
    545                     break; 
    546                 case "mergeFile":  
    547                     gtkDClass.mergeGtkDClass(text, convParms); 
    548                     text.length = 0; 
    549                     break; 
    550                 case "closeFile":  
    551                     closeFile(text, gtkDClass, convParms); 
    552                     text.length = 0; 
    553                     break; 
    554                 case "interface": 
    555                     convParms.interf = defReader.getValue(); 
    556                     char[] saveClass = convParms.clss.dup; 
    557                     char[][] saveTempl = convParms.templ.dup; 
    558                     convParms.templ.length = 0; 
    559                     convParms.outFile = convParms.interf; 
    560                     buildText ~= "\nprivate import " 
    561                             ~convParms.outPack~"." 
    562                             ~defReader.getValue()~";"; 
    563                     outFile(outPack, text, convParms); 
    564                     convParms.clss = saveClass; 
    565                     convParms.templ = saveTempl; 
    566                     // mark not interface (anymore) 
    567                     convParms.interf = ""; 
    568                     // as outFile is always the last definition 
    569                     // there is no need to restore it 
    570                     break; 
    571                 case "outFile":  
    572                     buildText ~= "\nprivate import " 
    573                             ~convParms.outPack~"." 
    574                             ~defReader.getValue()~";"; 
    575                     outFile(outPack, text, convParms); 
    576                     break; 
    577                 case "file":  
    578                     convParms.inFile = std.string.strip(defReader.getValue()); 
    579                     if ( convParms.inFile.length > 0 ) 
    580                     { 
    581                         if ( GtkDClass.startsWith(convParms.inFile,"/") ) 
    582                         { 
    583                             debug(file)writefln("GtkWrapper.wrapFile convParms:\n%s", convParms.toString()); 
    584                             debug(file)writefln("GtkWrapper.wrapFile convParms:\n%s", defReader.toString()); 
    585                             debug(file)writefln("(2)GtkWrapper.wrapFile %s", convParms.inFile); 
    586                             text = cast(char[]) std.file.read(convParms.inFile); 
    587                         } 
    588                         else 
    589                         { 
    590                             debug(file)writefln("(3)GtkWrapper.wrapFile %s", convParms.inFile); 
    591                             text = cast(char[]) std.file.read(std.path.join(std.path.join(inputRoot,pack),convParms.inFile)); 
    592                         } 
    593                     } 
    594                     else 
    595                     { 
    596               &