utils.c

该内容是《》一书的光盘内容

      p = ll->line;
      len = ll->len;

     
      rcol = rcol >= len ? len-1 : rcol;
      if (rcol >= 0)
         p += rcol;

     
      if (p != NULL)
         for (; rcol < len && !myiswhitespc( *p ); rcol++, p++);
      else
         rcol = len;

      
      if (rcol == len) {
         ++rline;
         ll = ll->next;
         if (ll->len != EOF) {
            p = ll->line;
            len = ll->len;
            rcol = 0;
         } else
            rc = ERROR;
      }

     
      while (rc == OK && (p == NULL  ||  (p != NULL && myiswhitespc( *p )))) {
         for (; rcol < len && myiswhitespc( *p ); rcol++, p++);
         if (rcol == len) {
            ++rline;
            ll = ll->next;
            if (ll->len != EOF) {
               p = ll->line;
               len = ll->len;
               rcol = 0;
            } else
               rc = ERROR;
         } else
            break;
      }
   } else
      rc = ERROR;

   if (rc == OK) {
      bin_offset_adjust( window, rline );
      find_adjust( window, ll, rline, rcol );
      make_ruler( window );
      show_ruler( window );
   }

   if (rline != w.rline && !window->file_info->dirty) {
      update_line( &w );
      show_curl_line( window );
   }
   sync( window );
   return( rc );
}



int  next_dirty_line( WINDOW *window )
{
int  rc;
line_list_ptr ll;
long rline;
long bin_offset;       
WINDOW w;

   entab_linebuff( );
   if (un_copy_line( window->ll, window, TRUE ) == ERROR)
      return( ERROR );
   rc = OK;
   dup_window_info( &w, window );
   rline = window->rline;
   ll = window->ll;
   bin_offset = window->bin_offset;
   if (ll->len != EOF) {
      while (rc == OK) {
         if (ll->len != EOF) {
            ++rline;
            bin_offset += ll->len;
            ll = ll->next;
            if (ll->dirty == TRUE)
               break;
         } else
            rc = ERROR;
      }
   } else
      rc = ERROR;

   if (rc == OK) {
      window->bin_offset = bin_offset;
      find_adjust( window, ll, rline, window->rcol );
      make_ruler( window );
      show_ruler( window );
   } else
      error( WARNING, window->bottom_line, utils16 );

   if (rline != w.rline && !window->file_info->dirty) {
      update_line( &w );
      show_curl_line( window );
   }
   sync( window );
   return( rc );
}



int  prev_dirty_line( WINDOW *window )
{
int  rc;
line_list_ptr ll;
long rline;
long bin_offset;        
WINDOW w;

   entab_linebuff( );
   if (un_copy_line( window->ll, window, TRUE ) == ERROR)
      return( ERROR );
   rc = OK;
   dup_window_info( &w, window );
   rline = window->rline;
   ll = window->ll;
   bin_offset = window->bin_offset;
   if (ll->prev != NULL) {
      while (rc == OK) {
         if (ll->prev != NULL) {
            --rline;
            ll = ll->prev;
            bin_offset -= ll->len;
            if (ll->dirty == TRUE)
               break;
         } else
            rc = ERROR;
      }
   } else
      rc = ERROR;

   if (rc == OK) {
      window->bin_offset = bin_offset;
      find_adjust( window, ll, rline, window->rcol );
      make_ruler( window );
      show_ruler( window );
   } else
      error( WARNING, window->bottom_line, utils16 );

   if (rline != w.rline && !window->file_info->dirty) {
      update_line( &w );
      show_curl_line( window );
   }
   sync( window );
   return( rc );
}



int  center_window( WINDOW *window )
{
int  center;
int  center_line;
int  diff;
register file_infos *file;
register WINDOW *win;           

   win = window;
   file = win->file_info;
   center = (win->bottom_line + 1 - win->top_line) / 2 - win->ruler;
   center_line = win->top_line + win->ruler + center;
   diff = center_line - win->cline;
   entab_linebuff( );
   if (un_copy_line( win->ll, win, TRUE ) == ERROR)
      return( ERROR );
   if (g_status.command == CenterWindow) {
      if (diff > 0) {
         if (win->rline + diff <= file->length) {
            update_line( win );
            win->cline += diff;
            win->rline += diff;
            for (; diff > 0; diff--) {
               win->bin_offset += win->ll->len;
               win->ll = win->ll->next;
            }
            show_curl_line( win );
         }
      } else if (diff < 0) {
         update_line( win );
         win->cline += diff;
         win->rline += diff;
         for (; diff < 0; diff++) {
            win->ll = win->ll->prev;
            win->bin_offset -= win->ll->len;
         }
         show_curl_line( win );
      }
   } else {
      if (diff > 0) {
         win->cline += diff;
         if ((long)(win->cline+1 - (win->top_line + win->ruler)) > win->rline)
            win->cline = (win->top_line + win->ruler) - 1 + (int)win->rline;
         file->dirty = LOCAL;
      } else if (diff < 0) {
         win->cline = win->cline + diff;
         file->dirty = LOCAL;
      }
   }
   if (g_status.command == CenterWindow  ||  g_status.command == CenterLine)
      sync( win );
   return( OK );
}



