Changeset 4074

Show
Ignore:
Timestamp:
05/13/06 09:57:50 (3 years ago)
Author:
miyoshi
Message:

* mw32term.c: Purge XSTRING and use SDATA, SBYTES and SCHARS
instead.

* mw32menu.c: Ditto.

* mw32ime.c: Ditto.

* mw32font.c: Ditto.

* mw32dl.c: Ditto.

* mw32clpbd.c: Ditto.

* mw32bdf.c: Ditto.

* w32.c (normalize_filename): Ditto.
Normalize coding style.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • trunk/src/ChangeLog.Meadow

    r4073 r4074  
     12006-05-13  MIYOSHI Masanori  <miyoshi@meadowy.org> 
     2 
     3        * mw32term.c: Purge XSTRING and use SDATA, SBYTES and SCHARS 
     4        instead. 
     5 
     6        * mw32menu.c: Ditto. 
     7 
     8        * mw32ime.c: Ditto. 
     9 
     10        * mw32font.c: Ditto. 
     11 
     12        * mw32dl.c: Ditto. 
     13 
     14        * mw32clpbd.c: Ditto. 
     15 
     16        * mw32bdf.c: Ditto. 
     17 
     18        * w32.c (normalize_filename): Ditto. 
     19        Normalize coding style. 
     20 
    1212006-05-03  MIYOSHI Masanori  <miyoshi@meadowy.org> 
    222 

  • trunk/src/mw32bdf.c

    r4003 r4074  
    340340  Lisp_Object ret = Qnil; 
    341341 
    342   bdffontp = mw32_init_bdf_font (XSTRING (fontfile)->data); 
     342  bdffontp = mw32_init_bdf_font (SDATA (fontfile)); 
    343343 
    344344  if (!bdffontp) return Qnil; 

  • trunk/src/mw32clpbd.c

    r3956 r4074  
    8585  BLOCK_INPUT; 
    8686 
    87   htextsize = decoding_buffer_size (&coding, 
    88                                     STRING_BYTES (XSTRING (string)) + 1); 
     87  htextsize = decoding_buffer_size (&coding, SBYTES (string) + 1); 
    8988  if ((htext = GlobalAlloc (GMEM_MOVEABLE | GMEM_DDESHARE, 
    9089                            htextsize)) == NULL) 
    …… 
    9493      if ((hmuletext = 
    9594           GlobalAlloc (GMEM_MOVEABLE | GMEM_DDESHARE, 
    96                         MW32_MULE_CB_REQSIZE (STRING_BYTES (XSTRING (string)) 
    97                                               + 1))) 
     95                        MW32_MULE_CB_REQSIZE (SBYTES (string) + 1))) 
    9896          == NULL) 
    9997        goto error; 
    …… 
    10199        goto error; 
    102100 
    103       MW32_MULE_SET_CB (lpmulecb, XSTRING (string)->data, 
    104                         STRING_BYTES(XSTRING (string)) + 1); 
     101      MW32_MULE_SET_CB (lpmulecb, SDATA (string), SBYTES (string) + 1); 
    105102      GlobalUnlock (hmuletext); 
    106103    } 
    …… 
    108105    goto error; 
    109106 
    110   encode_coding (&coding, XSTRING (string)->data, lptext, 
    111                  STRING_BYTES(XSTRING (string)), htextsize); 
     107  encode_coding (&coding, SDATA (string), lptext, SBYTES (string), htextsize); 
    112108  size = coding.produced; 
    113109  lptext[size] = '\0'; 

  • trunk/src/mw32dl.c

    r4065 r4074  
    148148  CHECK_STRING (filename); 
    149149 
    150   hlib = LoadLibrary (XSTRING (filename)->data); 
     150  hlib = LoadLibrary (SDATA (filename)); 
    151151 
    152152  current_dls++; 

  • trunk/src/mw32font.c

    r4065 r4074  
    881881  buf = alloca (bufsize); 
    882882  /* LOGFONT is NEVER accessed by lisp interpreter. */ 
    883   encode_coding (&coding, XSTRING (src)->data, buf, 
     883  encode_coding (&coding, SDATA (src), buf, 
    884884                 LISPY_STRING_BYTES (src), bufsize); 
    885885  size = coding.produced; 
    …… 
    11031103      plf->encoding.e.ccl_method.size = size; 
    11041104      plf->encoding.e.ccl_method.data = data; 
    1105       memcpy (data, XSTRING (symname)->data, size); 
     1105      memcpy (data, SDATA (symname), size); 
    11061106 
    11071107      byte = Fget (encoding, Qfont_unit_byte); 
    …… 
    12341234xlfd_pattern_regexp (Lisp_Object pattern) 
    12351235{ 
    1236   if (!index (XSTRING (pattern)->data, '*') 
    1237       && !index (XSTRING (pattern)->data, '?')) 
     1236  if (!index (SDATA (pattern), '*') 
     1237      && !index (SDATA (pattern), '?')) 
    12381238    /* PATTERN does not contain any wild cards.  */ 
    12391239    return pattern; 
    …… 
    12411241  { 
    12421242    /* We must at first update the cached data.  */ 
    1243     char *regex = (char *) alloca (XSTRING (pattern)->size * 2 + 3); 
     1243    char *regex = (char *) alloca (SCHARS (pattern) * 2 + 3); 
    12441244    char *p0, *p1 = regex; 
    12451245 
    12461246    /* Convert "*" to ".*", "?" to ".".  */ 
    12471247    *p1++ = '^'; 
    1248     for (p0 = (char *) XSTRING (pattern)->data; *p0; p0++) 
     1248    for (p0 = (char *) SDATA (pattern); *p0; p0++) 
    12491249      { 
    12501250        if (*p0 == '*') 
    …… 
    16741674      unsigned char* filename; 
    16751675      tem = XCDR (llf); 
    1676       filename = XSTRING (CAR (tem))->data; 
     1676      filename = SDATA (CAR (tem)); 
    16771677      plf = mw32_add_logical_font (pfr); 
    16781678      if (!mw32_set_bdf_font (f, plf, filename)) 
    …… 
    17081708  if (LISPY_STRING_BYTES (family_attr) != 1) return 0; 
    17091709 
    1710   name = XSTRING (family_attr)->data; 
     1710  name = SDATA (family_attr); 
    17111711  if (name[0] == '*') return 1; 
    17121712 
    …… 
    21882188        { 
    21892189          int idx; 
    2190           idx = mw32_get_font_request (XSTRING (lfont_name)->data); 
     2190          idx = mw32_get_font_request (SDATA (lfont_name)); 
    21912191          if (idx >= 0) pfr = &mw32_fr_table[idx]; 
    21922192          else pfr = NULL; 
    …… 
    24062406  CHECK_LIST (alist); 
    24072407 
    2408   if (mw32_get_font_request (XSTRING (name)->data) >= 0) 
    2409     error ("Already registerd %s font.", XSTRING (name)->data); 
     2408  if (mw32_get_font_request (SDATA (name)) >= 0) 
     2409    error ("Already registerd %s font.", SDATA (name)); 
    24102410 
    24112411  mw32_check_font_request_alist (alist); 
    24122412 
    2413   mw32_internal_add_font (XSTRING (name)->data, alist); 
     2413  mw32_internal_add_font (SDATA (name), alist); 
    24142414 
    24152415  return Qnil; 
    …… 
    24292429  CHECK_LIST (alist); 
    24302430 
    2431   idx = mw32_get_font_request (XSTRING (name)->data); 
     2431  idx = mw32_get_font_request (SDATA (name)); 
    24322432  if (idx < 0) 
    2433     error ("Font request %s is not registered.", XSTRING (name)->data); 
     2433    error ("Font request %s is not registered.", SDATA (name)); 
    24342434 
    24352435  mw32_check_font_request_alist (alist); 
    …… 
    24392439  pfr->loaded_LF_num = 0; 
    24402440  pfr->idx = idx; 
    2441   pfr->name = xstrdup (XSTRING (name)->data); 
     2441  pfr->name = xstrdup (SDATA (name)); 
    24422442 
    24432443  return Qnil; 
    …… 
    24692469  CHECK_STRING (name); 
    24702470 
    2471   idx = mw32_get_font_request (XSTRING (name)->data); 
     2471  idx = mw32_get_font_request (SDATA (name)); 
    24722472  if (idx < 0) 
    2473     error ("Font request %s is not registered.", XSTRING (name)->data); 
     2473    error ("Font request %s is not registered.", SDATA (name)); 
    24742474 
    24752475  return AREF (Vmw32_font_request_table, idx); 
    …… 
    26402640                                      LISPY_STRING_BYTES (family) + 1); 
    26412641      buf = alloca (bufsize); 
    2642       encode_coding (&coding, XSTRING (family)->data, buf, 
     2642      encode_coding (&coding, SDATA (family), buf, 
    26432643                     LISPY_STRING_BYTES (family), bufsize); 
    26442644      size = coding.produced; 

  • trunk/src/mw32ime.c

    r4065 r4074  
    14021402 
    14031403  MEADOW_ENCODE_ALLOC (LISPY_STRING_BYTES (object)); 
    1404   MEADOW_ENCODE (XSTRING (object)->data, LISPY_STRING_BYTES (object)); 
     1404  MEADOW_ENCODE (SDATA (object), LISPY_STRING_BYTES (object)); 
    14051405  len = MEADOW_ENCODE_PRODUCED; 
    14061406  MEADOW_ENCODE_BUF[len] = '\0'; 
    …… 
    16491649      str = XCONS (curelem)->car; 
    16501650      attr = XCONS (curelem)->u.cdr; 
    1651       encode_coding (&coding, XSTRING (str)->data, cs, 
     1651      encode_coding (&coding, SDATA (str), cs, 
    16521652                     LISPY_STRING_BYTES (str), size); 
    16531653      strsize = coding.produced; 

  • trunk/src/mw32menu.c

    r4065 r4074  
    427427  TCHAR *menu_str = 0; 
    428428 
    429   if (NILP (name) || name_is_separator (XSTRING (name)->data)) 
     429  if (NILP (name) || name_is_separator (SDATA (name))) 
    430430    AppendMenu (hmenu, MF_SEPARATOR, menu_id, NULL); 
    431431  else 
    …… 
    438438#endif 
    439439      if (STRINGP (description)) 
    440         desclen = strlen (XSTRING (description)->data); 
     440        desclen = strlen (SDATA (description)); 
    441441      /* Never description set to a size entry... so use 'strlen' */ 
    442442      else 
    …… 
    449449                                            LISPY_STRING_BYTES (name) + 1); 
    450450      menu_str = alloca (decodebufsize + desclen); 
    451       encode_coding (&coding, XSTRING (name)->data, menu_str, 
     451      encode_coding (&coding, SDATA (name), menu_str, 
    452452                     LISPY_STRING_BYTES (name), decodebufsize); 
    453453      size = coding.produced; 
    454454#else 
    455       size = LISPY_STRING_BYTES (XSTRING (name)); 
     455      size = LISPY_STRING_BYTES (name); 
    456456      menu_str = alloca (size + desclen + 1); 
    457       memcpy (menu_str, XSTRING (name)->data, size); 
     457      memcpy (menu_str, SDATA (name), size); 
    458458#endif 
    459459      if (desclen) 
    460         memcpy (&menu_str[size], XSTRING (description)->data, desclen); 
     460        memcpy (&menu_str[size], SDATA (description), desclen); 
    461461      menu_str[size + desclen] = '\0'; 
    462462 
    …… 
    14861486            save_wv->contents = wv; 
    14871487 
    1488           wv->name = (char *) XSTRING (item_name)->data; 
     1488          wv->name = (char *) SDATA (item_name); 
    14891489          if (!NILP (descrip)) 
    1490             wv->key = (char *) XSTRING (descrip)->data; 
     1490            wv->key = (char *) SDATA (descrip); 
    14911491          wv->value = 0; 
    14921492          /* The EMACS_INT cast avoids a warning.  There's no problem 
    …… 
    16501650          if (handle != INVALID_HANDLE_VALUE) 
    16511651            appendmenu_encode (first_handle, MF_POPUP | MF_STRING, 
    1652                                (UINT) handle, XSTRING (string)->data); 
     1652                               (UINT) handle, SDATA (string)); 
    16531653        } 
    16541654 
    …… 
    16981698 
    16991699          nochange = (modifymenu_encode (first_handle, idx, 
    1700                                          MF_STRING, 0, 
    1701                                         XSTRING (string)->data) && nochange); 
     1700                                         MF_STRING, 0, SDATA (string)) 
     1701                      && nochange); 
    17021702          idx++; 
    17031703        } 
    …… 
    19841984    { 
    19851985      InsertMenu (first_handle, 0, MF_BYPOSITION | MF_SEPARATOR, 0, 0); 
    1986       insertmenu_encode (first_handle, 0, 
    1987                          MF_OWNERDRAW, 0, XSTRING (title)->data); 
     1986      insertmenu_encode (first_handle, 0, MF_OWNERDRAW, 0, SDATA (title)); 
    19881987    } 
    19891988 

  • trunk/src/mw32term.c

    r4065 r4074  
    59555955    return fontset_name (fontset); 
    59565956 
    5957   result = mw32_new_font (f, (XSTRING (fontset_ascii (fontset))->data)); 
     5957  result = mw32_new_font (f, (SDATA (fontset_ascii (fontset)))); 
    59585958 
    59595959  if (!STRINGP (result)) 
    …… 
    60776077    for (share = x_display_list, tail = x_display_name_list; share; 
    60786078         share = share->next, tail = XCDR (tail)) 
    6079       if (same_x_server (XSTRING (XCAR (XCAR (tail)))->data, 
    6080                          XSTRING (display_name)->data)) 
     6079      if (same_x_server (SDATA (XCAR (XCAR (tail))), 
     6080                         SDATA (display_name))) 
    60816081        break; 
    60826082    if (share) 
    …… 
    61186118 
    61196119  dpyinfo->mw32_id_name 
    6120     = (char *) xmalloc (STRING_BYTES (XSTRING (Vinvocation_name)) 
    6121                         + STRING_BYTES (XSTRING (Vsystem_name)) 
     6120    = (char *) xmalloc (SBYTES (Vinvocation_name) 
     6121                        + SBYTES (Vsystem_name) 
    61226122                        + 2); 
    61236123  sprintf (dpyinfo->mw32_id_name, "%s@%s", 
    6124            XSTRING (Vinvocation_name)->data, XSTRING (Vsystem_name)->data); 
     6124           SDATA (Vinvocation_name), SDATA (Vsystem_name)); 
    61256125 
    61266126#if 0 
    …… 
    64286428      for (i = 0;i < 256;i++) 
    64296429        { 
    6430           if (lispy_function_keys[i] && 
    6431               (strcmp (lispy_function_keys[i], 
    6432                        XSTRING (key)->data) == 0)) 
     6430          if (lispy_function_keys[i] 
     6431              && (strcmp (lispy_function_keys[i], SDATA (key)) == 0)) 
    64336432            { 
    64346433              virtkey = i; 
    …… 
    64386437 
    64396438      if (virtkey == -1) 
    6440         error ("Can't find the key:%s", XSTRING (key)->data); 
     6439        error ("Can't find the key:%s", SDATA (key)); 
    64416440    } 
    64426441  else 

  • trunk/src/w32.c

    r4058 r4074  
    623623  TCHAR next_char; 
    624624 
    625   if (lstrlen (fp) > MAX_PATH) return; 
     625  if (lstrlen (fp) > MAX_PATH) 
     626    return; 
    626627 
    627628  /* Always lower-case drive letters a-z, even if the filesystem 
    …… 
    640641  if (NILP (Vw32_downcase_file_names)) 
    641642    { 
    642       for (;*fp;fp = n_fp) 
     643      for (; *fp; fp = n_fp) 
    643644        { 
    644645          n_fp = CharNext (fp); 
    …… 
    653654 
    654655      element_start = fp; 
    655       for (pelem = path_element;*fp;) 
     656      for (pelem = path_element; *fp;) 
    656657        { 
    657658          if (IS_DIRECTORY_SEP (*fp)) 
    …… 
    659660              if (element_start && (pelem > path_element)) 
    660661                memcpy (element_start, path_element, 
    661                         (pelem - path_element) * sizeof(TCHAR)); 
     662                        (pelem - path_element) * sizeof (TCHAR)); 
    662663 
    663664              *fp = path_sep; 
    …… 
    669670              if (element_start && (pelem > path_element)) 
    670671                memcpy (element_start, path_element, 
    671                         (pelem - path_element) * sizeof(TCHAR)); 
     672                        (pelem - path_element) * sizeof (TCHAR)); 
    672673 
    673674              pelem = path_element; 
    …… 
    683684 
    684685          n_fp = CharNext (fp); 
    685           while (n_fp > fp) *pelem++ = *fp++; 
     686          while (n_fp > fp) 
     687            *pelem++ = *fp++; 
    686688        } 
    687689    } 
    …… 
    912914      q = p; 
    913915 
    914       for(;;p = CharNext (p)) 
    915         { 
    916           if (!(*p) || IS_DIRECTORY_SEP(*p)) 
     916      for(;; p = CharNext (p)) 
     917        { 
     918          if (!(*p) || IS_DIRECTORY_SEP (*p)) 
    917919            break; 
    918920        } 
    …… 
    29682970      WIN32_FIND_DATA w32fd; 
    29692971 
    2970       len = lstrlen ((LPTSTR)path); 
     2972      len = lstrlen ((LPTSTR) path); 
    29712973      if (len > (MAX_PATH - 3)) 
    29722974        return ret; 
    2973       memcpy (name, path, sizeof(TCHAR) * (len + 1)); 
     2975      memcpy (name, path, sizeof (TCHAR) * (len + 1)); 
    29742976 
    29752977      unixtodos_filename (name); 
    …… 
    29772979      prevname = CharPrev(name, &name[len]); 
    29782980 
    2979       if (IS_DIRECTORY_SEP(*prevname)) 
     2981      if (IS_DIRECTORY_SEP (*prevname)) 
    29802982        { 
    29812983          name[len] = '*'; 
    …… 
    30043006        return ret; 
    30053007 
    3006       do { 
    3007         if (w32fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) 
    3008           num++; 
    3009         if (max > 0) max--; 
    3010         else if (max == 0) break; 
    3011       } while (FindNextFile (hf, &w32fd)); 
     3008      do 
     3009        { 
     3010          if (w32fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) 
     3011            num++; 
     3012          if (max > 0) 
     3013            max--; 
     3014          else if (max == 0) 
     3015            break; 
     3016        } while (FindNextFile (hf, &w32fd)); 
    30123017 
    30133018      FindClose (hf); 
    …… 
    46694674  CHECK_STRING (filename); 
    46704675 
    4671   filetmp = (char *) alloca (STRING_BYTES (XSTRING (filename)) + 1); 
     4676  filetmp = (char *) alloca (SBYTES (filename) + 1); 
    46724677  if (!filetmp) 
    46734678    { 
    46744679      error ("Cannot allocate memory!."); 
    46754680    } 
    4676   memcpy (filetmp, XSTRING (filename)->data, 
    4677           STRING_BYTES (XSTRING (filename)) + 1); 
     4681  memcpy (filetmp, SDATA (filename), SBYTES (filename) + 1); 
    46784682  unixtodos_argument (filetmp, !NILP (ep), !NILP (h2sp), 
    46794683                      !NILP (qp), !NILP (s2isp)); 
    …… 
    47004704                                    Vfile_name_coding_system, Qt); 
    47014705  directory = Ffile_name_directory (fullpath); 
    4702   hff = FindFirstFile (XSTRING (fullpath)->data, &w32FindData); 
    4703   if (hff == INVALID_HANDLE_VALUE){ 
    4704     return Qnil; 
    4705   } 
     4706  hff = FindFirstFile (SDATA (fullpath), &w32FindData); 
     4707  if (hff == INVALID_HANDLE_VALUE) 
     4708    { 
     4709      return Qnil; 
     4710    } 
    47064711  fullpath = 
    47074712    Fexpand_file_name (Fdecode_coding_string 
    …… 
    47294734  fullpath = Fencode_coding_string (Fexpand_file_name (lfn, Qnil), 
    47304735                                    Vfile_name_coding_system, Qt); 
    4731   len = GetShortPathName (XSTRING (fullpath)->data, buf, MAX_PATH); 
     4736  len = GetShortPathName (SDATA (fullpath), buf, MAX_PATH); 
    47324737  if (!len) 
    47334738    return Qnil; 
    …… 
    48024807                                         Vfile_name_coding_system, 
    48034808                                         Qt); 
    4804       p = XSTRING (directory)->data; 
     4809      p = SDATA (directory); 
    48054810      unixtodos_filename (p); 
    48064811    } 
    …… 
    48084813  file = Fencode_coding_string (file, Vfile_name_coding_system, Qt); 
    48094814 
    4810   ret = (UINT) FindExecutable (XSTRING (file)->data, p, buf); 
     4815  ret = (UINT) FindExecutable (SDATA (file), p, buf); 
    48114816 
    48124817  if (ret == ERROR_FILE_NOT_FOUND) 
    4813     error ("specified file:%s is not found", XSTRING (file)->data); 
     4818    error ("specified file:%s is not found", SDATA (file)); 
    48144819  else if (ret == ERROR_PATH_NOT_FOUND) 
    48154820    error ("specified directory is not found", directory);