wrap/utils/funct.d

   1 /*
   2  * This file is part of duit.
   3  *
   4  * duit is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU Lesser General Public License as published by
   6  * the Free Software Foundation; either version 2.1 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * duit is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public License
  15  * along with duit; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  17  */
  18
  19 module utils.funct;
  20
  21 //debug = Funct;
  22 //debug = wrapType;
  23 //debug = unwrapType;
  24 //debug = mainStrct;
  25 //debug = ctor;
  26 //debug = type;
  27 //debug = name;
  28 //debug = parm;
  29 //debug = externalDec
  30 //debug = callback;
  31
  32 public struct Funct
  33 {
  34
  35         private import std.string;
  36         private import std.stdio;
  37
  38         private import utils.convparms;
  39         private import utils.DuitClass;
  40
  41         bit ctor;       /// when true this method was found to be a constructor
  42         char[] type;
  43         char[] typeWrap;
  44         char[] name;
  45         char[] convName;                /// name after convertion
  46         // TODO parms need to be a struct
  47         char[][] parmsType;
  48         char[][] parmsWrap;             /// this is the parameter wrapped type
  49         char[][] parms;
  50         char[][] parmsDesc;
  51         bit[] parmConst;
  52         bit[] parmPointer;
  53         char[] typeDesc;
  54         char[] strctVar;
  55         char[] strctPointer;
  56
  57
  58         /**
  59          * Gets the type, name and parameters of the function
  60          * Params:
  61          *      text =  The Gtk API description of the function call
  62          */
  63         void init(char[] text, ConvParms* convParms)
  64         {
  65                 strctVar = null;
  66                 getStrctVar(convParms);
  67                 strctPointer = convParms.strct.dup ~ '*';
  68                 debug(Funct) writefln("init text=%s", text);
  69                 int p = 0;
  70                 DuitClass.skipBlank(p,text);
  71                 type = DuitClass.untilBlank(p, text);
  72                 debug(type)writef("type = %s", type);
  73                 DuitClass.fixType(type, p, text);
  74                 debug(type)writefln(" -> %s", type);
  75                 DuitClass.skipBlank(p, text);
  76                 name = DuitClass.until(p, text, '(');
  77
  78                 DuitClass.adjustTypeName(type, name);
  79
  80                 typeWrap = getWrappedType(type.dup, convParms);
  81
  82                 DuitClass.skip(p, text,'(');
  83                 int countBrace = 0;
  84                 char[] currParmType;
  85                 char[] currParm;
  86                 debug(parm)writef("%s:", name);
  87                 while ( countBrace==0 && p<text.length && text[p]!=')' )
  88                 {
  89                         currParmType.length = 0;
  90                         currParm.length = 0;
  91
  92                         DuitClass.skipBlank(p, text);
  93                         currParmType = DuitClass.untilBlank(p, text, ",)");
  94                         DuitClass.skipBlank(p, text);
  95                         debug(parm)writef("currParmType = %s", currParmType);
  96                         if ( std.string.find(" const volatile G_CONST_RETURN ", currParmType) > 0 )
  97                         {
  98                                 currParmType = DuitClass.untilBlank(p, text, ",)");
  99                                 DuitClass.skipBlank(p, text);
 100                         }
 101                         if ( "struct"==currParmType )
 102                         {
 103                                 currParmType = DuitClass.untilBlank(p, text, ",)");
 104                                 DuitClass.skipBlank(p, text);
 105                                 currParmType = "void";
 106                         }
 107                         else
 108                         {
 109                                 DuitClass.fixType(currParmType, p, text);
 110                         }
 111                         debug(parm)writefln(" -> %s", currParmType);
 112                         if ( currParmType != "..." )
 113                         {
 114                                 currParm = DuitClass.until(p, text, "),");
 115                         }
 116                         else
 117                         {
 118                                 currParm = "";
 119                         }
 120
 121                         DuitClass.adjustTypeName(currParmType, currParm);
 122
 123                         parmsType ~= currParmType.dup;
 124                         parmsWrap ~= getWrappedType(currParmType.dup, convParms);
 125                         parms ~= currParm.dup;
 126
 127                         if ( p<text.length && text[p]==',') ++p;
 128                 }
 129                 DuitClass.skip(p, text, ';');
 130         }
 131
 132         char[] getStrctVar(ConvParms* convParms)
 133         {
 134                 if ( strctVar.length == 0 )
 135                 {
 136                         if ( convParms.strct.length > 0 )
 137                         {
 138                                 strctVar = DuitClass.toVar(convParms.strct.dup);
 139                         }
 140                         else
 141                         {
 142                                 strctVar = "";
 143                         }
 144                 }
 145                 return strctVar;
 146         }
 147
 148         /**
 149          * Checks the type against the strcutWrap table
 150          * Returns:
 151          */
 152         char[] getWrappedType(char[] currType, ConvParms* convParms)
 153         {
 154                 char[] wType;
 155                 if ( currType == "gchar*" || currType == "char*" )
 156                 {
 157                         wType = "char[]";
 158                 }
 159                 else if ( convParms.structWrap.length == 0 )
 160                 {
 161                         // this should be the common case
 162                         wType = currType;
 163                 }
 164                 else if ( currType in convParms.structWrap )
 165                 {
 166                         wType = convParms.structWrap[currType];
 167                         debug(wrapType) writefln("WrappedType %s -> %s", currType, wType);
 168                 }
 169                 else
 170                 {
 171                         wType = currType;
 172                 }
 173
 174                 debug(wrapType)writefln("\t wrapType: %s -> %s", currType, wType);
 175                 return wType;
 176         }
 177
 178         /**
 179          * Gets the gtk from the Duit class to be used on the Gtk function call
 180          * Params:
 181          *      currType =
 182          *      convParms =
 183          * Returns:
 184          */
 185         char[] getUnwrappedType(char[] currType, ConvParms* convParms)
 186         {
 187                 // TODO
 188                 return currType;
 189         }
 190
 191         /**
 192          * Gets the external declaration
 193          * Params:
 194          *       =
 195          *      aliases =
 196          * Returns:
 197          */
 198         char[] getExternal(ConvParms* convParms, char[][char[]] aliases)
 199         {
 200
 201                 char[] ext = type
 202                                         ~ " function("
 203                                         ~ getParameters(convParms, aliases)
 204                                         ~ ")"
 205                                         ~ name
 206                                         ;
 207
 208                 return ext;
 209         }
 210
 211         char[] getParameters(ConvParms* convParms, char[][char[]] aliases)
 212         {
 213                 char[] parameters;
 214
 215                 int i=0;
 216                 while ( i<parmsType.length && i< parms.length )
 217                 {
 218
 219                         if ( i>0 ) parameters ~= ", ";
 220                         if ( i>=0
 221                                 && (parmsType[i]!="void" || parms[i].length>0)
 222                                 )
 223                         {
 224                                 parameters ~= parmsType[i] ~" "~DuitClass.idsToDuit(parms[i], convParms, aliases);
 225                         }
 226                         ++i;
 227                 }
 228
 229                 return parameters;
 230         }
 231
 232         /**
 233          * Gets the parameters for the call back functions.
 234          * These are all but the first parameter and the last parameter will be the class.
 235          * I'm not sure ths is valid for all callbacks.
 236          * Params:
 237          *      convParms =
 238          *      aliases =
 239          * Returns:
 240          */
 241         char[] getCallbackParameters(int firstParameter, ConvParms* convParms, char[][char[]] aliases)
 242         {
 243                 char[] parameters;
 244
 245                 debug(callback)writefln("getCallbackParameters "~convParms.clss);
 246                 debug(callback)writefln("\t %s", getExternal(convParms, aliases));
 247
 248                 int i=firstParameter;
 249                 while ( i<parmsType.length && i< parms.length )
 250                 {
 251
 252                         if ( i>firstParameter ) parameters ~= ", ";
 253                         if ( i == parms.length-1 )
 254                         {
 255                                 parameters ~= convParms.clss~" "~DuitClass.getClassVar(convParms);
 256                         }
 257                         else if ( i>=firstParameter
 258                                 && (parmsType[i]!="void" || parms[i].length>0)
 259                                 )
 260                         {
 261                                 if ( i == 0 && DuitClass.endsWith(parmsType[i], '*') )
 262                                 {
 263                                         parameters ~= parmsType[i] ~" "~DuitClass.idsToDuit(parms[i], convParms, aliases)~"Struct";
 264                                 }
 265                                 else
 266                                 {
 267                                         parameters ~= parmsType[i] ~" "~DuitClass.idsToDuit(parms[i], convParms, aliases);
 268                                 }
 269                         }
 270                         ++i;
 271                 }
 272
 273                 return parameters;
 274         }
 275
 276         /**
 277          * Gets the actual parameters for the call back functions.
 278          * These are all but the first parameter and the last parameter will be the class.
 279          * I'm not sure ths is valid for all callbacks.
 280          * Params:
 281          *      convParms =
 282          *      aliases =
 283          * Returns:
 284          */
 285         char[] getCallbackVars(ConvParms* convParms, char[][char[]] aliases)
 286         {
 287                 char[] parameters;
 288
 289                 debug(callback)writefln("getCallbackVars "~convParms.clss);
 290                 debug(callback)writefln("\t %s", getExternal(convParms, aliases));
 291
 292                 int i=1;
 293                 while ( i<parmsType.length && i< parms.length )
 294                 {
 295
 296                         if ( i>1 ) parameters ~= ", ";
 297                         if ( i == parms.length-1 )
 298                         {
 299                                 parameters ~= DuitClass.getClassVar(convParms);
 300                         }
 301                         else if ( i>=1
 302                                 && (parmsType[i]!="void" || parms[i].length>0)
 303                                 )
 304                         {
 305                                 //if ( parmsType[i]=="GtkWidget*" )
 306                                 //{
 307                                 //      parameters ~= "new Widget("~DuitClass.idsToDuit(parameterToDuit(i, convParms, aliases), convParms, aliases)~")";
 308                                 //}
 309                                 //else
 310                                 {
 311                                         //parameters ~= DuitClass.idsToDuit(parameterToDuit(i, convParms, aliases), convParms, aliases);
 312                                         parameters ~= parameterToDuit(i, convParms, aliases);
 313                                 }
 314                         }
 315                         ++i;
 316                 }
 317
 318                 return parameters;
 319         }
 320
 321         char[] getDelegateDeclaration(ConvParms* convParms, int firstParameter = 0)
 322         {
 323                 if ( DuitClass.endsWith(typeWrap,"user_function") )
 324                 {
 325                         typeWrap = typeWrap[0..typeWrap.length-13];
 326                 }
 327                 char[] decl = typeWrap ~ " delegate(";
 328
 329                 int pCount = 0;
 330                 foreach(int count, char[] parm ; parmsWrap )
 331                 {
 332                         if ( count >= firstParameter )
 333                         {
 334                                 if ( pCount > 0 )
 335                                 {
 336                                         decl ~= ", ";
 337                                 }
 338                                 if ( count == parmsWrap.length-1 )
 339                                 {
 340                                         decl ~= convParms.clss;
 341                                 }
 342                                 else
 343                                 {
 344                                         decl ~= parm;
 345                                 }
 346                                 ++pCount;
 347                         }
 348                 }
 349                 decl ~= ")";
 350                 return decl;
 351         }
 352
 353
 354         /**
 355          * Gets the method header.
 356          * If the type is a pointer to the main strcut and the name starts with "new"
 357          * then the method is a constructor
 358          * Params:
 359          *      strct =
 360          * Returns:
 361          */
 362         char[] declaration(ConvParms* convParms, char[][char[]] aliases)
 363         {
 364                 char[] dec;
 365                 debug(ctor)writefln("declaration ctor strct = %s",convParms.strct);
 366                 debug(ctor)writefln("declaration ctor realStrct = %s",convParms.realStrct);
 367                 debug(ctor)writefln("declaration ctor type = %s",type);
 368                 debug(ctor)writefln("declaration ctor name = %s",name);
 369                 convName = DuitClass.idsToDuit(name, convParms, aliases);
 370                 if ( convParms.strct.length>0
 371                         && DuitClass.startsWith(convName, "new")
 372                         && ( (type == strctPointer
 373                                         || type == convParms.ctorStrct~"*")
 374                                 || /* special GObject case */
 375                                         (type == "gpointer" && convParms.strct == "GObject")
 376                                 || /* special Gtk... that return a GtkWidget pointer */
 377                                         (type == "GtkWidget*")
 378                                 || /* special Gtk... that return a GtkWidget pointer */
 379                                         (type == "GtkObject*" && convParms.strct == "GtkAdjustment")
 380                                 )
 381                         )
 382                 {
 383                         dec = "public this (";
 384                         ctor = true;
 385                         convName = "this";
 386                 }
 387                 else
 388                 {
 389                         if ( convName == "new" )
 390                         {
 391                                 convName ~= convParms.outFile;
 392                         }
 393                         if ( convParms.strct.length>0
 394                                 && parmsType.length > 0
 395                                 && (parmsType[0] == strctPointer )
 396                                 )
 397                         {
 398                                 dec = "public "~typeWrap~" "~convName~"(";
 399                         }
 400                         else
 401                         {
 402                                 dec = "public static "~typeWrap~" "~convName~"(";
 403                         }
 404                         ctor = false;
 405                 }
 406                 int i=0;
 407                 int parmCount = 0;
 408                 while ( i<parmsType.length && i< parms.length )
 409                 {
 410                         if ( i == 0 )
 411                         {
 412                                 debug(mainStrct)writefln("1st Parm %s ?= %s",parmsType[i], convParms.strct);
 413                                 if ( parmsType[i] == strctPointer )
 414                                 {
 415                                         debug(mainStrct)writefln("\tSAME <<<<<<------");
 416                                         --parmCount;
 417                                 }
 418                         }
 419
 420
 421                         if ( parmCount>0 ) dec ~= ", ";
 422                         if ( parmCount>=0
 423                                 && (parmsType[i]!="void" || parms[i].length>0)
 424                                 )
 425                         {
 426                                 dec ~= parmsWrap[i]~" "~DuitClass.idsToDuit(parms[i], convParms, aliases);
 427                         }
 428                         ++i;
 429                         ++parmCount;
 430                 }
 431                 dec ~= ')';
 432
 433                 return dec;
 434         }
 435
 436         /**
 437          * Wraps the parameters if necessary
 438          * Params:
 439          *      i =
 440          * Returns:
 441          */
 442         char[] parameterToGtk(int i, ConvParms* convParms, char[][char[]] aliases)
 443         {
 444                 char[] parmToGtk;
 445                 if ( parmsType[i] != parmsWrap[i] )
 446                 {
 447                         if ( parmsWrap[i] == "char[]" )
 448                         {
 449                                 parmToGtk = "Str.toStringz("
 450                                                         ~ DuitClass.idsToDuit(parms[i], convParms, aliases)
 451                                                         ~")";
 452                         }
 453                         else
 454                         {
 455                                 char[] id = DuitClass.idsToDuit(parms[i], convParms, aliases);
 456                                 parmToGtk = "("~id~" is null) ? null : "~id~ ".get"~parmsWrap[i]~"Struct()";
 457                         }
 458                 }
 459                 else
 460                 {
 461                         parmToGtk = DuitClass.idsToDuit(parms[i], convParms, aliases);
 462                 }
 463                 return parmToGtk;
 464         }
 465
 466         char[] parameterToDuit(int i, ConvParms* convParms, char[][char[]] aliases)
 467         {
 468                 char[] parmToDuit;
 469                 if ( parmsType[i] != parmsWrap[i] )
 470                 {
 471                         if ( parmsWrap[i] == "char[]" )
 472                         {
 473                                 parmToDuit = "Str.toString("
 474                                                         ~ DuitClass.idsToDuit(parms[i], convParms, aliases)
 475                                                         ~")";
 476                         }
 477                         else
 478                         {
 479                                 //parmToDuit = DuitClass.idsToDuit(parms[i], convParms, aliases);
 480                                 parmToDuit = "new "~parmsWrap[i]~"("~DuitClass.idsToDuit(parms[i], convParms, aliases)~")";
 481                         }
 482                 }
 483                 else
 484                 {
 485                         parmToDuit = DuitClass.idsToDuit(parms[i], convParms, aliases);
 486                 }
 487                 return parmToDuit;
 488         }
 489
 490         char[] getWrapParametersType()
 491         {
 492                 char[] pw;
 493                 foreach ( int count, char[] typeW ; parmsWrap )
 494                 {
 495                         if ( count > 0 )
 496                         {
 497                                 pw ~= ",";
 498                         }
 499                         pw ~= typeW;
 500                 }
 501                 return pw;
 502         }
 503
 504         /**
 505          * Gets the body of the Duit method.
 506          * This include the call to the Gtk function.
 507          * If the first parameter is a pointer to the struct make it implicit and use the internal struct
 508          * Returns: The text of the body of the function NOT including the braces
 509          */
 510         char[][] bod(ConvParms* convParms, char[][char[]] aliases)
 511         {
 512                 char[][] bd;
 513
 514                 //bd ~= "{";
 515
 516                 char[] gtkCall;
 517
 518                 debug(ctor)writefln("body ctor = %s",ctor);
 519
 520                 if ( type != "void" )
 521                 {
 522                         if ( ctor )
 523                         {
 524                                 gtkCall ~= "this(";
 525                                 //if ( convParms.strct == "GObject" )
 526                                 {
 527                                         if ( convParms.realStrct.length > 0 )
 528                                         {
 529                                                 gtkCall ~="cast("~convParms.realStrct~"*)";
 530                                         }
 531                                         else
 532                                         {
 533                                                 gtkCall ~="cast("~convParms.strct~"*)";
 534                                         }
 535
 536                                 }
 537                         }
 538                         else
 539                         {
 540                                 gtkCall ~= "return ";
 541                                 if ( type != typeWrap )
 542                                 {
 543                                         if ( typeWrap == "char[]" )
 544                                         {
 545                                                 gtkCall ~= "Str.toString(";
 546                                         }
 547                                         else
 548                                         {
 549                                                 gtkCall ~= "new "~typeWrap~"( ";
 550                                         }
 551                                 }
 552                         }
 553                 }
 554
 555                 gtkCall ~= name ~ "(";
 556
 557                 int i=0;
 558                 while ( i<parmsType.length && i< parms.length )
 559                 {
 560
 561                         debug(parm) writefln("\t(%s -> %s) %s",parmsType[i], parmsWrap[i], parms[i]);
 562                         if ( i == 0 )
 563                         {
 564                                 if ( parmsType[0]==strctPointer )
 565                                 {
 566                                         if ( convParms.templ.length == 0 )
 567                                         {
 568                                                 gtkCall ~= DuitClass.toVar(convParms.strct.dup);
 569                                         }
 570                                         else
 571                                         {
 572                                                 gtkCall ~= "get"~convParms.clss~"Struct()";
 573                                         }
 574                                 }
 575                                 else if ( parms[0].length>0 )
 576                                 {
 577                                         gtkCall ~= parameterToGtk(0, convParms, aliases);
 578                                 }
 579                         }
 580                         else
 581                         {
 582                                 if ( parms[i].length>0 )
 583                                 {
 584                                         gtkCall ~= ", ";
 585                                         gtkCall ~= parameterToGtk(i, convParms, aliases);
 586                                 }
 587                         }
 588
 589
 590
 591                         ++i;
 592                 }
 593
 594                 if ( ctor )
 595                 {
 596                         gtkCall ~= ") ";
 597                 }
 598                 else if ( type != typeWrap )
 599                 {
 600                         gtkCall ~= ") ";
 601                 }
 602
 603
 604                 gtkCall ~= ");";
 605
 606                 bd ~= gtkCall;
 607                 //bd ~= "}";
 608
 609                 return bd;
 610         }
 611
 612 }