int  horizontal_screen_right( WINDOW *window )
{
int  col;

   col = window->rcol;
   col += (window->end_col + 1 - window->start_col);
   if (col < MAX_LINE_LENGTH) {
      window->rcol = col;
      window->bcol += (window->end_col + 1 - window->start_col);
      window->file_info->dirty = LOCAL;
      check_virtual_col( window, window->rcol, window->ccol );
      make_ruler( window );
      show_ruler( window );
   }
   sync( window );
   return( OK );
}



int  horizontal_screen_left( WINDOW *window )
{
int  screen_width;

   screen_width = window->end_col + 1 - window->start_col;
   if (window->rcol - screen_width < 0) {
      if (window->bcol != 0) {
         window->bcol = 0;
         window->file_info->dirty = LOCAL;
      }
   } else {
      window->rcol -= screen_width;
      window->bcol -= screen_width;
      if (window->bcol < 0)
         window->bcol = 0;
      window->file_info->dirty = LOCAL;
   }
   check_virtual_col( window, window->rcol, window->ccol );
   sync( window );
   make_ruler( window );
   show_ruler( window );
   return( OK );
}



int  goto_top_file( WINDOW *window )
{
register WINDOW *win;   
long num;

   win = window;
   entab_linebuff( );
   if (un_copy_line( win->ll, win, TRUE ) == ERROR)
      return( ERROR );
   if (win->rline != win->cline - (win->top_line+win->ruler-1)) {
      win->bin_offset = 0;
      win->rline = win->cline - (win->top_line+win->ruler-1);
      win->ll = win->file_info->line_list;
      for (num=1; num < win->rline; num++) {
         win->bin_offset += win->ll->len;
         win->ll = win->ll->next;
      }
      display_current_window( win );
   }
   sync( win );
   return( OK );
}



int  goto_end_file( WINDOW *window )
{
register WINDOW *win;  
line_list_ptr ll;
long length;

   win = window;
   entab_linebuff( );
   if (un_copy_line( win->ll, win, TRUE ) == ERROR)
      return( ERROR );
   length = win->file_info->length;
   if (length > win->rline + win->bottom_line - win->cline) {
      win->rline = length - (win->bottom_line - win->cline) + 1;
      win->ll = win->file_info->line_list_end;
      for (;length >= win->rline; length--)
         win->ll = win->ll->prev;

      win->bin_offset = 0;
      ll = win->file_info->line_list;
      for (length = 1; length < win->rline; length++) {
         win->bin_offset += ll->len;
         ll = ll->next;
      }

      display_current_window( win );
   }
   sync( win );
   return( OK );
}



int  goto_line( WINDOW *window )
{
long number;            
long n;
char num_str[MAX_COLS]; 
register WINDOW *win;   
line_list_ptr ll;
int  rc;

   win = window;
   entab_linebuff( );
   if (un_copy_line( win->ll, win, TRUE ) == ERROR)
      return( ERROR );
  
   num_str[0] = '\0';
   
   if (get_name( find11, win->bottom_line, num_str,
                 g_display.message_color ) != OK  ||  *num_str == '\0')
      return( ERROR );
   number = atol( num_str );

   if (number > 0  && number <= (long)win->file_info->length) {
      update_line( win );
      ll = win->ll;
      n = win->rline;
      if (number < win->rline) {
         if (n - number < number - 1) {
            for (; n > number; n--) {
               ll = ll->prev;
               win->bin_offset -= ll->len;
            }
         } else {
            ll = win->file_info->line_list;
            n = 1;
            for (; n < number; n++) {
               win->bin_offset += ll->len;
               ll = ll->next;
            }
         }
      } else if (number > win->rline) {
         for (; n < number; n++) {
            win->bin_offset += ll->len;
            ll = ll->next;
         }
      }
      find_adjust( win, ll, number, win->rcol );
      if (!win->file_info->dirty)
         show_curl_line( win );
      rc = OK;
   } else {
      
      strcat( num_str, find12 );
      ltoa( win->file_info->length, num_str+25, 10 );
      error( WARNING, win->bottom_line, num_str );
      rc = ERROR;
   }
   return( rc );
}



