dlls/kernel32/format_msg.c

   1 /*
   2  * FormatMessage implementation
   3  *
   4  * Copyright 1996 Marcus Meissner
   5  * Copyright 2009 Alexandre Julliard
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #include "config.h"
  23
  24 #include <stdarg.h>
  25 #include <stdio.h>
  26 #include <string.h>
  27
  28 #include "ntstatus.h"
  29 #define WIN32_NO_STATUS
  30 #include "windef.h"
  31 #include "winbase.h"
  32 #include "winerror.h"
  33 #include "winternl.h"
  34 #include "winuser.h"
  35 #include "winnls.h"
  36 #include "wine/unicode.h"
  37 #include "kernel_private.h"
  38 #include "wine/debug.h"
  39
  40 WINE_DEFAULT_DEBUG_CHANNEL(resource);
  41
  42 struct format_args
  43 {
  44     ULONG_PTR    *args;
  45     __ms_va_list *list;
  46     int           last;
  47 };
  48
  49 /* Messages used by FormatMessage
  50  *
  51  * They can be specified either directly or using a message ID and
  52  * loading them from the resource.
  53  *
  54  * The resourcedata has following format:
  55  * start:
  56  * 0: DWORD nrofentries
  57  * nrofentries * subentry:
  58  *      0: DWORD firstentry
  59  *      4: DWORD lastentry
  60  *      8: DWORD offset from start to the stringentries
  61  *
  62  * (lastentry-firstentry) * stringentry:
  63  * 0: WORD len (0 marks end)    [ includes the 4 byte header length ]
  64  * 2: WORD flags
  65  * 4: CHAR[len-4]
  66  *      (stringentry i of a subentry refers to the ID 'firstentry+i')
  67  *
  68  * Yes, ANSI strings in win32 resources. Go figure.
  69  */
  70
  71 /**********************************************************************
  72  *      load_message    (internal)
  73  */
  74 static LPWSTR load_message( HMODULE module, UINT id, WORD lang )
  75 {
  76     const MESSAGE_RESOURCE_ENTRY *mre;
  77     WCHAR *buffer;
  78     NTSTATUS status;
  79
  80     TRACE("module = %p, id = %08x\n", module, id );
  81
  82     if (!module) module = GetModuleHandleW( NULL );
  83     if ((status = RtlFindMessage( module, RT_MESSAGETABLE, lang, id, &mre )) != STATUS_SUCCESS)
  84     {
  85         SetLastError( RtlNtStatusToDosError(status) );
  86         return NULL;
  87     }
  88
  89     if (mre->Flags & MESSAGE_RESOURCE_UNICODE)
  90     {
  91         int len = (strlenW( (const WCHAR *)mre->Text ) + 1) * sizeof(WCHAR);
  92         if (!(buffer = HeapAlloc( GetProcessHeap(), 0, len ))) return NULL;
  93         memcpy( buffer, mre->Text, len );
  94     }
  95     else
  96     {
  97         int len = MultiByteToWideChar( CP_ACP, 0, (const char *)mre->Text, -1, NULL, 0 );
  98         if (!(buffer = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) ))) return NULL;
  99         MultiByteToWideChar( CP_ACP, 0, (const char*)mre->Text, -1, buffer, len );
 100     }
 101     TRACE("returning %s\n", wine_dbgstr_w(buffer));
 102     return buffer;
 103 }
 104
 105 static LPWSTR search_message( DWORD flags, HMODULE module, UINT id, WORD lang )
 106 {
 107     LPWSTR from = NULL;
 108     if (flags & FORMAT_MESSAGE_FROM_HMODULE)
 109         from = load_message( module, id, lang );
 110     if (!from && (flags & FORMAT_MESSAGE_FROM_SYSTEM))
 111     {
 112         /* Fold win32 hresult to its embedded error code. */
 113         if (HRESULT_SEVERITY(id) == SEVERITY_ERROR &&
 114             HRESULT_FACILITY(id) == FACILITY_WIN32)
 115         {
 116             id = HRESULT_CODE(id);
 117         }
 118         from = load_message( kernel32_handle, id, lang );
 119     }
 120     return from;
 121 }
 122
 123 /**********************************************************************
 124  *      get_arg    (internal)
 125  */
 126 static ULONG_PTR get_arg( int nr, DWORD flags, struct format_args *args )
 127 {
 128     if (nr == -1) nr = args->last + 1;
 129     if (args->list)
 130     {
 131         if (!args->args) args->args = HeapAlloc( GetProcessHeap(), 0, 99 * sizeof(ULONG_PTR) );
 132         while (nr > args->last)
 133             args->args[args->last++] = va_arg( *args->list, ULONG_PTR );
 134     }
 135     if (nr > args->last) args->last = nr;
 136     return args->args[nr - 1];
 137 }
 138
 139 /**********************************************************************
 140  *      format_insert    (internal)
 141  */
 142 static LPCWSTR format_insert( BOOL unicode_caller, int insert, LPCWSTR format,
 143                               DWORD flags, struct format_args *args,
 144                               LPWSTR *result )
 145 {
 146     static const WCHAR fmt_u[] = {'%','u',0};
 147     WCHAR *wstring = NULL, *p, fmt[256];
 148     ULONG_PTR arg;
 149     int size;
 150
 151     if (*format != '!')  /* simple string */
 152     {
 153         arg = get_arg( insert, flags, args );
 154         if (unicode_caller || !arg)
 155         {
 156             static const WCHAR nullW[] = {'(','n','u','l','l',')',0};
 157             const WCHAR *str = (const WCHAR *)arg;
 158
 159             if (!str) str = nullW;
 160             *result = HeapAlloc( GetProcessHeap(), 0, (strlenW(str) + 1) * sizeof(WCHAR) );
 161             strcpyW( *result, str );
 162         }
 163         else
 164         {
 165             const char *str = (const char *)arg;
 166             DWORD length = MultiByteToWideChar( CP_ACP, 0, str, -1, NULL, 0 );
 167             *result = HeapAlloc( GetProcessHeap(), 0, length * sizeof(WCHAR) );
 168             MultiByteToWideChar( CP_ACP, 0, str, -1, *result, length );
 169         }
 170         return format;
 171     }
 172
 173     format++;
 174     p = fmt;
 175     *p++ = '%';
 176
 177     while (*format == '0' ||
 178            *format == '+' ||
 179            *format == '-' ||
 180            *format == ' ' ||
 181            *format == '*' ||
 182            *format == '#')
 183     {
 184         if (*format == '*')
 185         {
 186             p += sprintfW( p, fmt_u, get_arg( insert, flags, args ));
 187             insert = -1;
 188             format++;
 189         }
 190         else *p++ = *format++;
 191     }
 192     while (isdigitW(*format)) *p++ = *format++;
 193
 194     if (*format == '.')
 195     {
 196         *p++ = *format++;
 197         if (*format == '*')
 198         {
 199             p += sprintfW( p, fmt_u, get_arg( insert, flags, args ));
 200             insert = -1;
 201             format++;
 202         }
 203         else
 204             while (isdigitW(*format)) *p++ = *format++;
 205     }
 206
 207     /* replicate MS bug: drop an argument when using va_list with width/precision */
 208     if (insert == -1 && args->list) args->last--;
 209     arg = get_arg( insert, flags, args );
 210
 211     /* check for ascii string format */
 212     if ((format[0] == 'h' && format[1] == 's') ||
 213         (format[0] == 'h' && format[1] == 'S') ||
 214         (unicode_caller && format[0] == 'S') ||
 215         (!unicode_caller && format[0] == 's'))
 216     {
 217         DWORD len = MultiByteToWideChar( CP_ACP, 0, (char *)arg, -1, NULL, 0 );
 218         wstring = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
 219         MultiByteToWideChar( CP_ACP, 0, (char *)arg, -1, wstring, len );
 220         arg = (ULONG_PTR)wstring;
 221         *p++ = 's';
 222     }
 223     /* check for ascii character format */
 224     else if ((format[0] == 'h' && format[1] == 'c') ||
 225              (format[0] == 'h' && format[1] == 'C') ||
 226              (unicode_caller && format[0] == 'C') ||
 227              (!unicode_caller && format[0] == 'c'))
 228     {
 229         char ch = arg;
 230         wstring = HeapAlloc( GetProcessHeap(), 0, 2 * sizeof(WCHAR) );
 231         MultiByteToWideChar( CP_ACP, 0, &ch, 1, wstring, 1 );
 232         wstring[1] = 0;
 233         arg = (ULONG_PTR)wstring;
 234         *p++ = 's';
 235     }
 236     /* check for wide string format */
 237     else if ((format[0] == 'l' && format[1] == 's') ||
 238              (format[0] == 'l' && format[1] == 'S') ||
 239              (format[0] == 'w' && format[1] == 's') ||
 240              (!unicode_caller && format[0] == 'S'))
 241     {
 242         *p++ = 's';
 243     }
 244     /* check for wide character format */
 245     else if ((format[0] == 'l' && format[1] == 'c') ||
 246              (format[0] == 'l' && format[1] == 'C') ||
 247              (format[0] == 'w' && format[1] == 'c') ||
 248              (!unicode_caller && format[0] == 'C'))
 249     {
 250         *p++ = 'c';
 251     }
 252     /* FIXME: handle I64 etc. */
 253     else while (*format && *format != '!') *p++ = *format++;
 254
 255     *p = 0;
 256     size = 256;
 257     for (;;)
 258     {
 259         WCHAR *ret = HeapAlloc( GetProcessHeap(), 0, size * sizeof(WCHAR) );
 260         int needed = snprintfW( ret, size, fmt, arg );
 261         if (needed == -1 || needed >= size)
 262         {
 263             HeapFree( GetProcessHeap(), 0, ret );
 264             size = max( needed + 1, size * 2 );
 265         }
 266         else
 267         {
 268             *result = ret;
 269             break;
 270         }
 271     }
 272
 273     while (*format && *format != '!') format++;
 274     if (*format == '!') format++;
 275
 276     HeapFree( GetProcessHeap(), 0, wstring );
 277     return format;
 278 }
 279
 280 struct _format_message_data
 281 {
 282     LPWSTR formatted;
 283     DWORD size;
 284     LPWSTR t;
 285     LPWSTR space;
 286     BOOL inspace;
 287     DWORD width, w;
 288 };
 289
 290 static void format_add_char(struct _format_message_data *fmd, WCHAR c)
 291 {
 292     *fmd->t++ = c;
 293     if (fmd->width && fmd->width != FORMAT_MESSAGE_MAX_WIDTH_MASK)
 294     {
 295         switch (c) {
 296         case '\r':
 297         case '\n':
 298             fmd->space = NULL;
 299             fmd->inspace = FALSE;
 300             fmd->w = 0;
 301             break;
 302         case ' ':
 303             if (!fmd->inspace)
 304                 fmd->space = fmd->t - 1;
 305             fmd->inspace = TRUE;
 306             fmd->w++;
 307             break;
 308         default:
 309             fmd->inspace = FALSE;
 310             fmd->w++;
 311         }
 312         if (fmd->w == fmd->width) {
 313             LPWSTR notspace;
 314             if (fmd->space) {
 315                 notspace = fmd->space;
 316                 while (notspace != fmd->t && *notspace == ' ')
 317                     notspace++;
 318             } else
 319                 notspace = fmd->space = fmd->t;
 320             fmd->w = fmd->t - notspace;
 321             memmove(fmd->space+2, notspace, fmd->w * sizeof(*fmd->t));
 322             *fmd->space++ = '\r';
 323             *fmd->space++ = '\n';
 324             fmd->t = fmd->space + fmd->w;
 325             fmd->space = NULL;
 326             fmd->inspace = FALSE;
 327         }
 328     }
 329     if ((DWORD)(fmd->t - fmd->formatted) == fmd->size) {
 330         DWORD_PTR ispace = fmd->space - fmd->formatted;
 331         /* Allocate two extra characters so we can insert a '\r\n' in
 332          * the middle of a word.
 333          */
 334         fmd->formatted = HeapReAlloc(GetProcessHeap(), 0, fmd->formatted, (fmd->size * 2 + 2) * sizeof(WCHAR));
 335         fmd->t = fmd->formatted + fmd->size;
 336         if (fmd->space)
 337             fmd->space = fmd->formatted + ispace;
 338         fmd->size *= 2;
 339     }
 340 }
 341
 342 /**********************************************************************
 343  *      format_message    (internal)
 344  */
 345 static LPWSTR format_message( BOOL unicode_caller, DWORD dwFlags, LPCWSTR fmtstr,
 346                               struct format_args *format_args )
 347 {
 348     struct _format_message_data fmd;
 349     LPCWSTR f;
 350     BOOL eos = FALSE;
 351
 352     fmd.size = 100;
 353     fmd.formatted = fmd.t = HeapAlloc( GetProcessHeap(), 0, (fmd.size + 2) * sizeof(WCHAR) );
 354
 355     fmd.width = dwFlags & FORMAT_MESSAGE_MAX_WIDTH_MASK;
 356     fmd.w = 0;
 357     fmd.inspace = FALSE;
 358     fmd.space = NULL;
 359     f = fmtstr;
 360     while (*f && !eos) {
 361         if (*f=='%') {
 362             int insertnr;
 363             WCHAR *str,*x;
 364
 365             f++;
 366             switch (*f) {
 367             case '1':case '2':case '3':case '4':case '5':
 368             case '6':case '7':case '8':case '9':
 369                 if (dwFlags & FORMAT_MESSAGE_IGNORE_INSERTS)
 370                     goto ignore_inserts;
 371                 else if (((dwFlags & FORMAT_MESSAGE_ARGUMENT_ARRAY) && !format_args->args) ||
 372                         (!(dwFlags & FORMAT_MESSAGE_ARGUMENT_ARRAY) && !format_args->list))
 373                 {
 374                     SetLastError(ERROR_INVALID_PARAMETER);
 375                     HeapFree(GetProcessHeap(), 0, fmd.formatted);
 376                     return NULL;
 377                 }
 378                 insertnr = *f-'0';
 379                 switch (f[1]) {
 380                 case '0':case '1':case '2':case '3':
 381                 case '4':case '5':case '6':case '7':
 382                 case '8':case '9':
 383                     f++;
 384                     insertnr = insertnr*10 + *f-'0';
 385                     f++;
 386                     break;
 387                 default:
 388                     f++;
 389                     break;
 390                 }
 391                 f = format_insert( unicode_caller, insertnr, f, dwFlags, format_args, &str );
 392                 for (x = str; *x; x++) format_add_char(&fmd, *x);
 393                 HeapFree( GetProcessHeap(), 0, str );
 394                 break;
 395             case 'n':
 396                 format_add_char(&fmd, '\r');
 397                 format_add_char(&fmd, '\n');
 398                 f++;
 399                 break;
 400             case 'r':
 401                 format_add_char(&fmd, '\r');
 402                 f++;
 403                 break;
 404             case 't':
 405                 format_add_char(&fmd, '\t');
 406                 f++;
 407                 break;
 408             case '0':
 409                 eos = TRUE;
 410                 f++;
 411                 break;
 412             case '\0':
 413                 SetLastError(ERROR_INVALID_PARAMETER);
 414                 HeapFree(GetProcessHeap(), 0, fmd.formatted);
 415                 return NULL;
 416             ignore_inserts:
 417             default:
 418                 if (dwFlags & FORMAT_MESSAGE_IGNORE_INSERTS)
 419                     format_add_char(&fmd, '%');
 420                 format_add_char(&fmd, *f++);
 421                 break;
 422             }
 423         } else {
 424             WCHAR ch = *f;
 425             f++;
 426             if (ch == '\r') {
 427                 if (*f == '\n')
 428                     f++;
 429                 if(fmd.width)
 430                     format_add_char(&fmd, ' ');
 431                 else
 432                 {
 433                     format_add_char(&fmd, '\r');
 434                     format_add_char(&fmd, '\n');
 435                 }
 436             } else {
 437                 if (ch == '\n')
 438                 {
 439                     if(fmd.width)
 440                         format_add_char(&fmd, ' ');
 441                     else
 442                     {
 443                         format_add_char(&fmd, '\r');
 444                         format_add_char(&fmd, '\n');
 445                     }
 446                 }
 447                 else
 448                     format_add_char(&fmd, ch);
 449             }
 450         }
 451     }
 452     *fmd.t = '\0';
 453
 454     return fmd.formatted;
 455 }
 456
 457 /***********************************************************************
 458  *           FormatMessageA   (KERNEL32.@)
 459  */
 460 DWORD WINAPI FormatMessageA(
 461         DWORD   dwFlags,
 462         LPCVOID lpSource,
 463         DWORD   dwMessageId,
 464         DWORD   dwLanguageId,
 465         LPSTR   lpBuffer,
 466         DWORD   nSize,
 467         __ms_va_list* args )
 468 {
 469     struct format_args format_args;
 470     DWORD ret = 0;
 471     LPWSTR      target;
 472     DWORD       destlength;
 473     LPWSTR      from;
 474
 475     TRACE("(0x%x,%p,%d,0x%x,%p,%d,%p)\n",
 476           dwFlags,lpSource,dwMessageId,dwLanguageId,lpBuffer,nSize,args);
 477
 478     if (dwFlags & FORMAT_MESSAGE_ALLOCATE_BUFFER)
 479     {
 480         if (!lpBuffer)
 481         {
 482             SetLastError(ERROR_NOT_ENOUGH_MEMORY);
 483             return 0;
 484         }
 485         else
 486             *(LPSTR *)lpBuffer = NULL;
 487     }
 488
 489     if (dwFlags & FORMAT_MESSAGE_ARGUMENT_ARRAY)
 490     {
 491         format_args.args = (ULONG_PTR *)args;
 492         format_args.list = NULL;
 493         format_args.last = 0;
 494     }
 495     else
 496     {
 497         format_args.args = NULL;
 498         format_args.list = args;
 499         format_args.last = 0;
 500     }
 501
 502     from = NULL;
 503     if (dwFlags & FORMAT_MESSAGE_FROM_STRING)
 504     {
 505         DWORD length = MultiByteToWideChar(CP_ACP, 0, lpSource, -1, NULL, 0);
 506         from = HeapAlloc( GetProcessHeap(), 0, length * sizeof(WCHAR) );
 507         MultiByteToWideChar(CP_ACP, 0, lpSource, -1, from, length);
 508     }
 509     else if (dwFlags & (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_FROM_SYSTEM))
 510     {
 511         from = search_message( dwFlags, (HMODULE)lpSource, dwMessageId, dwLanguageId );
 512         if (!from) return 0;
 513     }
 514     else
 515     {
 516         SetLastError(ERROR_INVALID_PARAMETER);
 517         return 0;
 518     }
 519
 520     target = format_message( FALSE, dwFlags, from, &format_args );
 521     if (!target)
 522         goto failure;
 523
 524     TRACE("-- %s\n", debugstr_w(target));
 525
 526     /* Only try writing to an output buffer if there are processed characters
 527      * in the temporary output buffer. */
 528     if (*target)
 529     {
 530         destlength = WideCharToMultiByte(CP_ACP, 0, target, -1, NULL, 0, NULL, NULL);
 531         if (dwFlags & FORMAT_MESSAGE_ALLOCATE_BUFFER)
 532         {
 533             LPSTR buf = LocalAlloc(LMEM_ZEROINIT, max(nSize, destlength));
 534             WideCharToMultiByte(CP_ACP, 0, target, -1, buf, destlength, NULL, NULL);
 535             *((LPSTR*)lpBuffer) = buf;
 536         }
 537         else
 538         {
 539             if (nSize < destlength)
 540             {
 541                 SetLastError(ERROR_INSUFFICIENT_BUFFER);
 542                 goto failure;
 543             }
 544             WideCharToMultiByte(CP_ACP, 0, target, -1, lpBuffer, destlength, NULL, NULL);
 545         }
 546         ret = destlength - 1; /* null terminator */
 547     }
 548
 549 failure:
 550     HeapFree(GetProcessHeap(),0,target);
 551     HeapFree(GetProcessHeap(),0,from);
 552     if (!(dwFlags & FORMAT_MESSAGE_ARGUMENT_ARRAY)) HeapFree( GetProcessHeap(), 0, format_args.args );
 553     TRACE("-- returning %u\n", ret);
 554     return ret;
 555 }
 556
 557 /***********************************************************************
 558  *           FormatMessageW   (KERNEL32.@)
 559  */
 560 DWORD WINAPI FormatMessageW(
 561         DWORD   dwFlags,
 562         LPCVOID lpSource,
 563         DWORD   dwMessageId,
 564         DWORD   dwLanguageId,
 565         LPWSTR  lpBuffer,
 566         DWORD   nSize,
 567         __ms_va_list* args )
 568 {
 569     struct format_args format_args;
 570     DWORD ret = 0;
 571     LPWSTR target;
 572     DWORD talloced;
 573     LPWSTR from;
 574
 575     TRACE("(0x%x,%p,%d,0x%x,%p,%d,%p)\n",
 576           dwFlags,lpSource,dwMessageId,dwLanguageId,lpBuffer,nSize,args);
 577
 578     if (!lpBuffer)
 579     {
 580         SetLastError(ERROR_INVALID_PARAMETER);
 581         return 0;
 582     }
 583
 584     if (dwFlags & FORMAT_MESSAGE_ALLOCATE_BUFFER)
 585         *(LPWSTR *)lpBuffer = NULL;
 586
 587     if (dwFlags & FORMAT_MESSAGE_ARGUMENT_ARRAY)
 588     {
 589         format_args.args = (ULONG_PTR *)args;
 590         format_args.list = NULL;
 591         format_args.last = 0;
 592     }
 593     else
 594     {
 595         format_args.args = NULL;
 596         format_args.list = args;
 597         format_args.last = 0;
 598     }
 599
 600     from = NULL;
 601     if (dwFlags & FORMAT_MESSAGE_FROM_STRING) {
 602         from = HeapAlloc( GetProcessHeap(), 0, (strlenW(lpSource) + 1) *
 603             sizeof(WCHAR) );
 604         strcpyW( from, lpSource );
 605     }
 606     else if (dwFlags & (FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_FROM_SYSTEM))
 607     {
 608         from = search_message( dwFlags, (HMODULE)lpSource, dwMessageId, dwLanguageId );
 609         if (!from) return 0;
 610     }
 611     else
 612     {
 613         SetLastError(ERROR_INVALID_PARAMETER);
 614         return 0;
 615     }
 616
 617     target = format_message( TRUE, dwFlags, from, &format_args );
 618     if (!target)
 619         goto failure;
 620
 621     talloced = strlenW(target)+1;
 622     TRACE("-- %s\n",debugstr_w(target));
 623
 624     /* Only allocate a buffer if there are processed characters in the
 625      * temporary output buffer. If a caller supplies the buffer, then
 626      * a null terminator will be written to it. */
 627     if (dwFlags & FORMAT_MESSAGE_ALLOCATE_BUFFER)
 628     {
 629         if (*target)
 630         {
 631             /* nSize is the MINIMUM size */
 632             *((LPVOID*)lpBuffer) = LocalAlloc(LMEM_ZEROINIT, max(nSize, talloced)*sizeof(WCHAR));
 633             strcpyW(*(LPWSTR*)lpBuffer, target);
 634         }
 635     }
 636     else
 637     {
 638         if (nSize < talloced)
 639         {
 640             SetLastError(ERROR_INSUFFICIENT_BUFFER);
 641             goto failure;
 642         }
 643         strcpyW(lpBuffer, target);
 644     }
 645
 646     ret = talloced - 1; /* null terminator */
 647 failure:
 648     HeapFree(GetProcessHeap(),0,target);
 649     HeapFree(GetProcessHeap(),0,from);
 650     if (!(dwFlags & FORMAT_MESSAGE_ARGUMENT_ARRAY)) HeapFree( GetProcessHeap(), 0, format_args.args );
 651     TRACE("-- returning %u\n", ret);
 652     return ret;
 653 }