libedittext/drd64_libedittext_undoinfo.c

   1 /*DrDeAmOn64DrDeAmOn64DrDeAmOn64DrDeAmOn64DrDeAmOn64DrDeAmOn64DrDeAmOn64
   2
   3                          D r . D e a m o n  6 4
   4                         for INTEL64(R), AMD64(R)
   5
   6    Copyright(C) 2007-2009 Koine Yuusuke(koinec). All rights reserved.
   7
   8 Redistribution and use in source and binary forms, with or without
   9 modification, are permitted provided that the following conditions are met:
  10
  11  1. Redistributions of source code must retain the above copyright notice,
  12     this list of conditions and the following disclaimer.
  13  2. Redistributions in binary form must reproduce the above copyright
  14     notice, this list of conditions and the following disclaimer in the
  15     documentation and/or other materials provided with the distribution.
  16
  17 THIS SOFTWARE IS PROVIDED BY Koine Yuusuke(koinec) ``AS IS'' AND ANY
  18 EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  19 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  20 DISCLAIMED. IN NO EVENT SHALL Koine Yuusuke(koinec) OR CONTRIBUTORS BE
  21 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  22 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  23 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  24 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  25 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  26 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  27 OF THE POSSIBILITY OF SUCH DAMAGE.
  28
  29 DrDeAmOn64DrDeAmOn64DrDeAmOn64DrDeAmOn64DrDeAmOn64DrDeAmOn64DrDeAmOn64*/
  30
  31 /* File Info -----------------------------------------------------------
  32 File: drd64_.c
  33 Function:
  34 Comment:
  35 ----------------------------------------------------------------------*/
  36
  37 #define DRD64_SRC_LIBEDITTEXT_UNDOINFO
  38 #include"drd64_libedittext.h"
  39
  40 #define LOCATION(n)     DRD64_ERR_LOCATION( \
  41                                                 DRD64_ERROR_MODULE_LIBEDITTEXT, DRD64_ERROR_ARCH_NODEPEND, \
  42                                                 DRD64_SRC_LIBEDITTEXT_UNDOINFO_SRCID, (n))
  43
  44
  45 /*----------------------------------------------------------------------
  46 ----------------------------------------------------------------------*/
  47 Byte *
  48         LibEditText_UndoInfo_ReadDWordData(
  49                         DWord   *pdw_value,
  50                         Byte    *pb_now,
  51                         Byte    b_szflag )
  52 {
  53         Word                                    *pw_tmp;
  54         DWord                                   *pdw_tmp;
  55
  56         if( 0x01 == b_szflag )  {
  57                 *pdw_value      = (DWord)*pb_now;
  58                 pb_now          += sizeof( Byte );
  59         }
  60         else if( 0x02 == b_szflag )     {
  61                 pw_tmp          = (Word *)pb_now;
  62                 *pdw_value      = (DWord)*pw_tmp;
  63                 pb_now          += sizeof( Word );
  64         }
  65         else if( 0x04 == b_szflag )     {
  66                 pdw_tmp         = (DWord *)pb_now;
  67                 *pdw_value      = (DWord)*pdw_tmp;
  68                 pb_now          += sizeof( DWord );
  69         }
  70         else
  71                 { *pdw_value    = 0; }
  72
  73         return pb_now;
  74 }
  75
  76
  77 /*----------------------------------------------------------------------
  78 ----------------------------------------------------------------------*/
  79 Byte
  80         LibEditText_UndoInfo_CalcPhraseSizeBit(
  81                         DWord   dw_data )
  82 {
  83         if( 256 > dw_data )                     { return 0x01; }        // 1Byte Data
  84         else if( 65536 > dw_data )      { return 0x02; }        // 2Byte Data
  85
  86         return 0x03;    // 4Byte Data
  87 }
  88
  89
  90 /*----------------------------------------------------------------------
  91 ----------------------------------------------------------------------*/
  92 Byte *
  93         LibEditText_UndoInfo_SetDWordData(
  94                         Byte *pb_ptr,
  95                         DWord   dw_value )
  96 {
  97         int                     i_size;
  98         Byte            *pb_value;
  99         Word            *pw_value;
 100         DWord           *pdw_value;
 101
 102         if( 256 > dw_value )    {
 103                 pb_value        = (Byte *)pb_ptr;
 104                 *pb_value       = (Byte)dw_value;
 105                 pb_ptr          += sizeof( Byte );
 106         }
 107         else if( 65536 > dw_value )     {
 108                 pw_value        = (Word *)pb_ptr;
 109                 *pw_value       = (Word)dw_value;
 110                 pb_ptr          += sizeof( Word );
 111         }
 112         else    {
 113                 i_size  = 4;
 114                 pdw_value       = (DWord *)pb_ptr;
 115                 *pdw_value      = (Word)dw_value;
 116                 pb_ptr          += sizeof( DWord );
 117         }
 118
 119         return pb_ptr;
 120 }
 121
 122
 123 /*----------------------------------------------------------------------
 124 ----------------------------------------------------------------------*/
 125 Byte *
 126         LibEditText_UndoInfo_ReadDiffValue(
 127                         DWord   *pdw_value,
 128                         Byte    *pb_now,
 129                         Byte    b_szflag,
 130                         Byte    b_direct )
 131 {
 132         Char            *pc_diff;
 133         Short           *ps_diff;
 134         INT                     *pi_diff;
 135         INT                     i_diff  = 0;
 136         DWord           *pdw_tmp;
 137
 138         if( 0x01 == b_szflag )          {
 139                 if( 0x80 == *pb_now )   {
 140                         pb_now  += sizeof( Byte );
 141
 142                         if( 0x00 != b_direct )  {
 143                                 pdw_tmp         = (DWord *)pb_now;
 144                                 *pdw_value      = *pdw_tmp;
 145                         }
 146                         pb_now                  += sizeof( DWord );
 147
 148                         if( 0x00 == b_direct )  {
 149                                 pdw_tmp         = (DWord *)pb_now;
 150                                 *pdw_value      = *pdw_tmp;
 151                         }
 152                         pb_now                  += sizeof( DWord );
 153
 154                         goto    goto_LibEditText_UndoInfo_ReadDiffValue_post;
 155                 }
 156
 157                 pc_diff = (Char *)pb_now;
 158                 i_diff  = (INT)(*pc_diff);
 159                 pb_now  += sizeof( Char );
 160         }
 161         else if( 0x02 == b_szflag )             {
 162                 ps_diff = (Short *)pb_now;
 163                 i_diff  = (INT)(*ps_diff);
 164                 pb_now  += sizeof( Short );
 165         }
 166         else if( 0x03 == b_szflag )             {
 167                 pi_diff = (INT *)pb_now;
 168                 i_diff  = *pi_diff;
 169                 pb_now  += sizeof( INT );
 170         }
 171
 172         if( 0x00 == b_direct )  { i_diff *= -1; }
 173
 174         if( 0 > i_diff )        {
 175                 i_diff  *= -1;
 176                 *pdw_value      -= i_diff;
 177         }
 178         else    {
 179                 *pdw_value      += i_diff;
 180         }
 181
 182 goto_LibEditText_UndoInfo_ReadDiffValue_post:
 183         return pb_now;
 184 }
 185
 186
 187 /*----------------------------------------------------------------------
 188 ----------------------------------------------------------------------*/
 189 Byte
 190         LibEditText_UndoInfo_SetDiffValue(
 191                         Byte    **pb_ptr,
 192                         DWord   dw_newvalue,
 193                         DWord   dw_oldvalue )
 194 {
 195         Byte            b_flag;
 196         INT                     i_diff;
 197         Char            *pc_diff;
 198         Short           *ps_diff;
 199         INT                     *pi_diff;
 200         DWord           dw_diff;
 201         DWord           *pdw_value;
 202
 203         if( dw_newvalue > dw_oldvalue ) {
 204                 dw_diff = dw_newvalue - dw_oldvalue;
 205                 i_diff  = 1;
 206         }
 207         else                                                    {
 208                 dw_diff = dw_oldvalue - dw_newvalue;
 209                 i_diff  = -1;
 210         }
 211
 212         if( 0 == dw_diff )      {
 213                 return 0x00;
 214         }
 215         else if( 2147483648 <= dw_diff )        {
 216                 **pb_ptr        = 0x80;         // -128 is DWord Value Direct Set mode flag.
 217                 (*pb_ptr)++;
 218
 219                 // Set NewValue Data
 220                 pdw_value       = (DWord *)*pb_ptr;
 221                 *pdw_value      = dw_newvalue;
 222                 *pb_ptr         += sizeof( DWord );
 223
 224                 // Set OldValue Data
 225                 pdw_value       = (DWord *)*pb_ptr;
 226                 *pdw_value      = dw_oldvalue;
 227                 *pb_ptr         += sizeof( DWord );
 228
 229                 return 0x01;
 230         }
 231
 232         i_diff  *= (int)dw_diff;
 233
 234         if( 128 > dw_diff )             {
 235                 pc_diff         = (Char *)*pb_ptr;
 236                 *pc_diff        = (Char)i_diff;
 237                 *pb_ptr         += sizeof( Char );
 238                 b_flag          = 0x01;
 239         }
 240         else if( 32768 > dw_diff )      {
 241                 ps_diff         = (Short *)*pb_ptr;
 242                 *ps_diff        = (Short)i_diff;
 243                 *pb_ptr         += sizeof( Short );
 244                 b_flag          = 0x02;
 245         }
 246         else    {
 247                 pi_diff         = (INT *)*pb_ptr;
 248                 (*pi_diff)      = (INT)i_diff;
 249                 *pb_ptr         += sizeof( INT );
 250                 b_flag          = 0x03;
 251         }
 252
 253         return b_flag;
 254 }
 255
 256
 257 /*----------------------------------------------------------------------
 258 ----------------------------------------------------------------------*/
 259 DWord
 260         LibEditText_UndoInfo_GetStringSize(
 261                         LibEditText_TextInfo    *p_tinfo,
 262                         Byte    *pb_now )
 263 {
 264         Byte    *pb_end;
 265         DWord   dw_size;
 266
 267         dw_size = 0;
 268         pb_end  = p_tinfo->pb_undo + p_tinfo->dw_undo_last;
 269
 270         while(( '\0' != *pb_now ) && ( pb_now < pb_end ))       {
 271                 pb_now++;
 272                 dw_size++;
 273         }
 274
 275         return dw_size;
 276 }
 277
 278
 279 /*----------------------------------------------------------------------
 280 ----------------------------------------------------------------------*/
 281 LIBEDITTEXT_UNDOINFO_EXTERN
 282 int
 283         LibEditText_UndoInfo_ReadUndoInfo(
 284                         LibEditText_TextInfo    *p_tinfo,
 285                         LibEditText_UndoInfo    *pt_udinfo,
 286                         DWord                                   dw_line,
 287                         DWord                                   dw_pos,
 288                         Byte                                    *pb_undo,
 289                         Byte                                    b_direct )
 290 {
 291         Byte    *pb_now;
 292         LibEditText_UndoFlag    *pt_udflag;
 293
 294         assert( NULL != pt_udinfo );
 295         assert( NULL != pb_undo );
 296
 297         pb_now  = pb_undo;
 298
 299         // Read Command Byte ---
 300         pt_udinfo->b_cmd        = *pb_now++;
 301
 302         // Read UndoFlag Byte ---
 303         pt_udflag                       = (LibEditText_UndoFlag *)pb_now;
 304         pt_udinfo->t_udflag     = *pt_udflag;
 305         pb_now                          += sizeof( LibEditText_UndoFlag );
 306
 307         // Read LinkSize ---
 308         pb_now  = LibEditText_UndoInfo_ReadDWordData(
 309                                 &(pt_udinfo->dw_prevlength), pb_now, (Byte)(pt_udflag->bf_linksz) );
 310
 311         pt_udinfo->b_data               = 0x00;
 312         pt_udinfo->pb_str               = NULL;
 313         pt_udinfo->dw_data              = 0;
 314         pt_udinfo->dw_plusline  = 0;
 315         pt_udinfo->dw_pluspos   = 0;
 316
 317         // Read Command-Depend Variable Data ---
 318         if( LIBEDITTEXT_UNDOCMD_INSERTSTRING == pt_udinfo->b_cmd )      {
 319                 pt_udinfo->pb_str               = pb_now;
 320                 pt_udinfo->dw_data              = LibEditText_UndoInfo_GetStringSize( p_tinfo, pb_now );
 321                 pt_udinfo->dw_pluspos   = pt_udinfo->dw_data;
 322                 pb_now                                  += (pt_udinfo->dw_pluspos + 1);
 323         }
 324         else if( LIBEDITTEXT_UNDOCMD_INSERTCHAR == pt_udinfo->b_cmd )   {
 325                 pt_udinfo->b_data               = *pb_now;
 326                 pt_udinfo->dw_data              = 1;
 327                 pt_udinfo->dw_pluspos   = 1;
 328                 pb_now                                  += 1;
 329         }
 330         else if( LIBEDITTEXT_UNDOCMD_DELETESTRING == pt_udinfo->b_cmd ) {
 331                 pt_udinfo->pb_str               = pb_now;
 332                 pt_udinfo->dw_data              = LibEditText_UndoInfo_GetStringSize( p_tinfo, pb_now );
 333                 pb_now                                  += (pt_udinfo->dw_data + 1);
 334         }
 335         else if( LIBEDITTEXT_UNDOCMD_DELETECHAR == pt_udinfo->b_cmd )   {
 336                 pt_udinfo->b_data               = *pb_now;
 337                 pt_udinfo->dw_data              = 1;
 338                 pb_now                                  += 1;
 339         }
 340
 341         if( 0x00 == b_direct )  { dw_line       -= pt_udinfo->dw_plusline; }
 342         pt_udinfo->dw_line      = dw_line;
 343         pb_now  = LibEditText_UndoInfo_ReadDiffValue(
 344                                                 &(pt_udinfo->dw_line), pb_now, (Byte)(pt_udflag->bf_line), b_direct );
 345
 346         if( 0x00 == b_direct )  { dw_pos        -= pt_udinfo->dw_pluspos; }
 347         pt_udinfo->dw_pos       = dw_pos;
 348         pb_now  = LibEditText_UndoInfo_ReadDiffValue(
 349                                                 &(pt_udinfo->dw_pos), pb_now, (Byte)(pt_udflag->bf_pos), b_direct );
 350
 351         return 0x00;
 352 }
 353
 354
 355 /*----------------------------------------------------------------------
 356 ----------------------------------------------------------------------*/
 357 LIBEDITTEXT_UNDOINFO_EXTERN
 358 void
 359         LibEditText_UndoInfo_SetRedoFlag(
 360                         Byte                                    *pb_undo )
 361 {
 362         LibEditText_UndoFlag    *pt_udflag;
 363
 364         assert( NULL != pb_undo );
 365
 366         pt_udflag       = (LibEditText_UndoFlag *)(pb_undo + 1);
 367
 368         pt_udflag->bf_redone            = 0x01;
 369
 370         return;
 371 }
 372
 373
 374 /*----------------------------------------------------------------------
 375 ----------------------------------------------------------------------*/
 376 LIBEDITTEXT_UNDOINFO_EXTERN
 377 void
 378         LibEditText_UndoInfo_CommitUndo(
 379                         LibEditText_TextInfo    *p_tinfo,
 380                         int             i_flag )
 381 {
 382         Byte    *pb_undo;
 383         LibEditText_UndoFlag    *pt_udflag;
 384
 385         assert( NULL != p_tinfo );
 386
 387         pb_undo = p_tinfo->pb_undo + p_tinfo->dw_undo_end + 1;
 388         pt_udflag       = (LibEditText_UndoFlag *)pb_undo;
 389
 390         pt_udflag->bf_chain                     = 0x01;
 391         p_tinfo->b_undo_flagchain       = 0x00;
 392         return;
 393 }
 394
 395
 396 /*----------------------------------------------------------------------
 397 ----------------------------------------------------------------------*/
 398 Byte *
 399         LibEditText_UndoInfo_RewindUncommitInfo(
 400                         LibEditText_TextInfo    *p_tinfo )
 401 {
 402         Byte    *pb_undo;
 403         Byte    *pb_last;
 404         Byte    *pb_tmp;
 405         DWord   dw_length;
 406         LibEditText_UndoFlag    *pt_udflag;
 407
 408         assert( NULL != p_tinfo );
 409
 410         if( 0 == p_tinfo->dw_undo_last )        { return p_tinfo->pb_undo; }
 411
 412         pb_undo = p_tinfo->pb_undo + p_tinfo->dw_undo_end;
 413         pb_last = p_tinfo->pb_undo + p_tinfo->dw_undo_last;
 414
 415         pt_udflag       = (LibEditText_UndoFlag *)(pb_undo + 1);
 416
 417         while( 0x00 == pt_udflag->bf_chain )    {
 418                 pb_tmp  = LibEditText_UndoInfo_ReadDWordData( &dw_length, pb_undo, pt_udflag->bf_linksz );
 419                 if( 0 == dw_length )    { break; }
 420
 421                 pb_last = pb_undo;
 422                 pb_undo -= dw_length;
 423
 424                 pt_udflag       = (LibEditText_UndoFlag *)(pb_undo + 1);
 425         }
 426
 427         p_tinfo->dw_undo_end    = pb_undo - p_tinfo->pb_undo;
 428         p_tinfo->dw_undo_last   = pb_last - p_tinfo->pb_undo;
 429
 430         return pb_last;
 431 }
 432
 433
 434 /*----------------------------------------------------------------------
 435 ----------------------------------------------------------------------*/
 436 LIBEDITTEXT_UNDOINFO_EXTERN
 437 int
 438         LibEditText_UndoInfo_CancelUndoInfo(
 439                         LibEditText_TextInfo    *p_tinfo )
 440 {
 441         Byte    *pb_undo;
 442         Byte    *pb_last;
 443         Byte    *pb_tmp;
 444         DWord   dw_length;
 445         LibEditText_UndoFlag    *pt_udflag;
 446
 447         assert( NULL != p_tinfo );
 448
 449         if( 0 == p_tinfo->dw_undo_last )        { return 0x01; }
 450
 451         pb_undo = p_tinfo->pb_undo + p_tinfo->dw_undo_end;
 452         pb_last = p_tinfo->pb_undo + p_tinfo->dw_undo_last;
 453
 454         pt_udflag       = (LibEditText_UndoFlag *)(pb_undo + 1);
 455
 456         pb_tmp  = LibEditText_UndoInfo_ReadDWordData( &dw_length, pb_undo, pt_udflag->bf_linksz );
 457
 458         if( 0 < dw_length )     {
 459                 pb_last = pb_undo;
 460                 pb_undo -= dw_length;
 461
 462                 p_tinfo->dw_undo_end    = pb_undo - p_tinfo->pb_undo;
 463                 p_tinfo->dw_undo_last   = pb_last - p_tinfo->pb_undo;
 464         }
 465         else    {
 466                 dw_length                               = p_tinfo->dw_undo_last;
 467                 p_tinfo->dw_undo_last   = 0;
 468         }
 469
 470         memset( pb_undo, 0x00, dw_length );
 471
 472         return 0x00;
 473 }
 474
 475
 476 /*----------------------------------------------------------------------
 477 ----------------------------------------------------------------------*/
 478 LIBEDITTEXT_UNDOINFO_EXTERN
 479 int
 480         LibEditText_UndoInfo_SetUndoInfo(
 481                         LibEditText_TextInfo    *p_tinfo,
 482                         DWord   dw_line,
 483                         DWord   dw_pos,
 484                         Byte    b_cmd,
 485                         Byte    b_data,
 486                         Byte    *pb_str,
 487                         DWord   dw_strlength )
 488 {
 489         Byte                                    *pb_undo;
 490         Byte                                    *pb_now;
 491         DWord                                   dw_afterline;
 492         DWord                                   dw_afterpos;
 493         DWord                                   dw_prevlength;
 494         DWord                                   dw_undolength;
 495         LibEditText_UndoFlag    *pt_udflag;
 496
 497         assert( NULL != p_tinfo );
 498         pb_undo = p_tinfo->pb_undo + p_tinfo->dw_undo_last;
 499
 500         /* Check & Expand Undo-Buffer --- */
 501         dw_undolength   = sizeof( LibEditText_UndoFlag ) + (sizeof( DWord ) * 3) + dw_strlength + 1;
 502         if( p_tinfo->dw_undo_bufsize <= (p_tinfo->dw_undo_last + dw_undolength) )       {
 503                 pb_undo = (Byte *)realloc( p_tinfo->pb_undo,
 504                                 (p_tinfo->dw_undo_bufsize + DRD64_LIBEDITTEXT_DEFAULT_UNDOINFO_BUFSIZE) );
 505                 if( NULL == pb_undo     )       {
 506                         return -0x01;
 507                 }
 508
 509                 memset( (pb_undo + p_tinfo->dw_undo_bufsize), 0x00,
 510                                                                 DRD64_LIBEDITTEXT_DEFAULT_UNDOINFO_BUFSIZE );
 511
 512                 p_tinfo->dw_undo_bufsize        += DRD64_LIBEDITTEXT_DEFAULT_UNDOINFO_BUFSIZE;
 513                 p_tinfo->pb_undo                        = pb_undo;
 514
 515                 pb_undo += p_tinfo->dw_undo_last;       // Refreash pb_undo ptr.
 516         }
 517
 518         // Init. Recoding Ptr. ---
 519         pb_now          = pb_undo;
 520
 521         // Record Undo-Command ---
 522         *pb_now++       = b_cmd;
 523
 524         // Reserve UndoFlag Byte ---
 525         pt_udflag       = (LibEditText_UndoFlag *)pb_now;
 526         pb_now          += sizeof( LibEditText_UndoFlag );
 527
 528         pt_udflag->bf_redone    = 0x00;
 529         pt_udflag->bf_chain             = 0x00;
 530
 531         // Record Link Prev. UndoInfo ---
 532         if( 0 < p_tinfo->dw_undo_last ) {
 533                 dw_prevlength                   = p_tinfo->dw_undo_last - p_tinfo->dw_undo_end;
 534                 pt_udflag->bf_linksz    = LibEditText_UndoInfo_CalcPhraseSizeBit( dw_prevlength );
 535                 pb_now  = LibEditText_UndoInfo_SetDWordData( pb_now, dw_prevlength );
 536         }
 537         else
 538                 { pt_udflag->bf_linksz  = 0x00; }
 539
 540         // Record Command-Data ---
 541         dw_afterline    = dw_line;
 542         dw_afterpos             = dw_pos;
 543
 544         if( LIBEDITTEXT_UNDOCMD_INSERTSTRING == b_cmd )         {
 545                 // Variable Stirng
 546                 assert( NULL != pb_str );
 547
 548                 memcpy( pb_now, pb_str, dw_strlength );
 549                 pb_now  += dw_strlength;
 550
 551                 dw_afterpos     += dw_strlength;
 552
 553                 *pb_now++       = '\0';
 554         }
 555         else if( LIBEDITTEXT_UNDOCMD_INSERTCHAR == b_cmd )      {
 556                 // 1Byte -- Inserting Character Byte
 557                 dw_afterpos++;
 558                 *pb_now++       = b_data;
 559         }
 560         else if( LIBEDITTEXT_UNDOCMD_DELETESTRING == b_cmd )    {
 561                 // Save Delete-String for Undo-Buffer ---
 562                 assert( NULL != pb_str );
 563
 564                 memcpy( pb_now, pb_str, dw_strlength );
 565                 pb_now  += dw_strlength;
 566
 567                 *pb_now++       = '\0';
 568         }
 569         else if( LIBEDITTEXT_UNDOCMD_DELETECHAR == b_cmd )      {
 570                 *pb_now++       = b_data;
 571         }
 572 /*
 573         following Command is NO-Data!
 574                 LIBEDITTEXT_UNDOCMD_DELETELINE
 575                 LIBEDITTEXT_UNDOCMD_INSERTLINE
 576 */
 577
 578         // Record Prev. Undo-Line ---
 579         pt_udflag->bf_line      = LibEditText_UndoInfo_SetDiffValue(
 580                                                                                 &pb_now, dw_line, p_tinfo->dw_undo_line );
 581
 582         // Record Prev. Undo-Pos. ---
 583         pt_udflag->bf_pos       = LibEditText_UndoInfo_SetDiffValue(
 584                                                                                 &pb_now, dw_pos, p_tinfo->dw_undo_pos );
 585
 586         p_tinfo->dw_undo_line   = dw_afterline;
 587         p_tinfo->dw_undo_pos    = dw_afterpos;
 588         p_tinfo->dw_undo_end    = p_tinfo->dw_undo_last;
 589         p_tinfo->dw_undo_last   = pb_now - p_tinfo->pb_undo;;
 590
 591         return 0x00;
 592 }
 593
 594
 595 /*----------------------------------------------------------------------
 596 ----------------------------------------------------------------------*/
 597 LIBEDITTEXT_UNDOINFO_EXTERN
 598 int
 599         LibEditText_UndoInfo_Init(
 600                         LibEditText_TextInfo    *p_tinfo )
 601 {
 602         Byte    *pb_undo;
 603
 604         assert( NULL != p_tinfo );
 605
 606         if( NULL != p_tinfo->pb_undo )  {
 607                 return -0x01;
 608         }
 609
 610         pb_undo = (Byte *)malloc( DRD64_LIBEDITTEXT_DEFAULT_UNDOINFO_BUFSIZE );
 611         if( NULL == pb_undo )   {
 612                 return -0x02;
 613         }
 614         memset( pb_undo, 0x00, DRD64_LIBEDITTEXT_DEFAULT_UNDOINFO_BUFSIZE );
 615
 616         p_tinfo->pb_undo                        = pb_undo;
 617         p_tinfo->dw_undo_bufsize        = 0;
 618         p_tinfo->dw_undo_last           = 0;
 619         p_tinfo->dw_undo_line           = 0;
 620         p_tinfo->dw_undo_pos            = 0;
 621
 622         return 0x00;
 623 }
 624
 625
 626 /*----------------------------------------------------------------------
 627 ----------------------------------------------------------------------*/
 628 LIBEDITTEXT_UNDOINFO_EXTERN
 629 int
 630         LibEditText_UndoInfo_Term(
 631                         LibEditText_TextInfo    *p_tinfo )
 632 {
 633
 634         assert( NULL != p_tinfo );
 635
 636         if( NULL == p_tinfo->pb_undo )  {
 637                 return -0x01;
 638         }
 639
 640         free( p_tinfo->pb_undo );
 641
 642         p_tinfo->pb_undo                        = NULL;
 643         p_tinfo->dw_undo_bufsize        = 0;
 644         p_tinfo->dw_undo_last           = 0;
 645         p_tinfo->dw_undo_line           = 0;
 646         p_tinfo->dw_undo_pos            = 0;
 647
 648         return 0x00;
 649 }
 650
 651
 652 /* EOF of drd64_.c ----------------------------------- */