int  set_marker( WINDOW *window )
{
register MARKER  *marker;       

   marker = &window->file_info->marker[g_status.command - SetMark1];
   marker->rline  = window->rline;
   marker->rcol   = window->rcol;
   marker->ccol   = window->ccol;
   marker->bcol   = window->bcol;
   marker->marked = TRUE;
   return( OK );
}



int  goto_marker( WINDOW *window )
{
int  m;
file_infos *file;
long new_rline;
long n;
MARKER *marker;
register WINDOW *win;   
line_list_ptr ll;
int  rc;

   win = window;
   m = g_status.command - GotoMark1;
   file = win->file_info;
   marker = &file->marker[m];
   if (marker->marked) {
      entab_linebuff( );
      if (un_copy_line( win->ll, win, TRUE ) == ERROR)
         return( ERROR );
      file->dirty = LOCAL;
      if (marker->rline > file->length)
         marker->rline = file->length;
      if (marker->rline < 1l)
         marker->rline = 1l;
      new_rline = marker->rline;
      ll = win->ll;
      if (new_rline < win->rline) {
         if (win->rline - new_rline < new_rline - 1) {
            for (n=win->rline; n > new_rline; n--) {
               ll = ll->prev;
               win->bin_offset -= ll->len;
            }
         } else {
            ll = win->file_info->line_list;
            win->bin_offset = 0;
            n = 1;
            for (; n < new_rline; n++) {
               win->bin_offset += ll->len;
               ll = ll->next;
            }
         }
      } else if (new_rline > win->rline) {
         n = win->rline;
         for (; n < new_rline; n++) {
            win->bin_offset += ll->len;
            ll = ll->next;
         }
      }
      win->rline  = new_rline;
      win->ll     = ll;
      win->rcol   = marker->rcol;
      win->ccol   = marker->ccol;
      win->bcol   = marker->bcol;
      if (win->rline < (win->cline - ((win->top_line + win->ruler) - 1)))
         win->cline = (int)win->rline + (win->top_line + win->ruler) - 1;
      check_virtual_col( win, win->rcol, win->ccol );
      make_ruler( window );
      show_ruler( window );
      rc = OK;
   } else {
      if (m == 9)
         m = -1;
      *(utils13 + 7) = (char)('0' + m + 1);
    
      error( WARNING, win->bottom_line, utils13 );
      rc = ERROR;
   }
   return( rc );
}



int  date_time_stamp( WINDOW *window )
{
char date_time[MAX_COLS];
char stuff[20];
register char *dt;
int  year, month, day;
int  hours, minutes;
int  one, two, three;
int  i;
int  pm;


   get_date( &year, &month, &day, &i );
   get_time( &hours, &minutes, &i, &i );
   dt = date_time;

 
   switch (mode.date_style) {
      case MM_DD_YY  :
      case DD_MM_YY  :
      case YY_MM_DD  :
         year = year % 100;
   }

   switch (mode.date_style) {
      case DD_MM_YY   :
      case DD_MM_YYYY :
         one = day;
         two = month;
         three = year;
         break;
      case YY_MM_DD   :
      case YYYY_MM_DD :
         one = year;
         two = month;
         three = day;
         break;
      case MM_DD_YY   :
      case MM_DD_YYYY :
      default         :
         one = month;
         two = day;
         three = year;
         break;
   }
   strcpy( dt, itoa( one, stuff, 10 ) );
   strcat( dt, "-" );
   strcat( dt, itoa( two, stuff, 10 ) );
   strcat( dt, "-" );
   strcat( dt, itoa( three, stuff, 10 ) );

   strcat( dt, "  " );

   pm = FALSE;
   if (mode.time_style == _12_HOUR) {
      if (hours >= 12 && hours < 24)
         pm = TRUE;
      if (hours < 1)
         hours = 12;
      else if (hours >= 13)
         hours -= 12;
   }

   if (hours < 1)
      strcat( dt, "0" );
   strcat( dt, itoa( hours, stuff, 10 ) );
   strcat( dt, ":" );
   if (minutes < 10)
      strcat( dt, "0" );
   strcat( dt, itoa( minutes, stuff, 10 ) );
   if (mode.time_style == _12_HOUR)
      strcat( dt, pm == FALSE ? "am" : "pm" );
   strcat( dt, "  " );
   return( add_chars( dt, window ) );
}



int  add_chars( char *string, WINDOW *window )
{
int  rc = OK;

   while (*string) {
      g_status.key_pressed = *string;
      rc = insert_overwrite( window );
      ++string;
   }
   return( rc );
}