Problem: Using old C style comments.
Solution: Use // comments where appropriate.
*/
typedef struct
{
- int lead_spaces; /* remaining spaces for a TAB */
- int print_pos; /* virtual column for computing TABs */
- colnr_T column; /* byte column */
- linenr_T file_line; /* line nr in the buffer */
- long_u bytes_printed; /* bytes printed so far */
- int ff; /* seen form feed character */
+ int lead_spaces; // remaining spaces for a TAB
+ int print_pos; // virtual column for computing TABs
+ colnr_T column; // byte column
+ linenr_T file_line; // line nr in the buffer
+ long_u bytes_printed; // bytes printed so far
+ int ff; // seen form feed character
} prt_pos_T;
static char *parse_list_options(char_u *option_str, option_table_T *table, int table_size);
char_u *colonp;
char_u *commap;
char_u *p;
- int idx = 0; /* init for GCC */
+ int idx = 0; // init for GCC
int len;
- /* Save the old values, so that they can be restored in case of an error. */
+ // Save the old values, so that they can be restored in case of an error.
old_opts = ALLOC_MULT(option_table_T, table_size);
if (old_opts == NULL)
return NULL;
break;
}
- table[idx].number = getdigits(&p); /*advances p*/
+ table[idx].number = getdigits(&p); // advances p
}
table[idx].string = p;
if (ret != NULL)
{
- /* Restore old options in case of error */
+ // Restore old options in case of error
for (idx = 0; idx < table_size; ++idx)
table[idx] = old_opts[idx];
}
static long_u
prt_get_term_color(int colorindex)
{
- /* TODO: Should check for xterm with 88 or 256 colors. */
+ // TODO: Should check for xterm with 88 or 256 colors.
if (t_colors > 8)
return cterm_color_16[colorindex % 16];
return cterm_color_8[colorindex % 8];
pattr->fg_color = fg_color;
pattr->bg_color = bg_color;
}
-#endif /* FEAT_SYN_HL */
+#endif // FEAT_SYN_HL
static void
prt_set_fg(long_u fg)
prt_set_font(psettings->number.bold, psettings->number.italic, psettings->number.underline);
mch_print_start_line(TRUE, page_line);
- /* Leave two spaces between the number and the text; depends on
- * PRINT_NUMBER_WIDTH. */
+ // Leave two spaces between the number and the text; depends on
+ // PRINT_NUMBER_WIDTH.
sprintf((char *)tbuf, "%6ld", (long)lnum);
for (i = 0; i < 6; i++)
(void)mch_print_text_out(&tbuf[i], 1);
#ifdef FEAT_SYN_HL
if (psettings->do_syntax)
- /* Set colors for next character. */
+ // Set colors for next character.
current_syn_id = -1;
else
#endif
{
- /* Set colors and font back to normal. */
+ // Set colors and font back to normal.
prt_set_fg(PRCOLOR_BLACK);
prt_set_bg(PRCOLOR_WHITE);
prt_set_font(FALSE, FALSE, FALSE);
char_u *p;
int l;
- /* Also use the space for the line number. */
+ // Also use the space for the line number.
if (prt_use_number())
width += PRINT_NUMBER_WIDTH;
p_header, use_sandbox,
' ', width, NULL, NULL);
- /* Reset line numbers */
+ // Reset line numbers
curwin->w_cursor.lnum = tmp_lnum;
curwin->w_topline = tmp_topline;
curwin->w_botline = tmp_botline;
prt_set_bg(PRCOLOR_WHITE);
prt_set_font(TRUE, FALSE, FALSE);
- /* Use a negative line number to indicate printing in the top margin. */
+ // Use a negative line number to indicate printing in the top margin.
page_line = 0 - prt_header_height();
mch_print_start_line(TRUE, page_line);
for (p = tbuf; *p != NUL; )
if (mch_print_text_out(p, (l = (*mb_ptr2len)(p))))
{
++page_line;
- if (page_line >= 0) /* out of room in header */
+ if (page_line >= 0) // out of room in header
break;
mch_print_start_line(TRUE, page_line);
}
#ifdef FEAT_SYN_HL
if (psettings->do_syntax)
- /* Set colors for next character. */
+ // Set colors for next character.
current_syn_id = -1;
else
#endif
{
- /* Set colors and font back to normal. */
+ // Set colors and font back to normal.
prt_set_fg(PRCOLOR_BLACK);
prt_set_bg(PRCOLOR_WHITE);
prt_set_font(FALSE, FALSE, FALSE);
{
char *errormsg = NULL;
- /* Expand things like "%.ps". */
+ // Expand things like "%.ps".
if (expand_filename(eap, eap->cmdlinep, &errormsg) == FAIL)
{
if (errormsg != NULL)
settings.do_syntax = settings.has_color;
#endif
- /* Set up printing attributes for line numbers */
+ // Set up printing attributes for line numbers
settings.number.fg_color = PRCOLOR_BLACK;
settings.number.bg_color = PRCOLOR_WHITE;
settings.number.bold = FALSE;
goto print_fail_no_begin;
}
- /* Set colors and font to normal. */
+ // Set colors and font to normal.
curr_bg = (long_u)0xffffffffL;
curr_fg = (long_u)0xffffffffL;
curr_italic = MAYBE;
collated_copies < settings.n_collated_copies;
collated_copies++)
{
- prt_pos_T prtpos; /* current print position */
- prt_pos_T page_prtpos; /* print position at page start */
+ prt_pos_T prtpos; // current print position
+ prt_pos_T page_prtpos; // print position at page start
int side;
vim_memset(&page_prtpos, 0, sizeof(prt_pos_T));
if (jobsplit && collated_copies > 0)
{
- /* Splitting jobs: Stop a previous job and start a new one. */
+ // Splitting jobs: Stop a previous job and start a new one.
mch_print_end(&settings);
if (!mch_print_begin(&settings))
goto print_fail_no_begin;
uncollated_copies < settings.n_uncollated_copies;
uncollated_copies++)
{
- /* Set the print position to the start of this page. */
+ // Set the print position to the start of this page.
prtpos = page_prtpos;
/*
* Print one page.
*/
- /* Check for interrupt character every page. */
+ // Check for interrupt character every page.
ui_breakcheck();
if (got_int || settings.user_abort)
goto print_fail;
page_line, &prtpos);
if (prtpos.column == 0)
{
- /* finished a file line */
+ // finished a file line
prtpos.bytes_printed +=
STRLEN(skipwhite(ml_get(prtpos.file_line)));
if (++prtpos.file_line > eap->line2)
- break; /* reached the end */
+ break; // reached the end
}
else if (prtpos.ff)
{
- /* Line had a formfeed in it - start new page but
- * stay on the current line */
+ // Line had a formfeed in it - start new page but
+ // stay on the current line
break;
}
}
if (!mch_print_end_page())
goto print_fail;
if (prtpos.file_line > eap->line2)
- break; /* reached the end */
+ break; // reached the end
}
/*
if (settings.duplex && prtpos.file_line <= eap->line2)
++page_count;
- /* Remember the position where the next page starts. */
+ // Remember the position where the next page starts.
page_prtpos = prtpos;
}
}
else
{
- /* left over from wrap halfway a tab */
+ // left over from wrap halfway a tab
print_pos = ppos->print_pos;
tab_spaces = ppos->lead_spaces;
}
id = syn_get_final_id(id);
else
id = 0;
- /* Get the line again, a multi-line regexp may invalidate it. */
+ // Get the line again, a multi-line regexp may invalidate it.
line = ml_get(ppos->file_line);
if (id != current_syn_id)
if (need_break)
break;
}
- /* Keep the TAB if we didn't finish it. */
+ // Keep the TAB if we didn't finish it.
if (need_break && tab_spaces > 0)
break;
}
#define NUM_ELEMENTS(arr) (sizeof(arr)/sizeof((arr)[0]))
-#define PRT_PS_DEFAULT_DPI (72) /* Default user space resolution */
+#define PRT_PS_DEFAULT_DPI (72) // Default user space resolution
#define PRT_PS_DEFAULT_FONTSIZE (10)
#define PRT_PS_DEFAULT_BUFFER_SIZE (80)
struct prt_mediasize_S
{
char *name;
- float width; /* width and height in points for portrait */
+ float width; // width and height in points for portrait
float height;
};
{"B5", 516.0, 729.0},
{"executive", 522.0, 756.0},
{"folio", 595.0, 935.0},
- {"ledger", 1224.0, 792.0}, /* Yes, it is wider than taller! */
+ {"ledger", 1224.0, 792.0}, // Yes, it is wider than taller!
{"legal", 612.0, 1008.0},
{"quarto", 610.0, 780.0},
{"statement", 396.0, 612.0},
{"tabloid", 792.0, 1224.0}
};
-/* PS font names, must be in Roman, Bold, Italic, Bold-Italic order */
+// PS font names, must be in Roman, Bold, Italic, Bold-Italic order
struct prt_ps_font_S
{
int wx;
#define PRT_PS_FONT_OBLIQUE (2)
#define PRT_PS_FONT_BOLDOBLIQUE (3)
-/* Standard font metrics for Courier family */
+// Standard font metrics for Courier family
static struct prt_ps_font_S prt_ps_courier_font =
{
600,
{"Courier", "Courier-Bold", "Courier-Oblique", "Courier-BoldOblique"}
};
-/* Generic font metrics for multi-byte fonts */
+// Generic font metrics for multi-byte fonts
static struct prt_ps_font_S prt_ps_mb_font =
{
1000,
{NULL, NULL, NULL, NULL}
};
-/* Pointer to current font set being used */
+// Pointer to current font set being used
static struct prt_ps_font_S* prt_ps_font;
-/* Structures to map user named encoding and mapping to PS equivalents for
- * building CID font name */
+// Structures to map user named encoding and mapping to PS equivalents for
+// building CID font name
struct prt_ps_encoding_S
{
char *encoding;
#define CS_KANJITALK6 (0x40)
#define CS_KANJITALK7 (0x80)
-/* Japanese encodings and charsets */
+// Japanese encodings and charsets
static struct prt_ps_encoding_S j_encodings[] =
{
{"iso-2022-jp", NULL, (CS_JIS_C_1978|CS_JIS_X_1983|CS_JIS_X_1990|
#define CS_GBK (0x20)
#define CS_SC_ISO10646 (0x40)
-/* Simplified Chinese encodings and charsets */
+// Simplified Chinese encodings and charsets
static struct prt_ps_encoding_S sc_encodings[] =
{
{"iso-2022", NULL, (CS_GB_2312_80|CS_GBT_12345_90)},
#define CS_DLHKS (0x800)
#define CS_TC_ISO10646 (0x1000)
-/* Traditional Chinese encodings and charsets */
+// Traditional Chinese encodings and charsets
static struct prt_ps_encoding_S tc_encodings[] =
{
{"iso-2022", NULL, (CS_CNS_PLANE_1|CS_CNS_PLANE_2)},
#define CS_KR_X_1992_MS (0x04)
#define CS_KR_ISO10646 (0x08)
-/* Korean encodings and charsets */
+// Korean encodings and charsets
static struct prt_ps_encoding_S k_encodings[] =
{
{"iso-2022-kr", NULL, CS_KR_X_1992},
{"ISO10646", "UniKS", CS_KR_ISO10646}
};
-/* Collections of encodings and charsets for multi-byte printing */
+// Collections of encodings and charsets for multi-byte printing
struct prt_ps_mbfont_S
{
int num_encodings;
char_u version[256];
};
-/* Types of PS resource file currently used */
+// Types of PS resource file currently used
#define PRT_RESOURCE_TYPE_PROCSET (0)
#define PRT_RESOURCE_TYPE_ENCODING (1)
#define PRT_RESOURCE_TYPE_CMAP (2)
-/* The PS prolog file version number has to match - if the prolog file is
- * updated, increment the number in the file and here. Version checking was
- * added as of VIM 6.2.
- * The CID prolog file version number behaves as per PS prolog.
- * Table of VIM and prolog versions:
- *
- * VIM Prolog CIDProlog
- * 6.2 1.3
- * 7.0 1.4 1.0
- */
+// The PS prolog file version number has to match - if the prolog file is
+// updated, increment the number in the file and here. Version checking was
+// added as of VIM 6.2.
+// The CID prolog file version number behaves as per PS prolog.
+// Table of VIM and prolog versions:
+//
+// VIM Prolog CIDProlog
+// 6.2 1.3
+// 7.0 1.4 1.0
#define PRT_PROLOG_VERSION ((char_u *)"1.4")
#define PRT_CID_PROLOG_VERSION ((char_u *)"1.0")
-/* String versions of PS resource types - indexed by constants above so don't
- * re-order!
- */
+// String versions of PS resource types - indexed by constants above so don't
+// re-order!
static char *prt_resource_types[] =
{
"procset",
"cmap"
};
-/* Strings to look for in a PS resource file */
+// Strings to look for in a PS resource file
#define PRT_RESOURCE_HEADER "%!PS-Adobe-"
#define PRT_RESOURCE_RESOURCE "Resource-"
#define PRT_RESOURCE_PROCSET "ProcSet"
#define PRT_RESOURCE_CMAP "CMap"
-/* Data for table based DSC comment recognition, easy to extend if VIM needs to
- * read more comments. */
+// Data for table based DSC comment recognition, easy to extend if VIM needs to
+// read more comments.
#define PRT_DSC_MISC_TYPE (-1)
#define PRT_DSC_TITLE_TYPE (1)
#define PRT_DSC_VERSION_TYPE (2)
int fraction;
prt_real_bits(val, prec, &integer, &fraction);
- /* Emit integer part */
+ // Emit integer part
sprintf((char *)prt_line_buffer, "%d", integer);
prt_write_file(prt_line_buffer);
- /* Only emit fraction if necessary */
+ // Only emit fraction if necessary
if (fraction != 0)
{
- /* Remove any trailing zeros */
+ // Remove any trailing zeros
while ((fraction % 10) == 0)
{
prec--;
fraction /= 10;
}
- /* Emit fraction left padded with zeros */
+ // Emit fraction left padded with zeros
sprintf((char *)prt_line_buffer, ".%0*d", prec, fraction);
prt_write_file(prt_line_buffer);
}
prt_write_file(prt_line_buffer);
}
-/* Convert size from font space to user space at current font scale */
+// Convert size from font space to user space at current font scale
#define PRT_PS_FONT_TO_USER(scale, size) ((size) * ((scale)/1000.0))
static void
{
if (prt_ps_buffer.ga_len > 0)
{
- /* Any background color must be drawn first */
+ // Any background color must be drawn first
if (prt_do_bgcol && (prt_new_bgcol != PRCOLOR_WHITE))
{
int r, g, b;
prt_do_moveto = FALSE;
}
- /* Size of rect of background color on which text is printed */
+ // Size of rect of background color on which text is printed
prt_write_real(prt_text_run, 2);
prt_write_real(prt_line_height, 2);
- /* Lastly add the color of the background */
+ // Lastly add the color of the background
r = ((unsigned)prt_new_bgcol & 0xff0000) >> 16;
g = ((unsigned)prt_new_bgcol & 0xff00) >> 8;
b = prt_new_bgcol & 0xff;
prt_write_real(b / 255.0, 3);
prt_write_string("bg\n");
}
- /* Draw underlines before the text as it makes it slightly easier to
- * find the starting point.
- */
+ // Draw underlines before the text as it makes it slightly easier to
+ // find the starting point.
if (prt_do_underline)
{
if (prt_do_moveto)
prt_do_moveto = FALSE;
}
- /* Underline length of text run */
+ // Underline length of text run
prt_write_real(prt_text_run, 2);
prt_write_string("ul\n");
}
- /* Draw the text
- * Note: we write text out raw - EBCDIC conversion is handled in the
- * PostScript world via the font encoding vector. */
+ // Draw the text
+ // Note: we write text out raw - EBCDIC conversion is handled in the
+ // PostScript world via the font encoding vector.
if (prt_out_mbyte)
prt_write_string("<");
else
prt_write_string(">");
else
prt_write_string(")");
- /* Add a moveto if need be and use the appropriate show procedure */
+ // Add a moveto if need be and use the appropriate show procedure
if (prt_do_moveto)
{
prt_write_real(prt_pos_x_moveto, 2);
prt_write_real(prt_pos_y_moveto, 2);
- /* moveto and a show */
+ // moveto and a show
prt_write_string("ms\n");
prt_do_moveto = FALSE;
}
- else /* Simple show */
+ else // Simple show
prt_write_string("s\n");
ga_clear(&prt_ps_buffer);
return FALSE;
vim_strncpy(resource->name, (char_u *)name, 63);
- /* Look for named resource file in runtimepath */
+ // Look for named resource file in runtimepath
STRCPY(buffer, "print");
add_pathsep(buffer);
vim_strcat(buffer, (char_u *)name, MAXPATHL);
return retval;
}
-/* PS CR and LF characters have platform independent values */
+// PS CR and LF characters have platform independent values
#define PSLF (0x0a)
#define PSCR (0x0d)
-/* Static buffer to read initial comments in a resource file, some can have a
- * couple of KB of comments! */
+// Static buffer to read initial comments in a resource file, some can have a
+// couple of KB of comments!
#define PRT_FILE_BUFFER_LEN (2048)
struct prt_resfile_buffer_S
{
{
int idx;
- /* Move to start of next line and then find end of line */
+ // Move to start of next line and then find end of line
idx = prt_resfile.line_end + 1;
while (idx < prt_resfile.len)
{
static int
prt_resfile_strncmp(int offset, char *string, int len)
{
- /* Force not equal if string is longer than remainder of line */
+ // Force not equal if string is longer than remainder of line
if (len > (prt_resfile.line_end - (prt_resfile.line_start + offset)))
return 1;
return -1;
}
-/* prt_next_dsc() - returns detail on next DSC comment line found. Returns true
- * if a DSC comment is found, else false */
+// prt_next_dsc() - returns detail on next DSC comment line found. Returns true
+// if a DSC comment is found, else false
static int
prt_next_dsc(struct prt_dsc_line_S *p_dsc_line)
{
int comment;
int offset;
- /* Move to start of next line */
+ // Move to start of next line
if (!prt_resfile_next_line())
return FALSE;
- /* DSC comments always start %% */
+ // DSC comments always start %%
if (prt_resfile_strncmp(0, "%%", 2) != 0)
return FALSE;
- /* Find type of DSC comment */
+ // Find type of DSC comment
for (comment = 0; comment < (int)NUM_ELEMENTS(prt_dsc_table); comment++)
if (prt_resfile_strncmp(0, prt_dsc_table[comment].string,
prt_dsc_table[comment].len) == 0)
if (comment != NUM_ELEMENTS(prt_dsc_table))
{
- /* Return type of comment */
+ // Return type of comment
p_dsc_line->type = prt_dsc_table[comment].type;
offset = prt_dsc_table[comment].len;
}
else
{
- /* Unrecognised DSC comment, skip to ws after comment leader */
+ // Unrecognised DSC comment, skip to ws after comment leader
p_dsc_line->type = PRT_DSC_MISC_TYPE;
offset = prt_resfile_skip_nonws(0);
if (offset == -1)
return FALSE;
}
- /* Skip ws to comment value */
+ // Skip ws to comment value
offset = prt_resfile_skip_ws(offset);
if (offset == -1)
return FALSE;
return TRUE;
}
-/* Improved hand crafted parser to get the type, title, and version number of a
+/*
+ * Improved hand crafted parser to get the type, title, and version number of a
* PS resource file so the file details can be added to the DSC header comments.
*/
static int
}
vim_memset(prt_resfile.buffer, NUL, PRT_FILE_BUFFER_LEN);
- /* Parse first line to ensure valid resource file */
+ // Parse first line to ensure valid resource file
prt_resfile.len = (int)fread((char *)prt_resfile.buffer, sizeof(char_u),
PRT_FILE_BUFFER_LEN, fd_resource);
if (ferror(fd_resource))
return FALSE;
}
- /* Skip over any version numbers and following ws */
+ // Skip over any version numbers and following ws
offset += (int)STRLEN(PRT_RESOURCE_HEADER);
offset = prt_resfile_skip_nonws(offset);
if (offset == -1)
}
offset += (int)STRLEN(PRT_RESOURCE_RESOURCE);
- /* Decide type of resource in the file */
+ // Decide type of resource in the file
if (prt_resfile_strncmp(offset, PRT_RESOURCE_PROCSET,
(int)STRLEN(PRT_RESOURCE_PROCSET)) == 0)
resource->type = PRT_RESOURCE_TYPE_PROCSET;
return FALSE;
}
- /* Look for title and version of resource */
+ // Look for title and version of resource
resource->title[0] = '\0';
resource->version[0] = '\0';
seen_title = FALSE;
break;
case PRT_DSC_ENDCOMMENTS_TYPE:
- /* Wont find title or resource after this comment, stop searching */
+ // Wont find title or resource after this comment, stop searching
seen_all = TRUE;
break;
case PRT_DSC_MISC_TYPE:
- /* Not interested in whatever comment this line had */
+ // Not interested in whatever comment this line had
break;
}
}
static int
prt_check_resource(struct prt_ps_resource_S *resource, char_u *version)
{
- /* Version number m.n should match, the revision number does not matter */
+ // Version number m.n should match, the revision number does not matter
if (STRNCMP(resource->version, version, STRLEN(version)))
{
semsg(_("E621: \"%s\" resource file has wrong version"),
return FALSE;
}
- /* Other checks to be added as needed */
+ // Other checks to be added as needed
return TRUE;
}
static void
prt_dsc_text(char *comment, char *text)
{
- /* TODO - should scan 'text' for any chars needing escaping! */
+ // TODO - should scan 'text' for any chars needing escaping!
vim_snprintf((char *)prt_line_buffer, sizeof(prt_line_buffer),
"%%%%%s: (%s)\n", comment, text);
prt_write_file(prt_line_buffer);
static void
prt_dsc_resources(
- char *comment, /* if NULL add to previous */
+ char *comment, // if NULL add to previous
char *type,
char *string)
{
int color,
int num_copies)
{
- /* Only output the comment if we need to.
- * Note: tumble is ignored if we are not duplexing
- */
+ // Only output the comment if we need to.
+ // Note: tumble is ignored if we are not duplexing
if (!(duplex || collate || color || (num_copies > 1)))
return;
if (num_copies > 1)
{
prt_write_string(" numcopies(");
- /* Note: no space wanted so don't use prt_write_int() */
+ // Note: no space wanted so don't use prt_write_int()
sprintf((char *)prt_line_buffer, "%d", num_copies);
prt_write_file(prt_line_buffer);
prt_write_string(")");
{
int i;
- /* Free off all CID font names created, but first clear duplicate
- * pointers to the same string (when the same font is used for more than
- * one style).
- */
+ // Free off all CID font names created, but first clear duplicate
+ // pointers to the same string (when the same font is used for more than
+ // one style).
for (i = PRT_PS_FONT_ROMAN; i <= PRT_PS_FONT_BOLDOBLIQUE; i++)
{
if (prt_ps_mb_font.ps_fontname[i] != NULL)
if (prt_use_number())
{
prt_number_width = PRINT_NUMBER_WIDTH * prt_char_width;
- /* If we are outputting multi-byte characters then line numbers will be
- * printed with half width characters
- */
+ // If we are outputting multi-byte characters then line numbers will be
+ // printed with half width characters
if (prt_out_mbyte)
prt_number_width /= 2;
prt_left_margin += prt_number_width;
prt_ps_font->bbox_min_y)) / 2);
}
- /* Get height for topmost line based on background rect offset. */
+ // Get height for topmost line based on background rect offset.
prt_first_line_height = prt_line_height + prt_bgcol_offset;
- /* Calculate lpp */
+ // Calculate lpp
lpp = (int)((prt_top_margin - prt_bottom_margin) / prt_line_height);
- /* Adjust top margin if there is a header */
+ // Adjust top margin if there is a header
prt_top_margin -= prt_line_height * prt_header_height();
return lpp - prt_header_height();
struct prt_ps_encoding_S *p_mbenc;
*pp_mbenc = NULL;
- /* Look for recognised encoding */
+ // Look for recognised encoding
enc_len = (int)STRLEN(p_encoding);
p_mbenc = p_cmap->encodings;
for (mbenc = 0; mbenc < p_cmap->num_encodings; mbenc++)
int char_len;
struct prt_ps_charset_S *p_mbchar;
- /* Look for recognised character set, using default if one is not given */
+ // Look for recognised character set, using default if one is not given
if (*p_charset == NUL)
p_charset = p_cmap->defcs;
char_len = (int)STRLEN(p_charset);
if (*p_encoding == NUL)
p_encoding = enc_skip(p_enc);
- /* Look for a multi-byte font that matches the encoding and character set.
- * Only look if multi-byte character set is defined, or using multi-byte
- * encoding other than Unicode. This is because a Unicode encoding does not
- * uniquely identify a CJK character set to use. */
+ // Look for a multi-byte font that matches the encoding and character set.
+ // Only look if multi-byte character set is defined, or using multi-byte
+ // encoding other than Unicode. This is because a Unicode encoding does not
+ // uniquely identify a CJK character set to use.
p_mbenc = NULL;
props = enc_canon_props(p_encoding);
if (!(props & ENC_8BIT) && ((*p_pmcs != NUL) || !(props & ENC_UNICODE)))
break;
}
- /* Use first encoding matched if no charset matched */
+ // Use first encoding matched if no charset matched
if (p_mbchar == NULL && p_mbenc_first != NULL)
{
p_mbenc = p_mbenc_first;
prt_out_mbyte = (p_mbenc != NULL);
if (prt_out_mbyte)
{
- /* Build CMap name - will be same for all multi-byte fonts used */
+ // Build CMap name - will be same for all multi-byte fonts used
prt_cmap[0] = NUL;
prt_custom_cmap = (p_mbchar == NULL);
if (!prt_custom_cmap)
{
- /* Check encoding and character set are compatible */
+ // Check encoding and character set are compatible
if ((p_mbenc->needs_charset & p_mbchar->has_charset) == 0)
{
emsg(_("E673: Incompatible multi-byte encoding and character set."));
return FALSE;
}
- /* Add charset name if not empty */
+ // Add charset name if not empty
if (p_mbchar->cmap_charset != NULL)
{
vim_strncpy((char_u *)prt_cmap,
}
else
{
- /* Add custom CMap character set name */
+ // Add custom CMap character set name
if (*p_pmcs == NUL)
{
emsg(_("E674: printmbcharset cannot be empty with multi-byte encoding."));
STRCAT(prt_cmap, "-");
}
- /* CMap name ends with (optional) encoding name and -H for horizontal */
+ // CMap name ends with (optional) encoding name and -H for horizontal
if (p_mbenc->cmap_encoding != NULL && STRLEN(prt_cmap)
+ STRLEN(p_mbenc->cmap_encoding) + 3 < sizeof(prt_cmap))
{
return FALSE;
}
- /* Derive CID font names with fallbacks if not defined */
+ // Derive CID font names with fallbacks if not defined
if (!prt_build_cid_fontname(PRT_PS_FONT_ROMAN,
mbfont_opts[OPT_MBFONT_REGULAR].string,
mbfont_opts[OPT_MBFONT_REGULAR].strlen))
mbfont_opts[OPT_MBFONT_BOLDOBLIQUE].strlen))
return FALSE;
- /* Check if need to use Courier for ASCII code range, and if so pick up
- * the encoding to use */
+ // Check if need to use Courier for ASCII code range, and if so pick up
+ // the encoding to use
prt_use_courier = mbfont_opts[OPT_MBFONT_USECOURIER].present &&
(TOLOWER_ASC(mbfont_opts[OPT_MBFONT_USECOURIER].string[0]) == 'y');
if (prt_use_courier)
{
- /* Use national ASCII variant unless ASCII wanted */
+ // Use national ASCII variant unless ASCII wanted
if (mbfont_opts[OPT_MBFONT_ASCII].present &&
(TOLOWER_ASC(mbfont_opts[OPT_MBFONT_ASCII].string[0]) == 'y'))
prt_ascii_encoding = "ascii";
psettings->chars_per_line = prt_get_cpl();
psettings->lines_per_page = prt_get_lpp();
- /* Catch margin settings that leave no space for output! */
+ // Catch margin settings that leave no space for output!
if (psettings->chars_per_line <= 0 || psettings->lines_per_page <= 0)
return FAIL;
|| TOLOWER_ASC(printer_opts[OPT_PRINT_COLLATE].string[0]) == 'y');
if (prt_collate)
{
- /* TODO: Get number of collated copies wanted. */
+ // TODO: Get number of collated copies wanted.
psettings->n_collated_copies = 1;
}
else
{
- /* TODO: Get number of uncollated copies wanted and update the cached
- * count.
- */
+ // TODO: Get number of uncollated copies wanted and update the cached
+ // count.
prt_num_copies = 1;
}
prt_tumble = TRUE;
}
- /* For now user abort not supported */
+ // For now user abort not supported
psettings->user_abort = 0;
- /* If the user didn't specify a file name, use a temp file. */
+ // If the user didn't specify a file name, use a temp file.
if (psettings->outfile == NULL)
{
prt_ps_file_name = vim_tempname('p', TRUE);
STRCPY(buffer, "Unknown");
prt_dsc_textline("For", buffer);
prt_dsc_textline("Creator", VIM_VERSION_LONG);
- /* Note: to ensure Clean8bit I don't think we can use LC_TIME */
+ // Note: to ensure Clean8bit I don't think we can use LC_TIME
prt_dsc_textline("CreationDate", get_ctime(time(NULL), FALSE));
prt_dsc_textline("DocumentData", "Clean8Bit");
prt_dsc_textline("Orientation", "Portrait");
prt_dsc_atend("Pages");
prt_dsc_textline("PageOrder", "Ascend");
- /* The bbox does not change with orientation - it is always in the default
- * user coordinate system! We have to recalculate right and bottom
- * coordinates based on the font metrics for the bbox to be accurate. */
+ // The bbox does not change with orientation - it is always in the default
+ // user coordinate system! We have to recalculate right and bottom
+ // coordinates based on the font metrics for the bbox to be accurate.
prt_page_margins(prt_mediasize[prt_media].width,
prt_mediasize[prt_media].height,
&left, &right, &top, &bottom);
bbox[0] = (int)left;
if (prt_portrait)
{
- /* In portrait printing the fixed point is the top left corner so we
- * derive the bbox from that point. We have the expected cpl chars
- * across the media and lpp lines down the media.
- */
+ // In portrait printing the fixed point is the top left corner so we
+ // derive the bbox from that point. We have the expected cpl chars
+ // across the media and lpp lines down the media.
bbox[1] = (int)(top - (psettings->lines_per_page + prt_header_height())
* prt_line_height);
bbox[2] = (int)(left + psettings->chars_per_line * prt_char_width
}
else
{
- /* In landscape printing the fixed point is the bottom left corner so we
- * derive the bbox from that point. We have lpp chars across the media
- * and cpl lines up the media.
- */
+ // In landscape printing the fixed point is the bottom left corner so we
+ // derive the bbox from that point. We have lpp chars across the media
+ // and cpl lines up the media.
bbox[1] = (int)bottom;
bbox[2] = (int)(left + ((psettings->lines_per_page
+ prt_header_height()) * prt_line_height) + 0.5);
+ 0.5);
}
prt_dsc_ints("BoundingBox", 4, bbox);
- /* The media width and height does not change with landscape printing! */
+ // The media width and height does not change with landscape printing!
prt_dsc_docmedia(prt_mediasize[prt_media].name,
prt_mediasize[prt_media].width,
prt_mediasize[prt_media].height,
(double)0, NULL, NULL);
- /* Define fonts needed */
+ // Define fonts needed
if (!prt_out_mbyte || prt_use_courier)
prt_dsc_font_resource("DocumentNeededResources", &prt_ps_courier_font);
if (prt_out_mbyte)
prt_dsc_resources(NULL, "cmap", prt_cmap);
}
- /* Search for external resources VIM supplies */
+ // Search for external resources VIM supplies
if (!prt_find_resource("prolog", res_prolog))
{
emsg(_("E456: Can't find PostScript resource file \"prolog.ps\""));
goto theend;
if (prt_out_mbyte)
{
- /* Look for required version of multi-byte printing procset */
+ // Look for required version of multi-byte printing procset
if (!prt_find_resource("cidfont", res_cidfont))
{
emsg(_("E456: Can't find PostScript resource file \"cidfont.ps\""));
goto theend;
}
- /* Find an encoding to use for printing.
- * Check 'printencoding'. If not set or not found, then use 'encoding'. If
- * that cannot be found then default to "latin1".
- * Note: VIM specific encoding header is always skipped.
- */
+ // Find an encoding to use for printing.
+ // Check 'printencoding'. If not set or not found, then use 'encoding'. If
+ // that cannot be found then default to "latin1".
+ // Note: VIM specific encoding header is always skipped.
if (!prt_out_mbyte)
{
p_encoding = enc_skip(p_penc);
if (*p_encoding == NUL
|| !prt_find_resource((char *)p_encoding, res_encoding))
{
- /* 'printencoding' not set or not supported - find alternate */
+ // 'printencoding' not set or not supported - find alternate
int props;
p_encoding = enc_skip(p_enc);
props = enc_canon_props(p_encoding);
if (!(props & ENC_8BIT)
|| !prt_find_resource((char *)p_encoding, res_encoding))
- /* 8-bit 'encoding' is not supported */
- {
- /* Use latin1 as default printing encoding */
+ // 8-bit 'encoding' is not supported
+ {
+ // Use latin1 as default printing encoding
p_encoding = (char_u *)"latin1";
if (!prt_find_resource((char *)p_encoding, res_encoding))
{
}
if (!prt_open_resource(res_encoding))
goto theend;
- /* For the moment there are no checks on encoding resource files to
- * perform */
+ // For the moment there are no checks on encoding resource files to
+ // perform
}
else
{
p_encoding = enc_skip(p_enc);
if (prt_use_courier)
{
- /* Include ASCII range encoding vector */
+ // Include ASCII range encoding vector
if (!prt_find_resource(prt_ascii_encoding, res_encoding))
{
semsg(_("E456: Can't find PostScript resource file \"%s.ps\""),
}
if (!prt_open_resource(res_encoding))
goto theend;
- /* For the moment there are no checks on encoding resource files to
- * perform */
+ // For the moment there are no checks on encoding resource files to
+ // perform
}
}
prt_conv.vc_type = CONV_NONE;
if (!(enc_canon_props(p_enc) & enc_canon_props(p_encoding) & ENC_8BIT)) {
- /* Set up encoding conversion if required */
+ // Set up encoding conversion if required
if (FAIL == convert_setup(&prt_conv, p_enc, p_encoding))
{
semsg(_("E620: Unable to convert to print encoding \"%s\""),
if (prt_out_mbyte && prt_custom_cmap)
{
- /* Find user supplied CMap */
+ // Find user supplied CMap
if (!prt_find_resource(prt_cmap, res_cmap))
{
semsg(_("E456: Can't find PostScript resource file \"%s.ps\""),
goto theend;
}
- /* List resources supplied */
+ // List resources supplied
STRCPY(buffer, res_prolog->title);
STRCAT(buffer, " ");
STRCAT(buffer, res_prolog->version);
*/
prt_dsc_noarg("BeginDefaults");
- /* List font resources most likely common to all pages */
+ // List font resources most likely common to all pages
if (!prt_out_mbyte || prt_use_courier)
prt_dsc_font_resource("PageResources", &prt_ps_courier_font);
if (prt_out_mbyte)
prt_dsc_resources(NULL, "cmap", prt_cmap);
}
- /* Paper will be used for all pages */
+ // Paper will be used for all pages
prt_dsc_textline("PageMedia", prt_mediasize[prt_media].name);
prt_dsc_noarg("EndDefaults");
*/
prt_dsc_noarg("BeginProlog");
- /* Add required procsets - NOTE: order is important! */
+ // Add required procsets - NOTE: order is important!
if (!prt_add_resource(res_prolog))
goto theend;
if (prt_out_mbyte)
{
- /* Add CID font procset, and any user supplied CMap */
+ // Add CID font procset, and any user supplied CMap
if (!prt_add_resource(res_cidfont))
goto theend;
if (prt_custom_cmap && !prt_add_resource(res_cmap))
}
if (!prt_out_mbyte || prt_use_courier)
- /* There will be only one Roman font encoding to be included in the PS
- * file. */
+ // There will be only one Roman font encoding to be included in the PS
+ // file.
if (!prt_add_resource(res_encoding))
goto theend;
*/
prt_dsc_noarg("BeginSetup");
- /* Device setup - page size and number of uncollated copies */
+ // Device setup - page size and number of uncollated copies
prt_write_int((int)prt_mediasize[prt_media].width);
prt_write_int((int)prt_mediasize[prt_media].height);
prt_write_int(0);
prt_write_boolean(prt_collate);
prt_write_string("c\n");
- /* Font resource inclusion and definition */
+ // Font resource inclusion and definition
if (!prt_out_mbyte || prt_use_courier)
{
- /* When using Courier for ASCII range when printing multi-byte, need to
- * pick up ASCII encoding to use with it. */
+ // When using Courier for ASCII range when printing multi-byte, need to
+ // pick up ASCII encoding to use with it.
if (prt_use_courier)
p_encoding = (char_u *)prt_ascii_encoding;
prt_dsc_resources("IncludeResource", "font",
}
if (prt_out_mbyte)
{
- /* Define the CID fonts to be used in the job. Typically CJKV fonts do
- * not have an italic form being a western style, so where no font is
- * defined for these faces VIM falls back to an existing face.
- * Note: if using Courier for the ASCII range then the printout will
- * have bold/italic/bolditalic regardless of the setting of printmbfont.
- */
+ // Define the CID fonts to be used in the job. Typically CJKV fonts do
+ // not have an italic form being a western style, so where no font is
+ // defined for these faces VIM falls back to an existing face.
+ // Note: if using Courier for the ASCII range then the printout will
+ // have bold/italic/bolditalic regardless of the setting of printmbfont.
prt_dsc_resources("IncludeResource", "font",
prt_ps_mb_font.ps_fontname[PRT_PS_FONT_ROMAN]);
if (!prt_custom_cmap)
prt_ps_mb_font.ps_fontname[PRT_PS_FONT_BOLD]);
}
else
- /* Use ROMAN for BOLD */
+ // Use ROMAN for BOLD
prt_dup_cidfont("CF0", "CF1");
if (prt_ps_mb_font.ps_fontname[PRT_PS_FONT_OBLIQUE] != NULL)
prt_ps_mb_font.ps_fontname[PRT_PS_FONT_OBLIQUE]);
}
else
- /* Use ROMAN for OBLIQUE */
+ // Use ROMAN for OBLIQUE
prt_dup_cidfont("CF0", "CF2");
if (prt_ps_mb_font.ps_fontname[PRT_PS_FONT_BOLDOBLIQUE] != NULL)
prt_ps_mb_font.ps_fontname[PRT_PS_FONT_BOLDOBLIQUE]);
}
else
- /* Use BOLD for BOLDOBLIQUE */
+ // Use BOLD for BOLDOBLIQUE
prt_dup_cidfont("CF1", "CF3");
}
- /* Misc constant vars used for underlining and background rects */
+ // Misc constant vars used for underlining and background rects
prt_def_var("UO", PRT_PS_FONT_TO_USER(prt_line_height,
prt_ps_font->uline_offset), 2);
prt_def_var("UW", PRT_PS_FONT_TO_USER(prt_line_height,
prt_dsc_noarg("EndSetup");
- /* Fail if any problems writing out to the PS file */
+ // Fail if any problems writing out to the PS file
retval = !prt_file_error;
theend:
prt_dsc_noarg("EOF");
- /* Write CTRL-D to close serial communication link if used.
- * NOTHING MUST BE WRITTEN AFTER THIS! */
+ // Write CTRL-D to close serial communication link if used.
+ // NOTHING MUST BE WRITTEN AFTER THIS!
prt_write_file((char_u *)IF_EB("\004", "\067"));
if (!prt_file_error && psettings->outfile == NULL
&& !got_int && !psettings->user_abort)
{
- /* Close the file first. */
+ // Close the file first.
if (prt_ps_fd != NULL)
{
fclose(prt_ps_fd);
}
prt_message((char_u *)_("Sending to printer..."));
- /* Not printing to a file: use 'printexpr' to print the file. */
+ // Not printing to a file: use 'printexpr' to print the file.
if (eval_printexpr(prt_ps_file_name, psettings->arguments) == FAIL)
emsg(_("E365: Failed to print PostScript file"));
else
prt_bgcol = PRCOLOR_WHITE;
prt_font = PRT_PS_FONT_ROMAN;
- /* Set up page transformation for landscape printing. */
+ // Set up page transformation for landscape printing.
if (!prt_portrait)
{
prt_write_int(-((int)prt_mediasize[prt_media].width));
prt_dsc_noarg("EndPageSetup");
- /* We have reset the font attributes, force setting them again. */
+ // We have reset the font attributes, force setting them again.
curr_bg = (long_u)0xffffffff;
curr_fg = (long_u)0xffffffff;
curr_bold = MAYBE;
char_width = prt_char_width;
- /* Ideally VIM would create a rearranged CID font to combine a Roman and
- * CJKV font to do what VIM is doing here - use a Roman font for characters
- * in the ASCII range, and the original CID font for everything else.
- * The problem is that GhostScript still (as of 8.13) does not support
- * rearranged fonts even though they have been documented by Adobe for 7
- * years! If they ever do, a lot of this code will disappear.
- */
+ // Ideally VIM would create a rearranged CID font to combine a Roman and
+ // CJKV font to do what VIM is doing here - use a Roman font for characters
+ // in the ASCII range, and the original CID font for everything else.
+ // The problem is that GhostScript still (as of 8.13) does not support
+ // rearranged fonts even though they have been documented by Adobe for 7
+ // years! If they ever do, a lot of this code will disappear.
if (prt_use_courier)
{
in_ascii = (len == 1 && *p < 0x80);
{
if (!in_ascii)
{
- /* No longer in ASCII range - need to switch font */
+ // No longer in ASCII range - need to switch font
prt_in_ascii = FALSE;
prt_need_font = TRUE;
prt_attribute_change = TRUE;
}
else if (in_ascii)
{
- /* Now in ASCII range - need to switch font */
+ // Now in ASCII range - need to switch font
prt_in_ascii = TRUE;
prt_need_font = TRUE;
prt_attribute_change = TRUE;
}
}
- /* Output any required changes to the graphics state, after flushing any
- * text buffered so far.
- */
+ // Output any required changes to the graphics state, after flushing any
+ // text buffered so far.
if (prt_attribute_change)
{
prt_flush_buffer();
- /* Reset count of number of chars that will be printed */
+ // Reset count of number of chars that will be printed
prt_text_run = 0;
if (prt_need_moveto)
if (prt_do_conv)
{
- /* Convert from multi-byte to 8-bit encoding */
+ // Convert from multi-byte to 8-bit encoding
tofree = p = string_convert(&prt_conv, p, &len);
if (p == NULL)
{
if (prt_out_mbyte)
{
- /* Multi-byte character strings are represented more efficiently as hex
- * strings when outputting clean 8 bit PS.
- */
+ // Multi-byte character strings are represented more efficiently as hex
+ // strings when outputting clean 8 bit PS.
while (len-- > 0)
{
ch = prt_hexchar[(unsigned)(*p) >> 4];
}
else
{
- /* Add next character to buffer of characters to output.
- * Note: One printed character may require several PS characters to
- * represent it, but we only count them as one printed character.
- */
+ // Add next character to buffer of characters to output.
+ // Note: One printed character may require several PS characters to
+ // represent it, but we only count them as one printed character.
ch = *p;
if (ch < 32 || ch == '(' || ch == ')' || ch == '\\')
{
- /* Convert non-printing characters to either their escape or octal
- * sequence, ensures PS sent over a serial line does not interfere
- * with the comms protocol. Note: For EBCDIC we need to write out
- * the escape sequences as ASCII codes!
- * Note 2: Char codes < 32 are identical in EBCDIC and ASCII AFAIK!
- */
+ // Convert non-printing characters to either their escape or octal
+ // sequence, ensures PS sent over a serial line does not interfere
+ // with the comms protocol. Note: For EBCDIC we need to write out
+ // the escape sequences as ASCII codes!
+ // Note 2: Char codes < 32 are identical in EBCDIC and ASCII AFAIK!
ga_append(&prt_ps_buffer, IF_EB('\\', 0134));
switch (ch)
{
ga_append(&prt_ps_buffer, ch);
}
- /* Need to free any translated characters */
+ // Need to free any translated characters
vim_free(tofree);
prt_text_run += char_width;
prt_pos_x += char_width;
- /* The downside of fp - use relative error on right margin check */
+ // The downside of fp - use relative error on right margin check
next_pos = prt_pos_x + prt_char_width;
need_break = (next_pos > prt_right_margin) &&
((next_pos - prt_right_margin) > (prt_right_margin*1e-5));
}
}
-# endif /*FEAT_POSTSCRIPT*/
-#endif /*FEAT_PRINTER*/
+# endif //FEAT_POSTSCRIPT
+#endif //FEAT_PRINTER
#include "vim.h"
#if 0
-# define HT_DEBUG /* extra checks for table consistency and statistics */
+# define HT_DEBUG // extra checks for table consistency and statistics
-static long hash_count_lookup = 0; /* count number of hashtab lookups */
-static long hash_count_perturb = 0; /* count number of "misses" */
+static long hash_count_lookup = 0; // count number of hashtab lookups
+static long hash_count_perturb = 0; // count number of "misses"
#endif
-/* Magic value for algorithm that walks through the array. */
+// Magic value for algorithm that walks through the array.
#define PERTURB_SHIFT 5
static int hash_may_resize(hashtab_T *ht, int minitems);
-#if 0 /* currently not used */
+#if 0 // currently not used
/*
* Create an empty hash table.
* Returns NULL when out of memory.
void
hash_init(hashtab_T *ht)
{
- /* This zeroes all "ht_" entries and all the "hi_key" in "ht_smallarray". */
+ // This zeroes all "ht_" entries and all the "hi_key" in "ht_smallarray".
vim_memset(ht, 0, sizeof(hashtab_T));
ht->ht_array = ht->ht_smallarray;
ht->ht_mask = HT_INIT_SIZE - 1;
for (perturb = hash; ; perturb >>= PERTURB_SHIFT)
{
#ifdef HT_DEBUG
- ++hash_count_perturb; /* count a "miss" for hashtab lookup */
+ ++hash_count_perturb; // count a "miss" for hashtab lookup
#endif
idx = (unsigned)((idx << 2U) + idx + perturb + 1U);
hi = &ht->ht_array[idx & ht->ht_mask];
char_u *key,
hash_T hash)
{
- /* If resizing failed before and it fails again we can't add an item. */
+ // If resizing failed before and it fails again we can't add an item.
if (ht->ht_error && hash_may_resize(ht, 0) == FAIL)
return FAIL;
hi->hi_key = key;
hi->hi_hash = hash;
- /* When the space gets low may resize the array. */
+ // When the space gets low may resize the array.
return hash_may_resize(ht, 0);
}
-#if 0 /* not used */
+#if 0 // not used
/*
* Overwrite hashtable item "hi" with "key". "hi" must point to the item that
* is to be overwritten. Thus the number of items in the hashtable doesn't
static int
hash_may_resize(
hashtab_T *ht,
- int minitems) /* minimal number of items */
+ int minitems) // minimal number of items
{
hashitem_T temparray[HT_INIT_SIZE];
hashitem_T *oldarray, *newarray;
long_u newmask;
hash_T perturb;
- /* Don't resize a locked table. */
+ // Don't resize a locked table.
if (ht->ht_locked > 0)
return OK;
if (minitems == 0)
{
- /* Return quickly for small tables with at least two NULL items. NULL
- * items are required for the lookup to decide a key isn't there. */
+ // Return quickly for small tables with at least two NULL items. NULL
+ // items are required for the lookup to decide a key isn't there.
if (ht->ht_filled < HT_INIT_SIZE - 1
&& ht->ht_array == ht->ht_smallarray)
return OK;
return OK;
if (ht->ht_used > 1000)
- minsize = ht->ht_used * 2; /* it's big, don't make too much room */
+ minsize = ht->ht_used * 2; // it's big, don't make too much room
else
- minsize = ht->ht_used * 4; /* make plenty of room */
+ minsize = ht->ht_used * 4; // make plenty of room
}
else
{
newsize = HT_INIT_SIZE;
while (newsize < minsize)
{
- newsize <<= 1; /* make sure it's always a power of 2 */
+ newsize <<= 1; // make sure it's always a power of 2
if (newsize == 0)
- return FAIL; /* overflow */
+ return FAIL; // overflow
}
if (newsize == HT_INIT_SIZE)
{
- /* Use the small array inside the hashdict structure. */
+ // Use the small array inside the hashdict structure.
newarray = ht->ht_smallarray;
if (ht->ht_array == newarray)
{
- /* Moving from ht_smallarray to ht_smallarray! Happens when there
- * are many removed items. Copy the items to be able to clean up
- * removed items. */
+ // Moving from ht_smallarray to ht_smallarray! Happens when there
+ // are many removed items. Copy the items to be able to clean up
+ // removed items.
mch_memmove(temparray, newarray, sizeof(temparray));
oldarray = temparray;
}
}
else
{
- /* Allocate an array. */
+ // Allocate an array.
newarray = ALLOC_MULT(hashitem_T, newsize);
if (newarray == NULL)
{
- /* Out of memory. When there are NULL items still return OK.
- * Otherwise set ht_error, because lookup may result in a hang if
- * we add another item. */
+ // Out of memory. When there are NULL items still return OK.
+ // Otherwise set ht_error, because lookup may result in a hang if
+ // we add another item.
if (ht->ht_filled < ht->ht_mask)
return OK;
ht->ht_error = TRUE;
return (hash_T)0;
p = key + 1;
- /* A simplistic algorithm that appears to do very well.
- * Suggested by George Reilly. */
+ // A simplistic algorithm that appears to do very well.
+ // Suggested by George Reilly.
while (*p != NUL)
hash = hash * 101 + *p++;
static csinfo_T * csinfo = NULL;
-static int csinfo_size = 0; /* number of items allocated in
- csinfo[] */
+static int csinfo_size = 0; // number of items allocated in
+ // csinfo[]
-static int eap_arg_len; /* length of eap->arg, set in
- cs_lookup_cmd() */
+static int eap_arg_len; // length of eap->arg, set in
+ // cs_lookup_cmd()
static cscmd_T cs_cmds[] =
{
{ "add", cs_add,
static enum
{
- EXP_CSCOPE_SUBCMD, /* expand ":cscope" sub-commands */
- EXP_SCSCOPE_SUBCMD, /* expand ":scscope" sub-commands */
- EXP_CSCOPE_FIND, /* expand ":cscope find" arguments */
- EXP_CSCOPE_KILL /* expand ":cscope kill" arguments */
+ EXP_CSCOPE_SUBCMD, // expand ":cscope" sub-commands
+ EXP_SCSCOPE_SUBCMD, // expand ":scscope" sub-commands
+ EXP_CSCOPE_FIND, // expand ":cscope find" arguments
+ EXP_CSCOPE_KILL // expand ":cscope kill" arguments
} expand_what;
/*
switch (expand_what)
{
case EXP_CSCOPE_SUBCMD:
- /* Complete with sub-commands of ":cscope":
- * add, find, help, kill, reset, show */
+ // Complete with sub-commands of ":cscope":
+ // add, find, help, kill, reset, show
return (char_u *)cs_cmds[idx].name;
case EXP_SCSCOPE_SUBCMD:
- /* Complete with sub-commands of ":scscope": same sub-commands as
- * ":cscope" but skip commands which don't support split windows */
+ // Complete with sub-commands of ":scscope": same sub-commands as
+ // ":cscope" but skip commands which don't support split windows
for (i = 0, current_idx = 0; cs_cmds[i].name != NULL; i++)
if (cs_cmds[i].cansplit)
if (current_idx++ == idx)
"a", "c", "d", "e", "f", "g", "i", "s", "t", NULL
};
- /* Complete with query type of ":cscope find {query_type}".
- * {query_type} can be letters (c, d, ... a) or numbers (0, 1,
- * ..., 9) but only complete with letters, since numbers are
- * redundant. */
+ // Complete with query type of ":cscope find {query_type}".
+ // {query_type} can be letters (c, d, ... a) or numbers (0, 1,
+ // ..., 9) but only complete with letters, since numbers are
+ // redundant.
return (char_u *)query_type[idx];
}
case EXP_CSCOPE_KILL:
{
static char connection[5];
- /* ":cscope kill" accepts connection numbers or partial names of
- * the pathname of the cscope database as argument. Only complete
- * with connection numbers. -1 can also be used to kill all
- * connections. */
+ // ":cscope kill" accepts connection numbers or partial names of
+ // the pathname of the cscope database as argument. Only complete
+ // with connection numbers. -1 can also be used to kill all
+ // connections.
for (i = 0, current_idx = 0; i < csinfo_size; i++)
{
if (csinfo[i].fname == NULL)
{
char_u *p;
- /* Default: expand subcommands */
+ // Default: expand subcommands
xp->xp_context = EXPAND_CSCOPE;
xp->xp_pattern = arg;
expand_what = (cmdidx == CMD_scscope)
? EXP_SCSCOPE_SUBCMD : EXP_CSCOPE_SUBCMD;
- /* (part of) subcommand already typed */
+ // (part of) subcommand already typed
if (*arg != NUL)
{
p = skiptowhite(arg);
- if (*p != NUL) /* past first word */
+ if (*p != NUL) // past first word
{
xp->xp_pattern = skipwhite(p);
if (*skiptowhite(xp->xp_pattern) != NUL)
static void
do_cscope_general(
exarg_T *eap,
- int make_split UNUSED) /* whether to split window */
+ int make_split UNUSED) // whether to split window
{
cscmd_T *cmdp;
vim_strncpy(buf, (char_u *)p, size - 1);
return FALSE;
-} /* cs_fgets */
+}
/*
*/
static int
cs_add_common(
- char *arg1, /* filename - may contain environment variables */
- char *arg2, /* prepend path - may contain environment variables */
+ char *arg1, // filename - may contain environment variables
+ char *arg2, // prepend path - may contain environment variables
char *flags)
{
stat_T statbuf;
int usedlen = 0;
char_u *fbuf = NULL;
- /* get the filename (arg1), expand it, and try to stat it */
+ // get the filename (arg1), expand it, and try to stat it
if ((fname = alloc(MAXPATHL + 1)) == NULL)
goto add_err;
goto add_err;
}
- /* get the prepend path (arg2), expand it, and try to stat it */
+ // get the prepend path (arg2), expand it, and try to stat it
if (arg2 != NULL)
{
stat_T statbuf2;
goto staterr;
}
- /* if filename is a directory, append the cscope database name to it */
+ // if filename is a directory, append the cscope database name to it
if (S_ISDIR(statbuf.st_mode))
{
fname2 = alloc(strlen(CSCOPE_DBFILE) + strlen(fname) + 2);
vim_free(fname);
vim_free(ppath);
return CSCOPE_FAILURE;
-} /* cs_add_common */
+}
static int
cs_check_for_connections(void)
{
return (cs_cnt_connections() > 0);
-} /* cs_check_for_connections */
+}
static int
cs_check_for_tags(void)
{
return (p_tags[0] != NUL && curbuf->b_p_tags != NULL);
-} /* cs_check_for_tags */
+}
/*
cnt++;
}
return cnt;
-} /* cs_cnt_connections */
+}
static void
cs_reading_emsg(
- int idx) /* connection index */
+ int idx) // connection index
{
semsg(_("E262: error reading cscope connection %d"), idx);
}
vim_free(buf);
return nlines;
-} /* cs_cnt_matches */
+}
/*
return NULL;
}
- /* Skip white space before the patter, except for text and pattern search,
- * they may want to use the leading white space. */
+ // Skip white space before the patter, except for text and pattern search,
+ // they may want to use the leading white space.
pat = pattern;
if (search != 4 && search != 6)
while VIM_ISWHITE(*pat)
(void)sprintf(cmd, "%d%s", search, pat);
return cmd;
-} /* cs_create_cmd */
+}
/*
case -1:
(void)emsg(_("E622: Could not fork for cscope"));
goto err_closing;
- case 0: /* child: run cscope. */
+ case 0: // child: run cscope.
if (dup2(to_cs[0], STDIN_FILENO) == -1)
PERROR("cs_create_connection 1");
if (dup2(from_cs[1], STDOUT_FILENO) == -1)
if (dup2(from_cs[1], STDERR_FILENO) == -1)
PERROR("cs_create_connection 3");
- /* close unused */
+ // close unused
(void)close(to_cs[1]);
(void)close(from_cs[0]);
#else
- /* MSWIN */
- /* Create pipes to communicate with cscope */
+ // MSWIN
+ // Create pipes to communicate with cscope
sa.nLength = sizeof(SECURITY_ATTRIBUTES);
sa.bInheritHandle = TRUE;
sa.lpSecurityDescriptor = NULL;
return CSCOPE_FAILURE;
}
#endif
- /* expand the cscope exec for env var's */
+ // expand the cscope exec for env var's
if ((prog = alloc(MAXPATHL + 1)) == NULL)
{
#ifdef UNIX
return CSCOPE_FAILURE;
#else
- /* MSWIN */
+ // MSWIN
goto err_closing;
#endif
}
expand_env((char_u *)p_csprg, (char_u *)prog, MAXPATHL);
- /* alloc space to hold the cscope command */
+ // alloc space to hold the cscope command
len = (int)(strlen(prog) + strlen(csinfo[i].fname) + 32);
if (csinfo[i].ppath)
{
- /* expand the prepend path for env var's */
+ // expand the prepend path for env var's
if ((ppath = alloc(MAXPATHL + 1)) == NULL)
{
vim_free(prog);
#ifdef UNIX
return CSCOPE_FAILURE;
#else
- /* MSWIN */
+ // MSWIN
goto err_closing;
#endif
}
#ifdef UNIX
return CSCOPE_FAILURE;
#else
- /* MSWIN */
+ // MSWIN
goto err_closing;
#endif
}
- /* run the cscope command; is there execl for non-unix systems? */
+ // run the cscope command; is there execl for non-unix systems?
#if defined(UNIX)
(void)sprintf(cmd, "exec %s -dl -f %s", prog, csinfo[i].fname);
#else
- /* MSWIN */
+ // MSWIN
(void)sprintf(cmd, "%s -dl -f %s", prog, csinfo[i].fname);
#endif
if (csinfo[i].ppath != NULL)
(void)strcat(cmd, csinfo[i].flags);
}
# ifdef UNIX
- /* on Win32 we still need prog */
+ // on Win32 we still need prog
vim_free(prog);
# endif
vim_free(ppath);
#if defined(UNIX)
# if defined(HAVE_SETSID) || defined(HAVE_SETPGID)
- /* Change our process group to avoid cscope receiving SIGWINCH. */
+ // Change our process group to avoid cscope receiving SIGWINCH.
# if defined(HAVE_SETSID)
(void)setsid();
# else
PERROR(_("cs_create_connection exec failed"));
exit(127);
- /* NOTREACHED */
- default: /* parent. */
+ // NOTREACHED
+ default: // parent.
/*
* Save the file descriptors for later duplication, and
* reopen as streams.
if ((csinfo[i].fr_fp = fdopen(from_cs[0], "r")) == NULL)
PERROR(_("cs_create_connection: fdopen for fr_fp failed"));
- /* close unused */
+ // close unused
(void)close(to_cs[0]);
(void)close(from_cs[1]);
}
#else
- /* MSWIN */
- /* Create a new process to run cscope and use pipes to talk with it */
+ // MSWIN
+ // Create a new process to run cscope and use pipes to talk with it
GetStartupInfo(&si);
si.dwFlags = STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW;
- si.wShowWindow = SW_HIDE; /* Hide child application window */
+ si.wShowWindow = SW_HIDE; // Hide child application window
si.hStdOutput = stdout_wr;
si.hStdError = stdout_wr;
si.hStdInput = stdin_rd;
(void)emsg(_("E623: Could not spawn cscope process"));
goto err_closing;
}
- /* else */
+ // else
csinfo[i].pid = pi.dwProcessId;
csinfo[i].hProc = pi.hProcess;
CloseHandle(pi.hThread);
- /* TODO - tidy up after failure to create files on pipe handles. */
+ // TODO - tidy up after failure to create files on pipe handles.
if (((fd = _open_osfhandle((OPEN_OH_ARGTYPE)stdin_wr,
_O_TEXT|_O_APPEND)) < 0)
|| ((csinfo[i].to_fp = _fdopen(fd, "w")) == NULL))
|| ((csinfo[i].fr_fp = _fdopen(fd, "r")) == NULL))
PERROR(_("cs_create_connection: fdopen for fr_fp failed"));
- /* Close handles for file descriptors inherited by the cscope process */
+ // Close handles for file descriptors inherited by the cscope process
CloseHandle(stdin_rd);
CloseHandle(stdout_wr);
-#endif /* !UNIX */
+#endif // !UNIX
return CSCOPE_SUCCESS;
-} /* cs_create_connection */
+}
/*
return cs_find_common(opt, pat, eap->forceit, TRUE,
eap->cmdidx == CMD_lcscope, *eap->cmdlinep);
-} /* cs_find */
+}
/*
char cmdletter;
char *qfpos;
- /* get cmd letter */
+ // get cmd letter
switch (opt[0])
{
case '0' :
if (qfpos != NULL)
{
qfpos++;
- /* next symbol must be + or - */
+ // next symbol must be + or -
if (strchr(CSQF_FLAGS, *qfpos) == NULL)
{
char *nf = _("E469: invalid cscopequickfix flag %c for %c");
char *buf = alloc(strlen(nf));
- /* strlen will be enough because we use chars */
+ // strlen will be enough because we use chars
if (buf != NULL)
{
sprintf(buf, nf, *qfpos, *(qfpos-1));
}
#endif
- /* create the actual command to send to cscope */
+ // create the actual command to send to cscope
cmd = cs_create_cmd(opt, pat);
if (cmd == NULL)
return FALSE;
return FALSE;
}
- /* Send query to all open connections, then count the total number
- * of matches so we can alloc all in one swell foop. */
+ // Send query to all open connections, then count the total number
+ // of matches so we can alloc all in one swell foop.
for (i = 0; i < csinfo_size; i++)
nummatches[i] = 0;
totmatches = 0;
if (csinfo[i].fname == NULL || csinfo[i].to_fp == NULL)
continue;
- /* send cmd to cscope */
+ // send cmd to cscope
(void)fprintf(csinfo[i].to_fp, "%s\n", cmd);
(void)fflush(csinfo[i].to_fp);
#ifdef FEAT_QUICKFIX
if (qfpos != NULL && *qfpos != '0' && totmatches > 0)
{
- /* fill error list */
+ // fill error list
FILE *f;
char_u *tmp = vim_tempname('c', TRUE);
qf_info_T *qi = NULL;
{
cs_file_results(f, nummatches);
fclose(f);
- if (use_ll) /* Use location list */
+ if (use_ll) // Use location list
wp = curwin;
- /* '-' starts a new error list */
+ // '-' starts a new error list
if (qf_init(wp, tmp, (char_u *)"%f%*\\t%l%*\\t%m",
*qfpos == '-', cmdline, NULL) > 0)
{
return TRUE;
}
else
-#endif /* FEAT_QUICKFIX */
+#endif // FEAT_QUICKFIX
{
char **matches = NULL, **contexts = NULL;
int matched = 0;
- /* read output */
+ // read output
cs_fill_results((char *)pat, totmatches, nummatches, &matches,
&contexts, &matched);
vim_free(nummatches);
return do_tag((char_u *)pat, DT_CSCOPE, 0, forceit, verbose);
}
-} /* cs_find_common */
+}
/*
* Print help.
char *help = _(cmdp->help);
int space_cnt = 30 - vim_strsize((char_u *)help);
- /* Use %*s rather than %30s to ensure proper alignment in utf-8 */
+ // Use %*s rather than %30s to ensure proper alignment in utf-8
if (space_cnt < 0)
space_cnt = 0;
(void)smsg(_("%-5s: %s%*s (Usage: %s)"),
wait_return(TRUE);
return 0;
-} /* cs_help */
+}
static void
NULL, GetLastError(), 0, (LPSTR)&msg, 0, NULL);
if (msg != NULL)
{
- /* remove trailing \r\n */
+ // remove trailing \r\n
char *pcrlf = strstr(msg, "\r\n");
if (pcrlf != NULL)
*pcrlf = '\0';
switch (win32_fileinfo((char_u *)fname, &bhfi))
{
- case FILEINFO_ENC_FAIL: /* enc_to_utf16() failed */
- case FILEINFO_READ_FAIL: /* CreateFile() failed */
+ case FILEINFO_ENC_FAIL: // enc_to_utf16() failed
+ case FILEINFO_READ_FAIL: // CreateFile() failed
if (p_csverbose)
{
char *cant_msg = _("E625: cannot open cscope database: %s");
LocalFree(winmsg);
}
else
- /* subst filename if can't get error text */
+ // subst filename if can't get error text
(void)semsg(cant_msg, fname);
}
return -1;
- case FILEINFO_INFO_FAIL: /* GetFileInformationByHandle() failed */
+ case FILEINFO_INFO_FAIL: // GetFileInformationByHandle() failed
if (p_csverbose)
(void)emsg(_("E626: cannot get cscope database information"));
return -1;
}
#endif
- i = -1; /* can be set to the index of an empty item in csinfo */
+ i = -1; // can be set to the index of an empty item in csinfo
for (j = 0; j < csinfo_size; j++)
{
if (csinfo[j].fname != NULL
}
if (csinfo[j].fname == NULL && i == -1)
- i = j; /* remember first empty entry */
+ i = j; // remember first empty entry
}
if (i == -1)
i = csinfo_size;
if (csinfo_size == 0)
{
- /* First time allocation: allocate only 1 connection. It should
- * be enough for most users. If more is needed, csinfo will be
- * reallocated. */
+ // First time allocation: allocate only 1 connection. It should
+ // be enough for most users. If more is needed, csinfo will be
+ // reallocated.
csinfo_size = 1;
csinfo = ALLOC_CLEAR_ONE(csinfo_T);
}
{
csinfo_T *t_csinfo = csinfo;
- /* Reallocate space for more connections. */
+ // Reallocate space for more connections.
csinfo_size *= 2;
csinfo = vim_realloc(csinfo, sizeof(csinfo_T)*csinfo_size);
if (csinfo == NULL)
csinfo[i].nIndexHigh = bhfi.nFileIndexHigh;
#endif
return i;
-} /* cs_insert_filelist */
+}
/*
if (eap->arg == NULL)
return NULL;
- /* Store length of eap->arg before it gets modified by strtok(). */
+ // Store length of eap->arg before it gets modified by strtok().
eap_arg_len = (int)STRLEN(eap->arg);
if ((stok = strtok((char *)(eap->arg), (const char *)" ")) == NULL)
return (cmdp);
}
return NULL;
-} /* cs_lookup_cmd */
+}
/*
return CSCOPE_FAILURE;
}
- /* only single digit positive and negative integers are allowed */
+ // only single digit positive and negative integers are allowed
if ((strlen(stok) < 2 && VIM_ISDIGIT((int)(stok[0])))
|| (strlen(stok) < 3 && stok[0] == '-'
&& VIM_ISDIGIT((int)(stok[1]))))
i = atoi(stok);
else
{
- /* It must be part of a name. We will try to find a match
- * within all the names in the csinfo data structure
- */
+ // It must be part of a name. We will try to find a match
+ // within all the names in the csinfo data structure
for (i = 0; i < csinfo_size; i++)
{
if (csinfo[i].fname != NULL && strstr(csinfo[i].fname, stok))
}
return 0;
-} /* cs_kill */
+}
/*
*/
static void
cs_kill_execute(
- int i, /* cscope table index */
- char *cname) /* cscope database name */
+ int i, // cscope table index
+ char *cname) // cscope database name
{
if (p_csverbose)
{
char *search,
char *tagstr)
{
- /* vim style is ctags:
- *
- * <tagstr>\t<filename>\t<linenum_or_search>"\t<extra>
- *
- * but as mentioned above, we'll always use the line number and
- * put the search pattern (if one exists) as "extra"
- *
- * buf is used as part of vim's method of handling tags, and
- * (i think) vim frees it when you pop your tags and get replaced
- * by new ones on the tag stack.
- */
+ // vim style is ctags:
+ //
+ // <tagstr>\t<filename>\t<linenum_or_search>"\t<extra>
+ //
+ // but as mentioned above, we'll always use the line number and
+ // put the search pattern (if one exists) as "extra"
+ //
+ // buf is used as part of vim's method of handling tags, and
+ // (i think) vim frees it when you pop your tags and get replaced
+ // by new ones on the tag stack.
char *buf;
int amt;
}
return buf;
-} /* cs_make_vim_style_matches */
+}
/*
case Print:
cs_print_tags_priv(mp, cp, cnt);
break;
- default: /* should not reach here */
+ default: // should not reach here
iemsg(_("E570: fatal error in cs_manage_matches"));
return NULL;
}
return p;
-} /* cs_manage_matches */
+}
/*
return NULL;
}
- /* If the line's too long for the buffer, discard it. */
+ // If the line's too long for the buffer, discard it.
if ((p = strchr(buf, '\n')) == NULL)
{
while ((ch = getc(csinfo[cnumber].fr_fp)) != EOF && ch != '\n')
return NULL;
if ((*linenumber = strtok(NULL, (const char *)" ")) == NULL)
return NULL;
- *search = *linenumber + strlen(*linenumber) + 1; /* +1 to skip \0 */
+ *search = *linenumber + strlen(*linenumber) + 1; // +1 to skip \0
- /* --- nvi ---
- * If the file is older than the cscope database, that is,
- * the database was built since the file was last modified,
- * or there wasn't a search string, use the line number.
- */
+ // --- nvi ---
+ // If the file is older than the cscope database, that is,
+ // the database was built since the file was last modified,
+ // or there wasn't a search string, use the line number.
if (strcmp(*search, "<unknown>") == 0)
*search = NULL;
vim_free(context);
vim_free(fullname);
- } /* for all matches */
+ } // for all matches
(void)cs_read_prompt(i);
- } /* for all cscope connections */
+ } // for all cscope connections
vim_free(buf);
}
#endif
if (strcmp(cntx, "<global>") == 0)
cntxts[totsofar] = NULL;
else
- /* note: if vim_strsave returns NULL, then the context
- * will be "<global>", which is misleading.
- */
+ // note: if vim_strsave returns NULL, then the context
+ // will be "<global>", which is misleading.
cntxts[totsofar] = (char *)vim_strsave((char_u *)cntx);
if (matches[totsofar] != NULL)
totsofar++;
- } /* for all matches */
+ } // for all matches
(void)cs_read_prompt(i);
- } /* for all cscope connections */
+ } // for all cscope connections
parse_out:
if (totsofar == 0)
{
- /* No matches, free the arrays and return NULL in "*matches_p". */
+ // No matches, free the arrays and return NULL in "*matches_p".
VIM_CLEAR(matches);
VIM_CLEAR(cntxts);
}
*cntxts_p = cntxts;
vim_free(buf);
-} /* cs_fill_results */
+}
-/* get the requested path components */
+/*
+ * get the requested path components
+ */
static char *
cs_pathcomponents(char *path)
{
{
char *buf = NULL;
char *t_buf;
- int bufsize = 0; /* Track available bufsize */
+ int bufsize = 0; // Track available bufsize
int newsize = 0;
char *ptag;
char *fname, *lno, *extra, *tbuf;
vim_free(tbuf);
- msg_puts_attr(_("\n # line"), HL_ATTR(HLF_T)); /* strlen is 7 */
+ msg_puts_attr(_("\n # line"), HL_ATTR(HLF_T)); // strlen is 7
msg_advance(msg_col + 2);
msg_puts_attr(_("filename / context / line\n"), HL_ATTR(HLF_T));
{
idx = i;
- /* if we really wanted to, we could avoid this malloc and strcpy
- * by parsing matches[i] on the fly and placing stuff into buf
- * directly, but that's too much of a hassle
- */
+ // if we really wanted to, we could avoid this malloc and strcpy
+ // by parsing matches[i] on the fly and placing stuff into buf
+ // directly, but that's too much of a hassle
if ((tbuf = alloc(strlen(matches[idx]) + 1)) == NULL)
continue;
(void)strcpy(tbuf, matches[idx]);
}
extra = strtok(NULL, (const char *)"\t");
- lno[strlen(lno)-2] = '\0'; /* ignore ;" at the end */
+ lno[strlen(lno)-2] = '\0'; // ignore ;" at the end
- /* hopefully 'num' (num of matches) will be less than 10^16 */
+ // hopefully 'num' (num of matches) will be less than 10^16
newsize = (int)(strlen(csfmt_str) + 16 + strlen(lno));
if (bufsize < newsize)
{
}
if (buf != NULL)
{
- /* csfmt_str = "%4d %6s "; */
+ // csfmt_str = "%4d %6s ";
(void)sprintf(buf, csfmt_str, num, lno);
msg_puts_attr(buf, HL_ATTR(HLF_CM));
}
msg_outtrans_long_attr((char_u *)cs_pathcomponents(fname),
HL_ATTR(HLF_CM));
- /* compute the required space for the context */
+ // compute the required space for the context
if (cntxts[idx] != NULL)
context = cntxts[idx];
else
{
(void)sprintf(buf, cntxformat, context);
- /* print the context only if it fits on the same line */
+ // print the context only if it fits on the same line
if (msg_col + (int)strlen(buf) >= (int)Columns)
msg_putchar('\n');
msg_advance(12);
msg_outtrans_long_attr((char_u *)extra, 0);
}
- vim_free(tbuf); /* only after printing extra due to strtok use */
+ vim_free(tbuf); // only after printing extra due to strtok use
if (msg_col)
msg_putchar('\n');
ui_breakcheck();
if (got_int)
{
- got_int = FALSE; /* don't print any more matches */
+ got_int = FALSE; // don't print any more matches
break;
}
num++;
- } /* for all matches */
+ } // for all matches
vim_free(buf);
-} /* cs_print_tags_priv */
+}
/*
cs_read_prompt(int i)
{
int ch;
- char *buf = NULL; /* buffer for possible error message from cscope */
+ char *buf = NULL; // buffer for possible error message from cscope
int bufpos = 0;
char *cs_emsg;
int maxlen;
int n;
cs_emsg = _("E609: Cscope error: %s");
- /* compute maximum allowed len for Cscope error message */
+ // compute maximum allowed len for Cscope error message
maxlen = (int)(IOSIZE - strlen(cs_emsg));
for (;;)
{
while ((ch = getc(csinfo[i].fr_fp)) != EOF && ch != CSCOPE_PROMPT[0])
- /* if there is room and char is printable */
+ // if there is room and char is printable
if (bufpos < maxlen - 1 && vim_isprintc(ch))
{
- if (buf == NULL) /* lazy buffer allocation */
+ if (buf == NULL) // lazy buffer allocation
buf = alloc(maxlen);
if (buf != NULL)
{
- /* append character to the message */
+ // append character to the message
buf[bufpos++] = ch;
buf[bufpos] = NUL;
if (bufpos >= epromptlen
&& strcmp(&buf[bufpos - epromptlen], eprompt) == 0)
{
- /* remove eprompt from buf */
+ // remove eprompt from buf
buf[bufpos - epromptlen] = NUL;
- /* print message to user */
+ // print message to user
(void)semsg(cs_emsg, buf);
- /* send RETURN to cscope */
+ // send RETURN to cscope
(void)putc('\n', csinfo[i].to_fp);
(void)fflush(csinfo[i].to_fp);
- /* clear buf */
+ // clear buf
bufpos = 0;
buf[bufpos] = NUL;
}
if (buf != NULL && buf[0] != NUL)
(void)semsg(cs_emsg, buf);
else if (p_csverbose)
- cs_reading_emsg(i); /* don't have additional information */
+ cs_reading_emsg(i); // don't have additional information
cs_release_csp(i, TRUE);
vim_free(buf);
return CSCOPE_FAILURE;
}
if (ch == EOF)
- continue; /* didn't find the prompt */
- break; /* did find the prompt */
+ continue; // didn't find the prompt
+ break; // did find the prompt
}
vim_free(buf);
static RETSIGTYPE
sig_handler SIGDEFARG(sigarg)
{
- /* do nothing */
+ // do nothing
SIGRETURN;
}
#endif
# if defined(HAVE_SIGACTION)
struct sigaction sa, old;
- /* Use sigaction() to limit the waiting time to two seconds. */
+ // Use sigaction() to limit the waiting time to two seconds.
sigemptyset(&sa.sa_mask);
sa.sa_handler = sig_handler;
# ifdef SA_NODEFER
sa.sa_flags = 0;
# endif
sigaction(SIGALRM, &sa, &old);
- alarm(2); /* 2 sec timeout */
+ alarm(2); // 2 sec timeout
- /* Block until cscope exits or until timer expires */
+ // Block until cscope exits or until timer expires
pid = waitpid(csinfo[i].pid, &pstat, 0);
waitpid_errno = errno;
- /* cancel pending alarm if still there and restore signal */
+ // cancel pending alarm if still there and restore signal
alarm(0);
sigaction(SIGALRM, &old, NULL);
# else
int waited;
- /* Can't use sigaction(), loop for two seconds. First yield the CPU
- * to give cscope a chance to exit quickly. */
+ // Can't use sigaction(), loop for two seconds. First yield the CPU
+ // to give cscope a chance to exit quickly.
sleep(0);
for (waited = 0; waited < 40; ++waited)
{
pid = waitpid(csinfo[i].pid, &pstat, WNOHANG);
waitpid_errno = errno;
if (pid != 0)
- break; /* break unless the process is still running */
- mch_delay(50L, FALSE); /* sleep 50 ms */
+ break; // break unless the process is still running
+ mch_delay(50L, FALSE); // sleep 50 ms
}
# endif
/*
sleep(0);
for (waited = 0; waited < 40; ++waited)
{
- /* Check whether cscope process is still alive */
+ // Check whether cscope process is still alive
if (kill(csinfo[i].pid, 0) != 0)
{
- alive = FALSE; /* cscope process no longer exists */
+ alive = FALSE; // cscope process no longer exists
break;
}
- mch_delay(50L, FALSE); /* sleep 50ms */
+ mch_delay(50L, FALSE); // sleep 50ms
}
}
if (alive)
}
}
}
-#else /* !UNIX */
+#else // !UNIX
if (csinfo[i].hProc != NULL)
{
- /* Give cscope a chance to exit normally */
+ // Give cscope a chance to exit normally
if (WaitForSingleObject(csinfo[i].hProc, 1000) == WAIT_TIMEOUT)
TerminateProcess(csinfo[i].hProc, 0);
CloseHandle(csinfo[i].hProc);
}
clear_csinfo(i);
-} /* cs_release_csp */
+}
/*
{
char **dblist = NULL, **pplist = NULL, **fllist = NULL;
int i;
- char buf[20]; /* for sprintf " (#%d)" */
+ char buf[20]; // for sprintf " (#%d)"
if (csinfo_size == 0)
return CSCOPE_SUCCESS;
- /* malloc our db and ppath list */
+ // malloc our db and ppath list
dblist = ALLOC_MULT(char *, csinfo_size);
pplist = ALLOC_MULT(char *, csinfo_size);
fllist = ALLOC_MULT(char *, csinfo_size);
cs_release_csp(i, FALSE);
}
- /* rebuild the cscope connection list */
+ // rebuild the cscope connection list
for (i = 0; i < csinfo_size; i++)
{
if (dblist[i] != NULL)
cs_add_common(dblist[i], pplist[i], fllist[i]);
if (p_csverbose)
{
- /* don't use smsg_attr() because we want to display the
- * connection number in the same line as
- * "Added cscope database..."
- */
+ // don't use smsg_attr() because we want to display the
+ // connection number in the same line as
+ // "Added cscope database..."
sprintf(buf, " (#%d)", i);
msg_puts_attr(buf, HL_ATTR(HLF_R));
}
if (p_csverbose)
msg_attr(_("All cscope databases reset"), HL_ATTR(HLF_R) | MSG_HIST);
return CSCOPE_SUCCESS;
-} /* cs_reset */
+}
/*
len += (int)strlen(csinfo[i].ppath);
else if (p_csre && csinfo[i].fname != NULL)
{
- /* If 'cscoperelative' is set and ppath is not set, use cscope.out
- * path in path resolution. */
+ // If 'cscoperelative' is set and ppath is not set, use cscope.out
+ // path in path resolution.
csdir = alloc(MAXPATHL);
if (csdir != NULL)
{
}
}
- /* Note/example: this won't work if the cscope output already starts
- * "../.." and the prefix path is also "../..". if something like this
- * happens, you are screwed up and need to fix how you're using cscope. */
+ // Note/example: this won't work if the cscope output already starts
+ // "../.." and the prefix path is also "../..". if something like this
+ // happens, you are screwed up and need to fix how you're using cscope.
if (csinfo[i].ppath != NULL
&& (strncmp(name, csinfo[i].ppath, strlen(csinfo[i].ppath)) != 0)
&& (name[0] != '/')
}
else if (csdir != NULL && csinfo[i].fname != NULL && *csdir != NUL)
{
- /* Check for csdir to be non empty to avoid empty path concatenated to
- * cscope output. */
+ // Check for csdir to be non empty to avoid empty path concatenated to
+ // cscope output.
fullname = (char *)concat_fnames(csdir, (char_u *)name, TRUE);
}
else
wait_return(TRUE);
return CSCOPE_SUCCESS;
-} /* cs_show */
+}
/*
csinfo_size = 0;
}
-#endif /* FEAT_CSCOPE */
+#endif // FEAT_CSCOPE
#if defined(FEAT_EVAL) || defined(PROTO)
#include <lualib.h>
#include <lauxlib.h>
-/* Only do the following when the feature is enabled. Needed for "make
- * depend". */
+// Only do the following when the feature is enabled. Needed for "make
+// depend".
#if defined(FEAT_LUA) || defined(PROTO)
#define LUAVIM_CHUNKNAME "vim chunk"
static const char LUAVIM_LUAEVAL[] = "luaV_luaeval";
static const char LUAVIM_SETREF[] = "luaV_setref";
-/* most functions are closures with a cache table as first upvalue;
- * get/setudata manage references to vim userdata in cache table through
- * object pointers (light userdata) */
+// most functions are closures with a cache table as first upvalue;
+// get/setudata manage references to vim userdata in cache table through
+// object pointers (light userdata)
#define luaV_getudata(L, v) \
lua_pushlightuserdata((L), (void *) (v)); \
lua_rawget((L), lua_upvalueindex(1))
# define close_dll FreeLibrary
#endif
-/* lauxlib */
+// lauxlib
#if LUA_VERSION_NUM <= 501
#define luaL_register dll_luaL_register
#define luaL_prepbuffer dll_luaL_prepbuffer
#define luaL_buffinit dll_luaL_buffinit
#define luaL_addlstring dll_luaL_addlstring
#define luaL_pushresult dll_luaL_pushresult
-/* lua */
+// lua
#if LUA_VERSION_NUM <= 501
#define lua_tonumber dll_lua_tonumber
#define lua_tointeger dll_lua_tointeger
#define lua_rawseti dll_lua_rawseti
#define lua_setmetatable dll_lua_setmetatable
#define lua_next dll_lua_next
-/* libs */
+// libs
#define luaopen_base dll_luaopen_base
#define luaopen_table dll_luaopen_table
#define luaopen_string dll_luaopen_string
#define luaopen_debug dll_luaopen_debug
#define luaL_openlibs dll_luaL_openlibs
-/* lauxlib */
+// lauxlib
#if LUA_VERSION_NUM <= 501
void (*dll_luaL_register) (lua_State *L, const char *libname, const luaL_Reg *l);
char *(*dll_luaL_prepbuffer) (luaL_Buffer *B);
void (*dll_luaL_buffinit) (lua_State *L, luaL_Buffer *B);
void (*dll_luaL_addlstring) (luaL_Buffer *B, const char *s, size_t l);
void (*dll_luaL_pushresult) (luaL_Buffer *B);
-/* lua */
+// lua
#if LUA_VERSION_NUM <= 501
lua_Number (*dll_lua_tonumber) (lua_State *L, int idx);
lua_Integer (*dll_lua_tointeger) (lua_State *L, int idx);
#endif
int (*dll_lua_setmetatable) (lua_State *L, int objindex);
int (*dll_lua_next) (lua_State *L, int idx);
-/* libs */
+// libs
int (*dll_luaopen_base) (lua_State *L);
int (*dll_luaopen_table) (lua_State *L);
int (*dll_luaopen_string) (lua_State *L);
} luaV_Reg;
static const luaV_Reg luaV_dll[] = {
- /* lauxlib */
+ // lauxlib
#if LUA_VERSION_NUM <= 501
{"luaL_register", (luaV_function) &dll_luaL_register},
{"luaL_prepbuffer", (luaV_function) &dll_luaL_prepbuffer},
{"luaL_buffinit", (luaV_function) &dll_luaL_buffinit},
{"luaL_addlstring", (luaV_function) &dll_luaL_addlstring},
{"luaL_pushresult", (luaV_function) &dll_luaL_pushresult},
- /* lua */
+ // lua
#if LUA_VERSION_NUM <= 501
{"lua_tonumber", (luaV_function) &dll_lua_tonumber},
{"lua_tointeger", (luaV_function) &dll_lua_tointeger},
{"lua_rawseti", (luaV_function) &dll_lua_rawseti},
{"lua_setmetatable", (luaV_function) &dll_lua_setmetatable},
{"lua_next", (luaV_function) &dll_lua_next},
- /* libs */
+ // libs
{"luaopen_base", (luaV_function) &dll_luaopen_base},
{"luaopen_table", (luaV_function) &dll_luaopen_table},
{"luaopen_string", (luaV_function) &dll_luaopen_string},
}
return OK;
}
-#endif /* DYNAMIC_LUA */
+#endif // DYNAMIC_LUA
#if defined(DYNAMIC_LUA) || defined(PROTO)
int
#endif
-/* ======= Internal ======= */
+// ======= Internal =======
static void
luaV_newmetatable(lua_State *L, const char *tname)
{
void *p = lua_touserdata(L, ud);
- if (p != NULL) /* value is userdata? */
+ if (p != NULL) // value is userdata?
{
- if (lua_getmetatable(L, ud)) /* does it have a metatable? */
+ if (lua_getmetatable(L, ud)) // does it have a metatable?
{
- luaV_getfield(L, tname); /* get metatable */
- if (lua_rawequal(L, -1, -2)) /* MTs match? */
+ luaV_getfield(L, tname); // get metatable
+ if (lua_rawequal(L, -1, -2)) // MTs match?
{
- lua_pop(L, 2); /* MTs */
+ lua_pop(L, 2); // MTs
return p;
}
}
return status;
}
-/* similar to luaL_addlstring, but replaces \0 with \n if toline and
- * \n with \0 otherwise */
+/*
+ * similar to luaL_addlstring, but replaces \0 with \n if toline and
+ * \n with \0 otherwise
+ */
static void
luaV_addlstring(luaL_Buffer *b, const char *s, size_t l, int toline)
{
return (char_u *) lua_tostring(L, -1);
}
-/* pops a string s from the top of the stack and calls mf(t) for pieces t of
- * s separated by newlines */
+/*
+ * pops a string s from the top of the stack and calls mf(t) for pieces t of
+ * s separated by newlines
+ */
static void
luaV_msgfunc(lua_State *L, msgfunc_T mf)
{
luaL_buffinit(L, &b);
luaV_addlstring(&b, s, l, 0);
luaL_pushresult(&b);
- /* break string */
+ // break string
p = s = lua_tolstring(L, -1, &l);
while (l--)
{
- if (*p++ == '\0') /* break? */
+ if (*p++ == '\0') // break?
{
mf((char_u *) s);
s = p;
}
}
mf((char_u *) s);
- lua_pop(L, 2); /* original and modified strings */
+ lua_pop(L, 2); // original and modified strings
}
#define luaV_newtype(typ,tname,luatyp,luatname) \
return 1; \
}
-/* ======= List type ======= */
+// ======= List type =======
static luaV_List *
luaV_newlist(lua_State *L, list_T *lis)
{
luaV_List *l = (luaV_List *) lua_newuserdata(L, sizeof(luaV_List));
*l = lis;
- lis->lv_refcount++; /* reference in Lua */
- luaV_setudata(L, lis); /* cache[lis] = udata */
+ lis->lv_refcount++; // reference in Lua
+ luaV_setudata(L, lis); // cache[lis] = udata
luaV_getfield(L, LUAVIM_LIST);
lua_setmetatable(L, -2);
return l;
luaV_list_call(lua_State *L)
{
list_T *l = luaV_unbox(L, luaV_List, 1);
- lua_pushvalue(L, lua_upvalueindex(1)); /* pass cache table along */
+ lua_pushvalue(L, lua_upvalueindex(1)); // pass cache table along
lua_pushlightuserdata(L, (void *) l->lv_first);
lua_pushcclosure(L, luaV_list_iter, 2);
return 1;
luaV_list_index(lua_State *L)
{
list_T *l = luaV_unbox(L, luaV_List, 1);
- if (lua_isnumber(L, 2)) /* list item? */
+ if (lua_isnumber(L, 2)) // list item?
{
listitem_T *li = list_find(l, (long) luaL_checkinteger(L, 2));
if (li == NULL)
else
luaV_pushtypval(L, &li->li_tv);
}
- else if (lua_isstring(L, 2)) /* method? */
+ else if (lua_isstring(L, 2)) // method?
{
const char *s = lua_tostring(L, 2);
if (strncmp(s, "add", 3) == 0
luaL_error(L, "list is locked");
li = list_find(l, n);
if (li == NULL) return 0;
- if (lua_isnil(L, 3)) /* remove? */
+ if (lua_isnil(L, 3)) // remove?
{
vimlist_remove(l, li, li);
clear_tv(&li->li_tv);
};
-/* ======= Dict type ======= */
+// ======= Dict type =======
static luaV_Dict *
luaV_newdict(lua_State *L, dict_T *dic)
{
luaV_Dict *d = (luaV_Dict *) lua_newuserdata(L, sizeof(luaV_Dict));
*d = dic;
- dic->dv_refcount++; /* reference in Lua */
- luaV_setudata(L, dic); /* cache[dic] = udata */
+ dic->dv_refcount++; // reference in Lua
+ luaV_setudata(L, dic); // cache[dic] = udata
luaV_getfield(L, LUAVIM_DICT);
lua_setmetatable(L, -2);
return d;
{
dict_T *d = luaV_unbox(L, luaV_Dict, 1);
hashtab_T *ht = &d->dv_hashtab;
- lua_pushvalue(L, lua_upvalueindex(1)); /* pass cache table along */
+ lua_pushvalue(L, lua_upvalueindex(1)); // pass cache table along
lua_pushlightuserdata(L, (void *) ht->ht_array);
- lua_pushinteger(L, ht->ht_used); /* # remaining items */
+ lua_pushinteger(L, ht->ht_used); // # remaining items
lua_pushcclosure(L, luaV_dict_iter, 3);
return 1;
}
else
{
luaV_pushtypval(L, &di->di_tv);
- if (di->di_tv.v_type == VAR_FUNC) /* funcref? */
+ if (di->di_tv.v_type == VAR_FUNC) // funcref?
{
luaV_Funcref *f = (luaV_Funcref *) lua_touserdata(L, -1);
- f->self = d; /* keep "self" reference */
+ f->self = d; // keep "self" reference
d->dv_refcount++;
}
}
return 0;
if (*key == NUL)
luaL_error(L, "empty key");
- if (!lua_isnil(L, 3)) /* read value? */
+ if (!lua_isnil(L, 3)) // read value?
{
luaV_checktypval(L, 3, &v, "setting dict item");
if (d->dv_scope == VAR_DEF_SCOPE && v.v_type == VAR_FUNC)
luaL_error(L, "cannot assign funcref to builtin scope");
}
di = dict_find(d, key, -1);
- if (di == NULL) /* non-existing key? */
+ if (di == NULL) // non-existing key?
{
if (lua_isnil(L, 3))
return 0;
}
else
clear_tv(&di->di_tv);
- if (lua_isnil(L, 3)) /* remove? */
+ if (lua_isnil(L, 3)) // remove?
{
hashitem_T *hi = hash_find(&d->dv_hashtab, di->di_key);
hash_remove(&d->dv_hashtab, hi);
};
-/* ======= Blob type ======= */
+// ======= Blob type =======
static luaV_Blob *
luaV_newblob(lua_State *L, blob_T *blo)
{
luaV_Blob *b = (luaV_Blob *) lua_newuserdata(L, sizeof(luaV_Blob));
*b = blo;
- blo->bv_refcount++; /* reference in Lua */
- luaV_setudata(L, blo); /* cache[blo] = udata */
+ blo->bv_refcount++; // reference in Lua
+ luaV_setudata(L, blo); // cache[blo] = udata
luaV_getfield(L, LUAVIM_BLOB);
lua_setmetatable(L, -2);
return b;
};
-/* ======= Funcref type ======= */
+// ======= Funcref type =======
static luaV_Funcref *
luaV_newfuncref(lua_State *L, char_u *name)
return 0;
}
-/* equivalent to string(funcref) */
+// equivalent to string(funcref)
static int
luaV_funcref_len(lua_State *L)
{
};
-/* ======= Buffer type ======= */
+// ======= Buffer type =======
luaV_newtype(buf_T, buffer, luaV_Buffer, LUAVIM_BUFFER)
luaV_pushtype(buf_T, buffer, luaV_Buffer)
? "" : (char *) b->b_ffname);
else if (strncmp(s, "number", 6) == 0)
lua_pushinteger(L, b->b_fnum);
- /* methods */
+ // methods
else if (strncmp(s, "insert", 6) == 0
|| strncmp(s, "next", 4) == 0
|| strncmp(s, "previous", 8) == 0
#endif
if (n < 1 || n > b->b_ml.ml_line_count)
luaL_error(L, "invalid line number");
- if (lua_isnil(L, 3)) /* delete line */
+ if (lua_isnil(L, 3)) // delete line
{
buf_T *buf = curbuf;
curbuf = b;
else
{
deleted_lines_mark(n, 1L);
- if (b == curwin->w_buffer) /* fix cursor in current window? */
+ if (b == curwin->w_buffer) // fix cursor in current window?
{
if (curwin->w_cursor.lnum >= n)
{
}
curbuf = buf;
}
- else if (lua_isstring(L, 3)) /* update line */
+ else if (lua_isstring(L, 3)) // update line
{
buf_T *buf = curbuf;
curbuf = b;
#ifdef HAVE_SANDBOX
luaV_checksandbox(L);
#endif
- /* fix insertion line */
+ // fix insertion line
if (n < 0) n = 0;
if (n > last) n = last;
- /* insert */
+ // insert
buf = curbuf;
curbuf = b;
if (u_save(n, n + 1) == FAIL)
};
-/* ======= Window type ======= */
+// ======= Window type =======
luaV_newtype(win_T, window, luaV_Window, LUAVIM_WINDOW)
luaV_pushtype(win_T, window, luaV_Window)
lua_pushinteger(L, w->w_width);
else if (strncmp(s, "height", 6) == 0)
lua_pushinteger(L, w->w_height);
- /* methods */
+ // methods
else if (strncmp(s, "next", 4) == 0
|| strncmp(s, "previous", 8) == 0
|| strncmp(s, "isvalid", 7) == 0)
};
-/* ======= Vim module ======= */
+// ======= Vim module =======
static int
luaV_print(lua_State *L)
{
- int i, n = lua_gettop(L); /* nargs */
+ int i, n = lua_gettop(L); // nargs
const char *s;
size_t l;
luaL_Buffer b;
lua_getglobal(L, "tostring");
for (i = 1; i <= n; i++)
{
- lua_pushvalue(L, -1); /* tostring */
- lua_pushvalue(L, i); /* arg */
+ lua_pushvalue(L, -1); // tostring
+ lua_pushvalue(L, i); // arg
lua_call(L, 1, 1);
s = lua_tolstring(L, -1, &l);
if (s == NULL)
return luaL_error(L, "cannot convert to string");
- if (i > 1) luaL_addchar(&b, ' '); /* use space instead of tab */
+ if (i > 1) luaL_addchar(&b, ' '); // use space instead of tab
luaV_addlstring(&b, s, l, 0);
lua_pop(L, 1);
}
lua_settop(L, 0);
lua_getglobal(L, "vim");
lua_getfield(L, -1, "eval");
- lua_remove(L, -2); /* vim.eval at position 1 */
+ lua_remove(L, -2); // vim.eval at position 1
for (;;)
{
const char *input;
size_t l;
- lua_pushvalue(L, 1); /* vim.eval */
+ lua_pushvalue(L, 1); // vim.eval
lua_pushliteral(L, "input('lua_debug> ')");
- lua_call(L, 1, 1); /* return string */
+ lua_call(L, 1, 1); // return string
input = lua_tolstring(L, -1, &l);
if (l == 0 || strcmp(input, "cont") == 0)
return 0;
- msg_putchar('\n'); /* avoid outputting on input line */
+ msg_putchar('\n'); // avoid outputting on input line
if (luaL_loadbuffer(L, input, l, "=(debug command)")
|| lua_pcall(L, 0, 0, 0))
luaV_emsg(L);
- lua_settop(L, 1); /* remove eventual returns, but keep vim.eval */
+ lua_settop(L, 1); // remove eventual returns, but keep vim.eval
}
}
else
{
luaV_newlist(L, l);
- if (initarg) /* traverse table to init list */
+ if (initarg) // traverse table to init list
{
int notnil, i = 0;
typval_T v;
list_append_tv(l, &v);
clear_tv(&v);
}
- lua_pop(L, 1); /* value */
+ lua_pop(L, 1); // value
} while (notnil);
}
}
else
{
luaV_newdict(L, d);
- if (initarg) /* traverse table to init dict */
+ if (initarg) // traverse table to init dict
{
lua_pushnil(L);
while (lua_next(L, 1))
dictitem_T *di;
typval_T v;
- lua_pushvalue(L, -2); /* dup key in case it's a number */
+ lua_pushvalue(L, -2); // dup key in case it's a number
key = (char_u *) lua_tostring(L, -1);
if (key == NULL)
{
}
if (*key == NUL)
luaL_error(L, "table has empty key");
- luaV_checktypval(L, -2, &v, "vim.dict"); /* value */
+ luaV_checktypval(L, -2, &v, "vim.dict"); // value
di = dictitem_alloc(key);
if (di == NULL || dict_add(d, di) == FAIL)
{
}
copy_tv(&v, &di->di_tv);
clear_tv(&v);
- lua_pop(L, 2); /* key copy and value */
+ lua_pop(L, 2); // key copy and value
}
}
}
luaV_funcref(lua_State *L)
{
const char *name = luaL_checkstring(L, 1);
- /* note: not checking if function exists (needs function_exists) */
+ // note: not checking if function exists (needs function_exists)
if (name == NULL || *name == NUL || VIM_ISDIGIT(*name))
luaL_error(L, "invalid function name: %s", name);
luaV_newfuncref(L, (char_u *) name);
luaV_buffer(lua_State *L)
{
buf_T *buf;
- if (lua_isstring(L, 1)) /* get by number or name? */
+ if (lua_isstring(L, 1)) // get by number or name?
{
- if (lua_isnumber(L, 1)) /* by number? */
+ if (lua_isnumber(L, 1)) // by number?
{
int n = lua_tointeger(L, 1);
FOR_ALL_BUFFERS(buf)
}
}
else
- buf = (lua_toboolean(L, 1)) ? firstbuf : curbuf; /* first buffer? */
+ buf = (lua_toboolean(L, 1)) ? firstbuf : curbuf; // first buffer?
luaV_pushbuffer(L, buf);
return 1;
}
luaV_window(lua_State *L)
{
win_T *win;
- if (lua_isnumber(L, 1)) /* get by number? */
+ if (lua_isnumber(L, 1)) // get by number?
{
int n = lua_tointeger(L, 1);
for (win = firstwin; win != NULL; win = win->w_next, n--)
if (n == 1) break;
}
else
- win = (lua_toboolean(L, 1)) ? firstwin : curwin; /* first window? */
+ win = (lua_toboolean(L, 1)) ? firstwin : curwin; // first window?
luaV_pushwindow(L, win);
return 1;
}
luaV_type(lua_State *L)
{
luaL_checkany(L, 1);
- if (lua_type(L, 1) == LUA_TUSERDATA) /* check vim udata? */
+ if (lua_type(L, 1) == LUA_TUSERDATA) // check vim udata?
{
lua_settop(L, 1);
if (lua_getmetatable(L, 1))
}
}
}
- lua_pushstring(L, luaL_typename(L, 1)); /* fallback */
+ lua_pushstring(L, luaL_typename(L, 1)); // fallback
return 1;
}
{NULL, NULL}
};
-/* for freeing list, dict, buffer and window objects; lightuserdata as arg */
+/*
+ * for freeing list, dict, buffer and window objects; lightuserdata as arg
+ */
static int
luaV_free(lua_State *L)
{
luaL_addlstring(&b, str, l);
luaL_pushresult(&b);
str = lua_tolstring(L, -1, &l);
- if (luaL_loadbuffer(L, str, l, LUAVIM_EVALNAME)) /* compile error? */
+ if (luaL_loadbuffer(L, str, l, LUAVIM_EVALNAME)) // compile error?
{
luaV_emsg(L);
return 0;
}
luaV_pushtypval(L, arg);
- if (lua_pcall(L, 1, 1, 0)) /* running error? */
+ if (lua_pcall(L, 1, 1, 0)) // running error?
{
luaV_emsg(L);
return 0;
static int
luaopen_vim(lua_State *L)
{
- /* set cache table */
+ // set cache table
lua_newtable(L);
lua_newtable(L);
lua_pushstring(L, "v");
lua_setfield(L, -2, "__mode");
- lua_setmetatable(L, -2); /* cache is weak-valued */
- /* print */
+ lua_setmetatable(L, -2); // cache is weak-valued
+ // print
lua_pushcfunction(L, luaV_print);
lua_setglobal(L, "print");
- /* debug.debug */
+ // debug.debug
lua_getglobal(L, "debug");
lua_pushcfunction(L, luaV_debug);
lua_setfield(L, -2, "debug");
lua_pop(L, 1);
- /* free */
+ // free
lua_pushlightuserdata(L, (void *) LUAVIM_FREE);
- lua_pushvalue(L, 1); /* cache table */
+ lua_pushvalue(L, 1); // cache table
lua_pushcclosure(L, luaV_free, 1);
lua_rawset(L, LUA_REGISTRYINDEX);
- /* luaeval */
+ // luaeval
lua_pushlightuserdata(L, (void *) LUAVIM_LUAEVAL);
- lua_pushvalue(L, 1); /* cache table */
+ lua_pushvalue(L, 1); // cache table
lua_pushcclosure(L, luaV_luaeval, 1);
lua_rawset(L, LUA_REGISTRYINDEX);
- /* setref */
+ // setref
lua_pushlightuserdata(L, (void *) LUAVIM_SETREF);
- lua_pushvalue(L, 1); /* cache table */
+ lua_pushvalue(L, 1); // cache table
lua_pushcclosure(L, luaV_setref, 1);
lua_rawset(L, LUA_REGISTRYINDEX);
- /* register */
+ // register
luaV_newmetatable(L, LUAVIM_LIST);
lua_pushvalue(L, 1);
luaV_openlib(L, luaV_List_mt, 1);
lua_pushvalue(L, 1);
luaV_openlib(L, luaV_Funcref_mt, 1);
luaV_newmetatable(L, LUAVIM_BUFFER);
- lua_pushvalue(L, 1); /* cache table */
+ lua_pushvalue(L, 1); // cache table
luaV_openlib(L, luaV_Buffer_mt, 1);
luaV_newmetatable(L, LUAVIM_WINDOW);
- lua_pushvalue(L, 1); /* cache table */
+ lua_pushvalue(L, 1); // cache table
luaV_openlib(L, luaV_Window_mt, 1);
- lua_newtable(L); /* vim table */
- lua_pushvalue(L, 1); /* cache table */
+ lua_newtable(L); // vim table
+ lua_pushvalue(L, 1); // cache table
luaV_openlib(L, luaV_module, 1);
lua_setglobal(L, LUAVIM_NAME);
return 0;
luaV_newstate(void)
{
lua_State *L = luaL_newstate();
- luaL_openlibs(L); /* core libs */
- lua_pushcfunction(L, luaopen_vim); /* vim */
+ luaL_openlibs(L); // core libs
+ lua_pushcfunction(L, luaopen_vim); // vim
lua_call(L, 0, 0);
return L;
}
lua_setfield(L, -2, "firstline");
lua_pushinteger(L, line2);
lua_setfield(L, -2, "lastline");
- lua_pop(L, 1); /* vim table */
+ lua_pop(L, 1); // vim table
}
-/* ======= Interface ======= */
+// ======= Interface =======
static lua_State *L = NULL;
}
}
-/* ex commands */
+/*
+ * ex commands
+ */
void
ex_lua(exarg_T *eap)
{
}
luaV_setrange(L, eap->line1, eap->line2);
luaL_buffinit(L, &b);
- luaL_addlstring(&b, "return function(line, linenr) ", 30); /* header */
+ luaL_addlstring(&b, "return function(line, linenr) ", 30); // header
luaL_addlstring(&b, s, strlen(s));
- luaL_addlstring(&b, " end", 4); /* footer */
+ luaL_addlstring(&b, " end", 4); // footer
luaL_pushresult(&b);
s = lua_tolstring(L, -1, &len);
if (luaL_loadbuffer(L, s, len, LUAVIM_CHUNKNAME))
{
luaV_emsg(L);
- lua_pop(L, 1); /* function body */
+ lua_pop(L, 1); // function body
return;
}
lua_call(L, 0, 1);
- lua_replace(L, -2); /* function -> body */
+ lua_replace(L, -2); // function -> body
for (l = eap->line1; l <= eap->line2; l++)
{
- /* Check the line number, the command my have deleted lines. */
+ // Check the line number, the command my have deleted lines.
if (l > curbuf->b_ml.ml_line_count)
break;
- lua_pushvalue(L, -1); /* function */
- luaV_pushline(L, curbuf, l); /* current line as arg */
- lua_pushinteger(L, l); /* current line number as arg */
+ lua_pushvalue(L, -1); // function
+ luaV_pushline(L, curbuf, l); // current line as arg
+ lua_pushinteger(L, l); // current line number as arg
if (lua_pcall(L, 2, 1, 0))
{
luaV_emsg(L);
break;
}
- /* Catch the command switching to another buffer. */
+ // Catch the command switching to another buffer.
if (curbuf != was_curbuf)
break;
- if (lua_isstring(L, -1)) /* update line? */
+ if (lua_isstring(L, -1)) // update line?
{
#ifdef HAVE_SANDBOX
luaV_checksandbox(L);
#endif
ml_replace(l, luaV_toline(L, -1), TRUE);
changed_bytes(l, 0);
- lua_pop(L, 1); /* result from luaV_toline */
+ lua_pop(L, 1); // result from luaV_toline
}
- lua_pop(L, 1); /* line */
+ lua_pop(L, 1); // line
}
- lua_pop(L, 1); /* function */
+ lua_pop(L, 1); // function
check_cursor();
update_screen(NOT_VALID);
}
if (lua_isopen())
{
luaV_getfield(L, LUAVIM_SETREF);
- /* call the function with 1 arg, getting 1 result back */
+ // call the function with 1 arg, getting 1 result back
lua_pushinteger(L, copyID);
lua_call(L, 1, 1);
- /* get the result */
+ // get the result
aborted = lua_tointeger(L, -1);
- /* pop result off the stack */
+ // pop result off the stack
lua_pop(L, 1);
}
return aborted;
#include "if_mzsch.h"
-/* Only do the following when the feature is enabled. Needed for "make
- * depend". */
+// Only do the following when the feature is enabled. Needed for "make
+// depend".
#if defined(FEAT_MZSCHEME) || defined(PROTO)
#ifdef PROTO
# define TRAMPOLINED_MZVIM_STARTUP
#endif
-/* Base data structures */
+// Base data structures
#define SCHEME_VIMBUFFERP(obj) SAME_TYPE(SCHEME_TYPE(obj), mz_buffer_type)
#define SCHEME_VIMWINDOWP(obj) SAME_TYPE(SCHEME_TYPE(obj), mz_window_type)
{
Scheme_Closed_Prim *prim;
char *name;
- int mina; /* arity information */
+ int mina; // arity information
int maxa;
} Vim_Prim;
static Scheme_Object *sandbox_network_guard(int, Scheme_Object **);
static void sandbox_check(void);
#endif
-/* Buffer-related commands */
+// Buffer-related commands
static Scheme_Object *buffer_new(buf_T *buf);
static Scheme_Object *get_buffer_by_num(void *, int, Scheme_Object **);
static vim_mz_buffer *get_vim_curr_buffer(void);
-/* Window-related commands */
+// Window-related commands
static Scheme_Object *window_new(win_T *win);
static vim_mz_window *get_vim_curr_window(void);
}
static int buffer_fixup_proc(void *obj)
{
- /* apparently not needed as the object will be uncollectable while
- * the buffer is alive
- */
- /*
- vim_mz_buffer* buf = (vim_mz_buffer*) obj;
- buf->buf->b_mzscheme_ref = GC_fixup_self(obj);
- */
+ // apparently not needed as the object will be uncollectable while
+ // the buffer is alive
+ // vim_mz_buffer* buf = (vim_mz_buffer*) obj;
+ // buf->buf->b_mzscheme_ref = GC_fixup_self(obj);
+
return buffer_size_proc(obj);
}
static int window_size_proc(void *obj UNUSED)
}
static int window_fixup_proc(void *obj)
{
- /* apparently not needed as the object will be uncollectable while
- * the window is alive
- */
- /*
- vim_mz_window* win = (vim_mz_window*) obj;
- win->win->w_mzscheme_ref = GC_fixup_self(obj);
- */
+ // apparently not needed as the object will be uncollectable while
+ // the window is alive
+ // vim_mz_window* win = (vim_mz_window*) obj;
+ // win->win->w_mzscheme_ref = GC_fixup_self(obj);
+ //
return window_size_proc(obj);
}
-/* with precise GC, w_mzscheme_ref and b_mzscheme_ref are immobile boxes
- * containing pointers to a window/buffer
- * with conservative GC these are simply pointers*/
+// with precise GC, w_mzscheme_ref and b_mzscheme_ref are immobile boxes
+// containing pointers to a window/buffer
+// with conservative GC these are simply pointers
# define WINDOW_REF(win) *(vim_mz_window **)((win)->w_mzscheme_ref)
# define BUFFER_REF(buf) *(vim_mz_buffer **)((buf)->b_mzscheme_ref)
#else
static void (*dll_scheme_set_config_path)(Scheme_Object *p);
# endif
-#if defined(DYNAMIC_MZSCHEME) /* not when defined(PROTO) */
+#if defined(DYNAMIC_MZSCHEME) // not when defined(PROTO)
-/* arrays are imported directly */
+// arrays are imported directly
# define scheme_eof dll_scheme_eof
# define scheme_false dll_scheme_false
# define scheme_void dll_scheme_void
# define scheme_null dll_scheme_null
# define scheme_true dll_scheme_true
-/* pointers are GetProceAddress'ed as pointers to pointer */
+// pointers are GetProceAddress'ed as pointers to pointer
#if !defined(USE_THREAD_LOCAL) && !defined(LINK_EXTENSIONS_BY_TABLE)
# define scheme_current_thread (*dll_scheme_current_thread_ptr)
# endif
# define scheme_console_output (*dll_scheme_console_output_ptr)
# define scheme_notify_multithread (*dll_scheme_notify_multithread_ptr)
-/* and functions in a usual way */
+// and functions in a usual way
# define GC_malloc dll_GC_malloc
# define GC_malloc_atomic dll_GC_malloc_atomic
# if MZSCHEME_VERSION_MAJOR >= 500
# if defined(IMPLEMENT_THREAD_LOCAL_VIA_WIN_TLS) || defined(IMPLEMENT_THREAD_LOCAL_EXTERNALLY_VIA_PROC)
-/* define as function for macro in schthread.h */
+// define as function for macro in schthread.h
Thread_Local_Variables *
scheme_external_get_thread_local_variables(void)
{
hMzGC = 0;
}
}
-#endif /* DYNAMIC_MZSCHEME */
+#endif // DYNAMIC_MZSCHEME
#if MZSCHEME_VERSION_MAJOR < 299
# define GUARANTEED_STRING_ARG(proc, num) GUARANTEE_STRING(proc, num)
}
else
scheme_wrong_type(proc, "string", num, argc, argv);
- /* unreachable */
+ // unreachable
return scheme_void;
}
# define GUARANTEED_STRING_ARG(proc, num) guaranteed_byte_string_arg(proc, num, argc, argv)
#endif
-/* need to put it here for dynamic stuff to work */
+// need to put it here for dynamic stuff to work
#if defined(INCLUDE_MZSCHEME_BASE)
# include "mzscheme_base.c"
#endif
#endif
static int load_base_module_failed = FALSE;
-/* global environment */
+// global environment
static Scheme_Env *environment = NULL;
-/* output/error handlers */
+// output/error handlers
static Scheme_Object *curout = NULL;
static Scheme_Object *curerr = NULL;
-/* exn:vim exception */
+// exn:vim exception
static Scheme_Object *exn_catching_apply = NULL;
static Scheme_Object *exn_p = NULL;
static Scheme_Object *exn_message = NULL;
-static Scheme_Object *vim_exn = NULL; /* Vim Error exception */
+static Scheme_Object *vim_exn = NULL; // Vim Error exception
#if !defined(MZ_PRECISE_GC) || MZSCHEME_VERSION_MAJOR < 400
static void *stack_base = NULL;
static long range_start;
static long range_end;
-/* MzScheme threads scheduling stuff */
+// MzScheme threads scheduling stuff
static int mz_threads_allow = 0;
#if defined(FEAT_GUI_MSWIN)
static EventLoopTimerUPP timerUPP;
#endif
-#if !defined(FEAT_GUI_MSWIN) || defined(VIMDLL) /* Win32 console and Unix */
+#if !defined(FEAT_GUI_MSWIN) || defined(VIMDLL) // Win32 console and Unix
void
mzvim_check_threads(void)
{
- /* Last time MzScheme threads were scheduled */
+ // Last time MzScheme threads were scheduled
static time_t mz_last_time = 0;
if (mz_threads_allow && p_mzq > 0)
static void setup_timer(void);
static void remove_timer(void);
-/* timers are presented in GUI only */
+// timers are presented in GUI only
# if defined(FEAT_GUI_MSWIN)
static void CALLBACK
timer_proc(HWND hwnd UNUSED, UINT uMsg UNUSED, UINT_PTR idEvent UNUSED, DWORD dwTime UNUSED)
{
scheme_check_threads();
# if defined(FEAT_GUI_GTK)
- return TRUE; /* continue receiving notifications */
+ return TRUE; // continue receiving notifications
# elif defined(FEAT_GUI_MOTIF) || defined(FEAT_GUI_ATHENA)
- /* renew timeout */
+ // renew timeout
if (mz_threads_allow && p_mzq > 0)
timer_id = XtAppAddTimeOut(app_context, p_mzq,
timer_proc, NULL);
setup_timer();
}
-#endif /* MZSCHEME_GUI_THREADS */
+#endif // MZSCHEME_GUI_THREADS
static void
notify_multithread(int on)
void
mzscheme_end(void)
{
- /* We can not unload the DLL. Racket's thread might be still alive. */
+ // We can not unload the DLL. Racket's thread might be still alive.
#if 0
#ifdef DYNAMIC_MZSCHEME
dynamic_mzscheme_end();
mzscheme_env_main(Scheme_Env *env, int argc UNUSED, char **argv UNUSED)
{
#ifdef TRAMPOLINED_MZVIM_STARTUP
- /* Scheme has created the environment for us */
+ // Scheme has created the environment for us
environment = env;
#else
# ifdef MZ_PRECISE_GC
#endif
vim_main2();
- /* not reached, vim_main2() will loop until exit() */
+ // not reached, vim_main2() will loop until exit()
return 0;
}
#endif
#ifndef TRAMPOLINED_MZVIM_STARTUP
- /* in newer versions of precise GC the initial env has been created */
+ // in newer versions of precise GC the initial env has been created
environment = scheme_basic_env();
#endif
MZ_GC_CHECK();
#ifdef INCLUDE_MZSCHEME_BASE
- /* invoke function from generated and included mzscheme_base.c */
+ // invoke function from generated and included mzscheme_base.c
declare_modules(environment);
#endif
- /* setup 'current-library-collection-paths' parameter */
+ // setup 'current-library-collection-paths' parameter
# if MZSCHEME_VERSION_MAJOR >= 299
{
Scheme_Object *coll_path = NULL;
MZ_GC_DECL_REG(1);
MZ_GC_VAR_IN_REG(0, coll_path);
MZ_GC_REG();
- /* workaround for dynamic loading on windows */
+ // workaround for dynamic loading on windows
s = vim_getenv((char_u *)"PLTCOLLECTS", &mustfree);
if (s != NULL)
{
MZ_GC_DECL_REG(1);
MZ_GC_VAR_IN_REG(0, config_path);
MZ_GC_REG();
- /* workaround for dynamic loading on windows */
+ // workaround for dynamic loading on windows
s = vim_getenv((char_u *)"PLTCONFIGDIR", &mustfree);
if (s != NULL)
{
* we need to add them explicitly
*/
{
- /* use error handler to avoid abort */
+ // use error handler to avoid abort
scheme_dynamic_wind(NULL, load_base_module, NULL,
load_base_module_on_error, "racket/base");
if (load_base_module_failed)
}
register_vim_exn();
- /* use new environment to initialise exception handling */
+ // use new environment to initialise exception handling
init_exn_catching_apply();
- /* redirect output */
+ // redirect output
scheme_console_output = do_output;
scheme_console_printf = do_printf;
MZ_GC_CHECK();
#endif
- /* setup sandbox guards */
+ // setup sandbox guards
if (make_security_guard != NULL)
{
Scheme_Object *args[3] = {NULL, NULL, NULL};
MZ_GC_UNREG();
}
#endif
- /* Create buffer and window types for use in Scheme code */
+ // Create buffer and window types for use in Scheme code
mz_buffer_type = scheme_make_type("<vim-buffer>");
MZ_GC_CHECK();
mz_window_type = scheme_make_type("<vim-window>");
MZ_GC_REG();
config = scheme_current_config();
MZ_GC_CHECK();
- /* recreate ports each call effectively clearing these ones */
+ // recreate ports each call effectively clearing these ones
curout = scheme_make_byte_string_output_port();
MZ_GC_CHECK();
curerr = scheme_make_byte_string_output_port();
if (!value)
{
value = extract_exn_message(exn);
- /* Got an exn? */
+ // Got an exn?
if (value)
{
- scheme_display(value, curerr); /* Send to stderr-vim */
+ scheme_display(value, curerr); // Send to stderr-vim
MZ_GC_CHECK();
do_flush();
}
MZ_GC_UNREG();
- /* `raise' was called on some arbitrary value */
+ // `raise' was called on some arbitrary value
return FAIL;
}
- if (ret != NULL) /* if pointer to retval supported give it up */
+ if (ret != NULL) // if pointer to retval supported give it up
*ret = value;
- /* Print any result, as long as it's not a void */
+ // Print any result, as long as it's not a void
else if (!SCHEME_VOIDP(value))
{
- scheme_display(value, curout); /* Send to stdout-vim */
+ scheme_display(value, curout); // Send to stdout-vim
MZ_GC_CHECK();
}
return OK;
}
-/* :mzscheme */
+/*
+ * :mzscheme
+ */
static int
do_mzscheme_command(exarg_T *eap, void *data, Scheme_Closed_Prim *what)
{
file = (char *)scheme_malloc_fail_ok(scheme_malloc_atomic, MAXPATHL + 1);
MZ_GC_CHECK();
- /* make Vim expansion */
+ // make Vim expansion
expand_env((char_u *)pinfo->name, (char_u *)file, MAXPATHL);
pinfo->port = scheme_open_input_file(file, "mzfile");
MZ_GC_CHECK();
- scheme_count_lines(pinfo->port); /* to get accurate read error location*/
+ scheme_count_lines(pinfo->port); // to get accurate read error location
MZ_GC_CHECK();
- /* Like REPL but print only last result */
+ // Like REPL but print only last result
while (!SCHEME_EOFP(expr = scheme_read(pinfo->port)))
{
result = scheme_eval(expr, environment);
MZ_GC_CHECK();
}
- /* errors will be caught in do_mzscheme_command and ex_mzfile */
+ // errors will be caught in do_mzscheme_command and ex_mzfile
scheme_close_input_port(pinfo->port);
MZ_GC_CHECK();
pinfo->port = NULL;
return result;
}
-/* :mzfile */
+/*
+ * :mzfile
+ */
void
ex_mzfile(exarg_T *eap)
{
pinfo.name = (char *)eap->arg;
if (do_mzscheme_command(eap, &pinfo, do_load) != OK
- && pinfo.port != NULL) /* looks like port was not closed */
+ && pinfo.port != NULL) // looks like port was not closed
{
scheme_close_input_port(pinfo.port);
MZ_GC_CHECK();
Scheme_Object *v;
v = _scheme_apply(exn_catching_apply, 1, &f);
- /* v is a pair: (cons #t value) or (cons #f exn) */
+ // v is a pair: (cons #t value) or (cons #f exn)
if (SCHEME_TRUEP(SCHEME_CAR(v)))
return SCHEME_CDR(v);
if (SCHEME_TRUEP(_scheme_apply(exn_p, 1, &v)))
return _scheme_apply(exn_message, 1, &v);
else
- return NULL; /* Not an exn structure */
+ return NULL; // Not an exn structure
}
static Scheme_Object *
static void
do_output(char *mesg, OUTPUT_LEN_TYPE len UNUSED)
{
- /* TODO: use len, the string may not be NUL terminated */
+ // TODO: use len, the string may not be NUL terminated
do_intrnl_output(mesg, 0);
}
*========================================================================
*/
-/* (command {command-string}) */
+/*
+ * (command {command-string})
+ */
static Scheme_Object *
vim_command(void *data, int argc, Scheme_Object **argv)
{
MZ_GC_REG();
cmd = GUARANTEED_STRING_ARG(prim->name, 0);
- /* may be use do_cmdline_cmd? */
+ // may be use do_cmdline_cmd?
do_cmdline(BYTE_STRING_VALUE(cmd), NULL, NULL, DOCMD_NOWAIT|DOCMD_VERBOSE);
update_screen(VALID);
return scheme_void;
}
-/* (eval {expr-string}) */
+/*
+ * (eval {expr-string})
+ */
static Scheme_Object *
vim_eval(void *data UNUSED, int argc UNUSED, Scheme_Object **argv UNUSED)
{
return result;
#else
raise_vim_exn(_("expressions disabled at compile time"));
- /* unreachable */
+ // unreachable
return scheme_false;
#endif
}
-/* (range-start) */
+/*
+ * (range-start)
+ */
static Scheme_Object *
get_range_start(void *data UNUSED, int argc UNUSED, Scheme_Object **argv UNUSED)
{
return scheme_make_integer(range_start);
}
-/* (range-end) */
+/*
+ * (range-end)
+ */
static Scheme_Object *
get_range_end(void *data UNUSED, int argc UNUSED, Scheme_Object **argv UNUSED)
{
return scheme_make_integer(range_end);
}
-/* (beep) */
+/*
+ * (beep)
+ */
static Scheme_Object *
mzscheme_beep(void *data UNUSED, int argc UNUSED, Scheme_Object **argv UNUSED)
{
static Scheme_Object *M_global = NULL;
-/* (get-option {option-name}) [buffer/window] */
+/*
+ * (get-option {option-name}) [buffer/window]
+ */
static Scheme_Object *
get_option(void *data, int argc, Scheme_Object **argv)
{
case -2:
MZ_GC_UNREG();
raise_vim_exn(_("hidden option"));
- /*NOTREACHED*/
+ //NOTREACHED
case -3:
MZ_GC_UNREG();
raise_vim_exn(_("unknown option"));
- /*NOTREACHED*/
+ //NOTREACHED
}
- /* unreachable */
+ // unreachable
return scheme_void;
}
-/* (set-option {option-changing-string} [buffer/window]) */
+/*
+ * (set-option {option-changing-string} [buffer/window])
+ */
static Scheme_Object *
set_option(void *data, int argc, Scheme_Object **argv)
{
scheme_wrong_type(prim->name, "vim-buffer/window", 1, argc, argv);
}
- /* do_set can modify cmd, make copy */
+ // do_set can modify cmd, make copy
command = vim_strsave(BYTE_STRING_VALUE(cmd));
MZ_GC_UNREG();
do_set(command, opt_flags);
*===========================================================================
*/
-/* (curr-win) */
+/*
+ * (curr-win)
+ */
static Scheme_Object *
get_curr_win(void *data UNUSED, int argc UNUSED, Scheme_Object **argv UNUSED)
{
return (Scheme_Object *)get_vim_curr_window();
}
-/* (win-count) */
+/*
+ * (win-count)
+ */
static Scheme_Object *
get_window_count(void *data UNUSED, int argc UNUSED, Scheme_Object **argv UNUSED)
{
return scheme_make_integer(n);
}
-/* (get-win-list [buffer]) */
+/*
+ * (get-win-list [buffer])
+ */
static Scheme_Object *
get_window_list(void *data, int argc, Scheme_Object **argv)
{
MZ_GC_DECL_REG(1);
MZ_GC_VAR_IN_REG(0, self);
- /* We need to handle deletion of windows underneath us.
- * If we add a "w_mzscheme_ref" field to the win_T structure,
- * then we can get at it in win_free() in vim.
- *
- * On a win_free() we set the Scheme object's win_T *field
- * to an invalid value. We trap all uses of a window
- * object, and reject them if the win_T *field is invalid.
- */
+ // We need to handle deletion of windows underneath us.
+ // If we add a "w_mzscheme_ref" field to the win_T structure,
+ // then we can get at it in win_free() in vim.
+ //
+ // On a win_free() we set the Scheme object's win_T *field
+ // to an invalid value. We trap all uses of a window
+ // object, and reject them if the win_T *field is invalid.
if (win->w_mzscheme_ref != NULL)
return (Scheme_Object *)WINDOW_REF(win);
self = scheme_malloc_fail_ok(scheme_malloc_tagged, sizeof(vim_mz_window));
vim_memset(self, 0, sizeof(vim_mz_window));
#ifndef MZ_PRECISE_GC
- scheme_dont_gc_ptr(self); /* because win isn't visible to GC */
+ scheme_dont_gc_ptr(self); // because win isn't visible to GC
#else
win->w_mzscheme_ref = scheme_malloc_immobile_box(NULL);
#endif
return (Scheme_Object *)self;
}
-/* (get-win-num [window]) */
+/*
+ * (get-win-num [window])
+ */
static Scheme_Object *
get_window_num(void *data UNUSED, int argc UNUSED, Scheme_Object **argv UNUSED)
{
return scheme_make_integer(nr);
}
-/* (get-win-by-num {windownum}) */
+/*
+ * (get-win-by-num {windownum})
+ */
static Scheme_Object *
get_window_by_num(void *data, int argc, Scheme_Object **argv)
{
scheme_signal_error(_("window index is out of range"));
for ( ; win != NULL; win = win->w_next, --fnum)
- if (fnum == 1) /* to be 1-based */
+ if (fnum == 1) // to be 1-based
return window_new(win);
return scheme_false;
}
-/* (get-win-buffer [window]) */
+/*
+ * (get-win-buffer [window])
+ */
static Scheme_Object *
get_window_buffer(void *data, int argc, Scheme_Object **argv)
{
return buffer_new(win->win->w_buffer);
}
-/* (get-win-height [window]) */
+/*
+ * (get-win-height [window])
+ */
static Scheme_Object *
get_window_height(void *data, int argc, Scheme_Object **argv)
{
return scheme_make_integer(win->win->w_height);
}
-/* (set-win-height {height} [window]) */
+/*
+ * (set-win-height {height} [window])
+ */
static Scheme_Object *
set_window_height(void *data, int argc, Scheme_Object **argv)
{
return scheme_void;
}
-/* (get-win-width [window]) */
+/*
+ * (get-win-width [window])
+ */
static Scheme_Object *
get_window_width(void *data, int argc, Scheme_Object **argv)
{
return scheme_make_integer(win->win->w_width);
}
-/* (set-win-width {width} [window]) */
+/*
+ * (set-win-width {width} [window])
+ */
static Scheme_Object *
set_window_width(void *data, int argc, Scheme_Object **argv)
{
return scheme_void;
}
-/* (get-cursor [window]) -> (line . col) */
+/*
+ * (get-cursor [window]) -> (line . col)
+ */
static Scheme_Object *
get_cursor(void *data, int argc, Scheme_Object **argv)
{
scheme_make_integer_value((long)pos.col + 1));
}
-/* (set-cursor (line . col) [window]) */
+/*
+ * (set-cursor (line . col) [window])
+ */
static Scheme_Object *
set_cursor(void *data, int argc, Scheme_Object **argv)
{
col = SCHEME_INT_VAL(SCHEME_CDR(argv[0])) - 1;
check_line_range(lnum, win->win->w_buffer);
- /* don't know how to catch invalid column value */
+ // don't know how to catch invalid column value
win->win->w_cursor.lnum = lnum;
win->win->w_cursor.col = col;
*===========================================================================
*/
-/* (open-buff {filename}) */
+/*
+ * (open-buff {filename})
+ */
static Scheme_Object *
mzscheme_open_buffer(void *data, int argc, Scheme_Object **argv)
{
#ifdef HAVE_SANDBOX
sandbox_check();
#endif
- /* TODO make open existing file */
+ // TODO make open existing file
num = buflist_add(BYTE_STRING_VALUE(fname), BLN_LISTED | BLN_CURBUF);
if (num == 0)
return buf;
}
-/* (get-buff-by-num {buffernum}) */
+/*
+ * (get-buff-by-num {buffernum})
+ */
static Scheme_Object *
get_buffer_by_num(void *data, int argc, Scheme_Object **argv)
{
return scheme_false;
}
-/* (get-buff-by-name {buffername}) */
+/*
+ * (get-buff-by-name {buffername})
+ */
static Scheme_Object *
get_buffer_by_name(void *data, int argc, Scheme_Object **argv)
{
FOR_ALL_BUFFERS(buf)
{
if (buf->b_ffname == NULL || buf->b_sfname == NULL)
- /* empty string */
+ // empty string
{
if (BYTE_STRING_VALUE(fname)[0] == NUL)
buffer = buffer_new(buf);
else if (!fnamecmp(buf->b_ffname, BYTE_STRING_VALUE(fname))
|| !fnamecmp(buf->b_sfname, BYTE_STRING_VALUE(fname)))
{
- /* either short or long filename matches */
+ // either short or long filename matches
buffer = buffer_new(buf);
}
}
return buffer;
}
-/* (get-next-buff [buffer]) */
+/*
+ * (get-next-buff [buffer])
+ */
static Scheme_Object *
get_next_buffer(void *data, int argc, Scheme_Object **argv)
{
return buffer_new(buf->b_next);
}
-/* (get-prev-buff [buffer]) */
+/*
+ * (get-prev-buff [buffer])
+ */
static Scheme_Object *
get_prev_buffer(void *data, int argc, Scheme_Object **argv)
{
return buffer_new(buf->b_prev);
}
-/* (get-buff-num [buffer]) */
+/*
+ * (get-buff-num [buffer])
+ */
static Scheme_Object *
get_buffer_num(void *data, int argc, Scheme_Object **argv)
{
return scheme_make_integer(buf->buf->b_fnum);
}
-/* (buff-count) */
+/*
+ * (buff-count)
+ */
static Scheme_Object *
get_buffer_count(void *data UNUSED, int argc UNUSED, Scheme_Object **argv UNUSED)
{
return scheme_make_integer(n);
}
-/* (get-buff-name [buffer]) */
+/*
+ * (get-buff-name [buffer])
+ */
static Scheme_Object *
get_buffer_name(void *data, int argc, Scheme_Object **argv)
{
return scheme_make_byte_string((char *)buf->buf->b_ffname);
}
-/* (curr-buff) */
+/*
+ * (curr-buff)
+ */
static Scheme_Object *
get_curr_buffer(void *data UNUSED, int argc UNUSED, Scheme_Object **argv UNUSED)
{
MZ_GC_DECL_REG(1);
MZ_GC_VAR_IN_REG(0, self);
- /* We need to handle deletion of buffers underneath us.
- * If we add a "b_mzscheme_ref" field to the buf_T structure,
- * then we can get at it in buf_freeall() in vim.
- */
+ // We need to handle deletion of buffers underneath us.
+ // If we add a "b_mzscheme_ref" field to the buf_T structure,
+ // then we can get at it in buf_freeall() in vim.
if (buf->b_mzscheme_ref)
return (Scheme_Object *)BUFFER_REF(buf);
self = scheme_malloc_fail_ok(scheme_malloc_tagged, sizeof(vim_mz_buffer));
vim_memset(self, 0, sizeof(vim_mz_buffer));
#ifndef MZ_PRECISE_GC
- scheme_dont_gc_ptr(self); /* because buf isn't visible to GC */
+ scheme_dont_gc_ptr(self); // because buf isn't visible to GC
#else
buf->b_mzscheme_ref = scheme_malloc_immobile_box(NULL);
#endif
(char *)ml_get_buf(buf->buf, (linenr_T)(lo+i), FALSE));
raise_if_error();
- /* Set the list item */
+ // Set the list item
list = scheme_make_pair(str, list);
MZ_GC_CHECK();
}
static Scheme_Object *
set_buffer_line(void *data, int argc, Scheme_Object **argv)
{
- /* First of all, we check the value of the supplied MzScheme object.
- * There are three cases:
- * 1. #f - this is a deletion.
- * 2. A string - this is a replacement.
- * 3. Anything else - this is an error.
- */
+ // First of all, we check the value of the supplied MzScheme object.
+ // There are three cases:
+ // 1. #f - this is a deletion.
+ // 2. A string - this is a replacement.
+ // 3. Anything else - this is an error.
Vim_Prim *prim = (Vim_Prim *)data;
vim_mz_buffer *buf;
Scheme_Object *line = NULL;
}
else
{
- /* Otherwise it's a line */
+ // Otherwise it's a line
buf_T *savebuf = curbuf;
save = string_to_line(line);
curbuf = savebuf;
- /* Check that the cursor is not beyond the end of the line now. */
+ // Check that the cursor is not beyond the end of the line now.
if (buf->buf == curwin->w_buffer)
check_cursor_col();
static Scheme_Object *
set_buffer_line_list(void *data, int argc, Scheme_Object **argv)
{
- /* First of all, we check the type of the supplied MzScheme object.
- * There are three cases:
- * 1. #f - this is a deletion.
- * 2. A list - this is a replacement.
- * 3. Anything else - this is an error.
- */
+ // First of all, we check the type of the supplied MzScheme object.
+ // There are three cases:
+ // 1. #f - this is a deletion.
+ // 2. A list - this is a replacement.
+ // 3. Anything else - this is an error.
Vim_Prim *prim = (Vim_Prim *)data;
vim_mz_buffer *buf = NULL;
Scheme_Object *line_list = NULL;
line_list = argv[2];
buf = get_buffer_arg(prim->name, 3, argc, argv);
old_len = hi - lo;
- if (old_len < 0) /* process inverse values wisely */
+ if (old_len < 0) // process inverse values wisely
{
i = lo;
lo = hi;
}
extra = 0;
- check_line_range(lo, buf->buf); /* inclusive */
- check_line_range(hi - 1, buf->buf); /* exclusive */
+ check_line_range(lo, buf->buf); // inclusive
+ check_line_range(hi - 1, buf->buf); // exclusive
if (SCHEME_FALSEP(line_list) || SCHEME_NULLP(line_list))
{
{
buf_T *savebuf = curbuf;
- /* List */
+ // List
new_len = scheme_proper_list_length(line_list);
MZ_GC_CHECK();
- if (new_len < 0) /* improper or cyclic list */
+ if (new_len < 0) // improper or cyclic list
scheme_wrong_type(prim->name, "proper list",
2, argc, argv);
else
scheme_wrong_type(prim->name, "string or list", 1, argc, argv);
buf = get_buffer_arg(prim->name, 2, argc, argv);
- if (n != 0) /* 0 can be used in insert */
+ if (n != 0) // 0 can be used in insert
check_line_range(n, buf->buf);
if (SCHEME_STRINGP(list))
{
return scheme_void;
}
- /* List */
+ // List
size = scheme_proper_list_length(list);
MZ_GC_CHECK();
- if (size < 0) /* improper or cyclic list */
+ if (size < 0) // improper or cyclic list
scheme_wrong_type(prim->name, "proper list",
2, argc, argv);
else
/*
* Predicates
*/
-/* (buff? obj) */
+/*
+ * (buff? obj)
+ */
static Scheme_Object *
vim_bufferp(void *data UNUSED, int argc UNUSED, Scheme_Object **argv)
{
return scheme_false;
}
-/* (win? obj) */
+/*
+ * (win? obj)
+ */
static Scheme_Object *
vim_windowp(void *data UNUSED, int argc UNUSED, Scheme_Object **argv)
{
return scheme_false;
}
-/* (buff-valid? obj) */
+/*
+ * (buff-valid? obj)
+ */
static Scheme_Object *
vim_buffer_validp(void *data UNUSED, int argc UNUSED, Scheme_Object **argv)
{
return scheme_false;
}
-/* (win-valid? obj) */
+/*
+ * (win-valid? obj)
+ */
static Scheme_Object *
vim_window_validp(void *data UNUSED, int argc UNUSED, Scheme_Object **argv)
{
scheme_str = scheme_display_to_string(obj, &len);
- /* Error checking: String must not contain newlines, as we
- * are replacing a single line, and we must replace it with
- * a single line.
- */
+ // Error checking: String must not contain newlines, as we
+ // are replacing a single line, and we must replace it with
+ // a single line.
if (memchr(scheme_str, '\n', len))
scheme_signal_error(_("string cannot contain newlines"));
vim_str = alloc(len + 1);
- /* Create a copy of the string, with internal nulls replaced by
- * newline characters, as is the vim convention.
- */
+ // Create a copy of the string, with internal nulls replaced by
+ // newline characters, as is the vim convention.
for (i = 0; i < len; ++i)
{
if (scheme_str[i] == '\0')
vim_to_mzscheme(typval_T *vim_value)
{
Scheme_Object *result = NULL;
- /* hash table to store visited values to avoid infinite loops */
+ // hash table to store visited values to avoid infinite loops
Scheme_Hash_Table *visited = NULL;
MZ_GC_DECL_REG(2);
MZ_GC_VAR_IN_REG(1, visited);
MZ_GC_REG();
- /* Avoid infinite recursion */
+ // Avoid infinite recursion
if (depth > 100)
{
MZ_GC_UNREG();
return scheme_void;
}
- /* Check if we run into a recursive loop. The item must be in visited
- * then and we can use it again.
- */
+ // Check if we run into a recursive loop. The item must be in visited
+ // then and we can use it again.
result = scheme_hash_get(visited, (Scheme_Object *)vim_value);
MZ_GC_CHECK();
- if (result != NULL) /* found, do nothing */
+ if (result != NULL) // found, do nothing
new_value = FALSE;
else if (vim_value->v_type == VAR_STRING)
{
MZ_GC_VAR_IN_REG(0, funcname);
MZ_GC_REG();
- /* FIXME: func_ref() and func_unref() are needed. */
+ // FIXME: func_ref() and func_unref() are needed.
funcname = scheme_make_byte_string((char *)vim_value->vval.v_string);
MZ_GC_CHECK();
result = scheme_make_closed_prim_w_arity(vim_funcref, funcname,
MZ_GC_VAR_IN_REG(0, funcname);
MZ_GC_REG();
- /* FIXME: func_ref() and func_unref() are needed. */
- /* TODO: Support pt_dict and pt_argv. */
+ // FIXME: func_ref() and func_unref() are needed.
+ // TODO: Support pt_dict and pt_argv.
funcname = scheme_make_byte_string(
(char *)partial_name(vim_value->vval.v_partial));
MZ_GC_CHECK();
status = mzscheme_to_vim_impl(obj, tv, 1, visited);
for (i = 0; i < visited->size; ++i)
{
- /* free up remembered objects */
+ // free up remembered objects
if (visited->vals[i] != NULL)
free_tv((typval_T *)visited->vals[i]);
}
MZ_GC_REG();
MZ_GC_CHECK();
- if (depth > 100) /* limit the deepest recursion level */
+ if (depth > 100) // limit the deepest recursion level
{
tv->v_type = VAR_NUMBER;
tv->vval.v_number = 0;
int i;
Scheme_Object *curr = NULL;
Scheme_Object *cval = NULL;
- /* temporary var to hold current element of vectors and pairs */
+ // temporary var to hold current element of vectors and pairs
typval_T *v;
MZ_GC_DECL_REG(2);
status = FAIL;
else
{
- /* add the value in advance to allow handling of self-referential
- * data structures */
+ // add the value in advance to allow handling of self-referential
+ // data structures
typval_T *visited_tv = ALLOC_ONE(typval_T);
copy_tv(tv, visited_tv);
scheme_hash_set(visited, obj, (Scheme_Object *)visited_tv);
if (status == FAIL)
break;
}
- /* improper list not terminated with null
- * need to handle the last element */
+ // improper list not terminated with null
+ // need to handle the last element
if (status == OK && !SCHEME_NULLP(curr))
{
status = mzscheme_to_vim_impl(cval, v, depth + 1, visited);
}
}
}
- /* nothing to do for scheme_null */
+ // nothing to do for scheme_null
vim_free(v);
}
MZ_GC_UNREG();
{
if (((Scheme_Hash_Table *) obj)->vals[i] != NULL)
{
- /* generate item for `display'ed Scheme key */
+ // generate item for `display'ed Scheme key
dictitem_T *item = dictitem_alloc((char_u *)string_to_line(
((Scheme_Hash_Table *) obj)->keys[i]));
- /* convert Scheme val to Vim and add it to the dict */
+ // convert Scheme val to Vim and add it to the dict
if (mzscheme_to_vim_impl(((Scheme_Hash_Table *) obj)->vals[i],
&item->di_tv, depth + 1, visited) == FAIL
|| dict_add(dict, item) == FAIL)
}
else
{
- /* `display' any other value to string */
+ // `display' any other value to string
tv->v_type = VAR_STRING;
tv->vval.v_string = (char_u *)string_to_line(obj);
}
return status;
}
-/* Scheme prim procedure wrapping Vim funcref */
+/*
+ * Scheme prim procedure wrapping Vim funcref
+ */
static Scheme_Object *
vim_funcref(void *name, int argc, Scheme_Object **argv)
{
raise_vim_exn(NULL);
}
-/* get buffer:
+/*
+ * get buffer:
* either current
* or passed as argv[argnum] with checks
*/
return b;
}
-/* get window:
+/*
+ * get window:
* either current
* or passed as argv[argnum] with checks
*/
return w;
}
-/* get valid Vim buffer from Scheme_Object* */
+/*
+ * get valid Vim buffer from Scheme_Object*
+ */
buf_T *get_valid_buffer(void *obj)
{
buf_T *buf = ((vim_mz_buffer *)obj)->buf;
return buf;
}
-/* get valid Vim window from Scheme_Object* */
+/*
+ * get valid Vim window from Scheme_Object*
+ */
win_T *get_valid_window(void *obj)
{
win_T *win = ((vim_mz_window *)obj)->win;
{
if (curwin->w_cursor.lnum >= lo)
{
- /* Adjust the cursor position if it's in/after the changed
- * lines. */
+ // Adjust the cursor position if it's in/after the changed
+ // lines.
if (curwin->w_cursor.lnum >= hi)
{
curwin->w_cursor.lnum += extra;
{vim_window_validp, "win-valid?", 1, 1}
};
-/* return MzScheme wrapper for curbuf */
+/*
+ * return MzScheme wrapper for curbuf
+ */
static vim_mz_buffer *
get_vim_curr_buffer(void)
{
return BUFFER_REF(curbuf);
}
-/* return MzScheme wrapper for curwin */
+/*
+ * return MzScheme wrapper for curwin
+ */
static vim_mz_window *
get_vim_curr_window(void)
{
MZ_GC_CHECK();
mod = scheme_primitive_module(vimext_symbol, environment);
MZ_GC_CHECK();
- /* all prims made closed so they can access their own names */
+ // all prims made closed so they can access their own names
for (i = 0; i < (int)(sizeof(prims)/sizeof(prims[0])); i++)
{
Vim_Prim *prim = prims + i;
raise_vim_exn(_("not allowed in the Vim sandbox"));
}
-/* security guards to force Vim's sandbox restrictions on MzScheme level */
+/*
+ * security guards to force Vim's sandbox restrictions on MzScheme level
+ */
static Scheme_Object *
sandbox_file_guard(int argc UNUSED, Scheme_Object **argv)
{
* if_perlsfio.c: Special I/O functions for Perl interface.
*/
-#define _memory_h /* avoid memset redeclaration */
-#define IN_PERL_FILE /* don't include if_perl.pro from prot.h */
+#define _memory_h // avoid memset redeclaration
+#define IN_PERL_FILE // don't include if_perl.pro from prot.h
#include "vim.h"
#if defined(USE_SFIO) || defined(PROTO)
-#ifndef USE_SFIO /* just generating prototypes */
+#ifndef USE_SFIO // just generating prototypes
# define Sfio_t int
# define Sfdisc_t int
#endif
static int
sfvimwrite(
- Sfio_t *f, /* stream involved */
- char *buf, /* buffer to read from */
- int n, /* number of bytes to write */
- Sfdisc_t *disc) /* discipline */
+ Sfio_t *f, // stream involved
+ char *buf, // buffer to read from
+ int n, // number of bytes to write
+ Sfdisc_t *disc) // discipline
{
char_u *str;
return disc;
}
-#endif /* USE_SFIO */
+#endif // USE_SFIO
#include <limits.h>
-/* uncomment this if used with the debug version of python.
- * Checked on 2.7.4. */
-/* #define Py_DEBUG */
-/* Note: most of time you can add -DPy_DEBUG to CFLAGS in place of uncommenting
- */
-/* uncomment this if used with the debug version of python, but without its
- * allocator */
-/* #define Py_DEBUG_NO_PYMALLOC */
-
-/* Python.h defines _POSIX_THREADS itself (if needed) */
+// uncomment this if used with the debug version of python.
+// Checked on 2.7.4.
+// #define Py_DEBUG
+// Note: most of time you can add -DPy_DEBUG to CFLAGS in place of uncommenting
+// uncomment this if used with the debug version of python, but without its
+// allocator
+// #define Py_DEBUG_NO_PYMALLOC
+
+// Python.h defines _POSIX_THREADS itself (if needed)
#ifdef _POSIX_THREADS
# undef _POSIX_THREADS
#endif
# undef HAVE_PUTENV
#endif
#ifdef HAVE_STDARG_H
-# undef HAVE_STDARG_H /* Python's config.h defines it as well. */
+# undef HAVE_STDARG_H // Python's config.h defines it as well.
#endif
#ifdef _POSIX_C_SOURCE
-# undef _POSIX_C_SOURCE /* pyconfig.h defines it as well. */
+# undef _POSIX_C_SOURCE // pyconfig.h defines it as well.
#endif
#ifdef _XOPEN_SOURCE
-# undef _XOPEN_SOURCE /* pyconfig.h defines it as well. */
+# undef _XOPEN_SOURCE // pyconfig.h defines it as well.
#endif
#define PY_SSIZE_T_CLEAN
# undef PY_SSIZE_T_CLEAN
#endif
-#undef main /* Defined in python.h - aargh */
-#undef HAVE_FCNTL_H /* Clash with os_win32.h */
+#undef main // Defined in python.h - aargh
+#undef HAVE_FCNTL_H // Clash with os_win32.h
// Perhaps leave this out for Python 2.6, which supports bytes?
#define PyBytes_FromString PyString_FromString
#define PyBytes_FromStringAndSize PyString_FromStringAndSize
#if !defined(FEAT_PYTHON) && defined(PROTO)
-/* Use this to be able to generate prototypes without python being used. */
+// Use this to be able to generate prototypes without python being used.
# define PyObject Py_ssize_t
# define PyThreadState Py_ssize_t
# define PyTypeObject Py_ssize_t
#endif
#define Py_bytes_fmt "s"
-/* Parser flags */
+// Parser flags
#define single_input 256
#define file_input 257
#define eval_input 258
#if defined(PY_VERSION_HEX) && PY_VERSION_HEX >= 0x020300F0
- /* Python 2.3: can invoke ":python" recursively. */
+ // Python 2.3: can invoke ":python" recursively.
# define PY_CAN_RECURSE
#endif
#if defined(DYNAMIC_PYTHON) || defined(PROTO)
# ifndef DYNAMIC_PYTHON
-# define HINSTANCE long_u /* for generating prototypes */
+# define HINSTANCE long_u // for generating prototypes
# endif
# ifndef MSWIN
# define symbol_from_dll GetProcAddress
# endif
-/* This makes if_python.c compile without warnings against Python 2.5
- * on Win32 and Win64. */
+// This makes if_python.c compile without warnings against Python 2.5
+// on Win32 and Win64.
# undef PyRun_SimpleString
# undef PyRun_String
# undef PyArg_Parse
static int* dll_Py_NoSiteFlag;
# endif
-static HINSTANCE hinstPython = 0; /* Instance of python.dll */
+static HINSTANCE hinstPython = 0; // Instance of python.dll
-/* Imported exception objects */
+// Imported exception objects
static PyObject *imp_PyExc_AttributeError;
static PyObject *imp_PyExc_IndexError;
static PyObject *imp_PyExc_KeyError;
(PYTHON_PROC*)&py_PyUnicode_AsEncodedString;
# if !(defined(PY_NO_RTLD_GLOBAL) && defined(PY3_NO_RTLD_GLOBAL)) && defined(UNIX) && defined(FEAT_PYTHON3)
- /* Can't have Python and Python3 loaded at the same time.
- * It cause a crash, because RTLD_GLOBAL is needed for
- * standard C extension libraries of one or both python versions. */
+ // Can't have Python and Python3 loaded at the same time.
+ // It cause a crash, because RTLD_GLOBAL is needed for
+ // standard C extension libraries of one or both python versions.
if (python3_loaded())
{
if (verbose)
}
}
- /* Load unicode functions separately as only the ucs2 or the ucs4 functions
- * will be present in the library. */
+ // Load unicode functions separately as only the ucs2 or the ucs4 functions
+ // will be present in the library.
*ucs_as_encoded_string = symbol_from_dll(hinstPython,
"PyUnicodeUCS2_AsEncodedString");
if (*ucs_as_encoded_string == NULL)
Py_XINCREF(imp_PyExc_OverflowError);
Py_XDECREF(exmod);
}
-#endif /* DYNAMIC_PYTHON */
+#endif // DYNAMIC_PYTHON
static int initialised = 0;
#define PYINITIALISED initialised
#include "if_py_both.h"
-/******************************************************
- * Internal function prototypes.
- */
+///////////////////////////////////////////////////////
+// Internal function prototypes.
static int PythonMod_Init(void);
-/******************************************************
- * 1. Python interpreter main program.
- */
+///////////////////////////////////////////////////////
+// 1. Python interpreter main program.
-#if PYTHON_API_VERSION < 1007 /* Python 1.4 */
+#if PYTHON_API_VERSION < 1007 // Python 1.4
typedef PyObject PyThreadState;
#endif
{
static int recurse = 0;
- /* If a crash occurs while doing this, don't try again. */
+ // If a crash occurs while doing this, don't try again.
if (recurse != 0)
return;
# ifdef PY_CAN_RECURSE
PyGILState_Ensure();
# else
- Python_RestoreThread(); /* enter python */
+ Python_RestoreThread(); // enter python
# endif
Py_Finalize();
}
# ifdef PY_CAN_RECURSE
PyGILState_Ensure();
# else
- Python_RestoreThread(); /* enter python */
+ Python_RestoreThread(); // enter python
# endif
Py_Finalize();
}
if (*p_pyhome != NUL)
{
- /* The string must not change later, make a copy in static memory. */
+ // The string must not change later, make a copy in static memory.
py_home_buf = (char *)vim_strsave(p_pyhome);
if (py_home_buf != NULL)
Py_SetPythonHome(py_home_buf);
init_structs();
#if defined(PY_VERSION_HEX) && PY_VERSION_HEX >= 0x02070000
- /* Disable implicit 'import site', because it may cause Vim to exit
- * when it can't be found. */
+ // Disable implicit 'import site', because it may cause Vim to exit
+ // when it can't be found.
Py_NoSiteFlag++;
#endif
Py_Initialize();
#if defined(PY_VERSION_HEX) && PY_VERSION_HEX >= 0x02070000
- /* 'import site' explicitly. */
+ // 'import site' explicitly.
site = PyImport_ImportModule("site");
if (site == NULL)
{
Py_DECREF(site);
#endif
- /* Initialise threads, and below save the state using
- * PyEval_SaveThread. Without the call to PyEval_SaveThread, thread
- * specific state (such as the system trace hook), will be lost
- * between invocations of Python code. */
+ // Initialise threads, and below save the state using
+ // PyEval_SaveThread. Without the call to PyEval_SaveThread, thread
+ // specific state (such as the system trace hook), will be lost
+ // between invocations of Python code.
PyEval_InitThreads();
#ifdef DYNAMIC_PYTHON
get_exceptions();
globals = PyModule_GetDict(PyImport_AddModule("__main__"));
- /* Remove the element from sys.path that was added because of our
- * argv[0] value in PythonMod_Init(). Previously we used an empty
- * string, but depending on the OS we then get an empty entry or
- * the current directory in sys.path. */
+ // Remove the element from sys.path that was added because of our
+ // argv[0] value in PythonMod_Init(). Previously we used an empty
+ // string, but depending on the OS we then get an empty entry or
+ // the current directory in sys.path.
PyRun_SimpleString("import sys; sys.path = filter(lambda x: x != '/must>not&exist', sys.path)");
- /* lock is created and acquired in PyEval_InitThreads() and thread
- * state is created in Py_Initialize()
- * there _PyGILState_NoteThreadState() also sets gilcounter to 1
- * (python must have threads enabled!)
- * so the following does both: unlock GIL and save thread state in TLS
- * without deleting thread state
- */
+ // lock is created and acquired in PyEval_InitThreads() and thread
+ // state is created in Py_Initialize()
+ // there _PyGILState_NoteThreadState() also sets gilcounter to 1
+ // (python must have threads enabled!)
+ // so the following does both: unlock GIL and save thread state in TLS
+ // without deleting thread state
#ifndef PY_CAN_RECURSE
saved_python_thread =
#endif
return 0;
fail:
- /* We call PythonIO_Flush() here to print any Python errors.
- * This is OK, as it is possible to call this function even
- * if PythonIO_Init_io() has not completed successfully (it will
- * not do anything in this case).
- */
+ // We call PythonIO_Flush() here to print any Python errors.
+ // This is OK, as it is possible to call this function even
+ // if PythonIO_Init_io() has not completed successfully (it will
+ // not do anything in this case).
PythonIO_Flush();
return -1;
}
init_range(arg);
- Python_Release_Vim(); /* leave vim */
+ Python_Release_Vim(); // leave Vim
#if defined(HAVE_LOCALE_H) || defined(X_LOCALE)
- /* Python only works properly when the LC_NUMERIC locale is "C". */
+ // Python only works properly when the LC_NUMERIC locale is "C".
saved_locale = setlocale(LC_NUMERIC, NULL);
if (saved_locale == NULL || STRCMP(saved_locale, "C") == 0)
saved_locale = NULL;
else
{
- /* Need to make a copy, value may change when setting new locale. */
+ // Need to make a copy, value may change when setting new locale.
saved_locale = (char *) PY_STRSAVE(saved_locale);
(void)setlocale(LC_NUMERIC, "C");
}
#ifdef PY_CAN_RECURSE
pygilstate = PyGILState_Ensure();
#else
- Python_RestoreThread(); /* enter python */
+ Python_RestoreThread(); // enter python
#endif
run((char *) cmd, arg
#ifdef PY_CAN_RECURSE
PyGILState_Release(pygilstate);
#else
- Python_SaveThread(); /* leave python */
+ Python_SaveThread(); // leave python
#endif
#if defined(HAVE_LOCALE_H) || defined(X_LOCALE)
}
#endif
- Python_Lock_Vim(); /* enter vim */
+ Python_Lock_Vim(); // enter vim
PythonIO_Flush();
theend:
if (p_pyx == 0)
p_pyx = 2;
- /* Have to do it like this. PyRun_SimpleFile requires you to pass a
- * stdio file pointer, but Vim and the Python DLL are compiled with
- * different options under Windows, meaning that stdio pointers aren't
- * compatible between the two. Yuk.
- *
- * Put the string "execfile('file')" into buffer. But, we need to
- * escape any backslashes or single quotes in the file name, so that
- * Python won't mangle the file name.
- */
+ // Have to do it like this. PyRun_SimpleFile requires you to pass a
+ // stdio file pointer, but Vim and the Python DLL are compiled with
+ // different options under Windows, meaning that stdio pointers aren't
+ // compatible between the two. Yuk.
+ //
+ // Put the string "execfile('file')" into buffer. But, we need to
+ // escape any backslashes or single quotes in the file name, so that
+ // Python won't mangle the file name.
strcpy(buffer, "execfile('");
- p = buffer + 10; /* size of "execfile('" */
+ p = buffer + 10; // size of "execfile('"
while (*file && p < buffer + (BUFFER_SIZE - 3))
{
*p++ = *file++;
}
- /* If we didn't finish the file name, we hit a buffer overflow */
+ // If we didn't finish the file name, we hit a buffer overflow
if (*file != '\0')
return;
- /* Put in the terminating "')" and a null */
+ // Put in the terminating "')" and a null
*p++ = '\'';
*p++ = ')';
*p++ = '\0';
- /* Execute the file */
+ // Execute the file
DoPyCommand(buffer,
(rangeinitializer) init_range_cmd,
(runner) run_cmd,
(void *)eap);
}
-/******************************************************
- * 2. Python output stream: writes output via [e]msg().
- */
+///////////////////////////////////////////////////////
+// 2. Python output stream: writes output via [e]msg().
-/* Implementation functions
- */
+// Implementation functions
static PyObject *
OutputGetattr(PyObject *self, char *name)
return Py_FindMethod(OutputMethods, self, name);
}
-/******************************************************
- * 3. Implementation of the Vim module for Python
- */
+///////////////////////////////////////////////////////
+// 3. Implementation of the Vim module for Python
-/* Window type - Implementation functions
- * --------------------------------------
- */
+// Window type - Implementation functions
+// --------------------------------------
#define WindowType_Check(obj) ((obj)->ob_type == &WindowType)
-/* Buffer type - Implementation functions
- * --------------------------------------
- */
+// Buffer type - Implementation functions
+// --------------------------------------
#define BufferType_Check(obj) ((obj)->ob_type == &BufferType)
static PyInt BufferAssItem(PyObject *, PyInt, PyObject *);
static PyInt BufferAssSlice(PyObject *, PyInt, PyInt, PyObject *);
-/* Line range type - Implementation functions
- * --------------------------------------
- */
+// Line range type - Implementation functions
+// --------------------------------------
#define RangeType_Check(obj) ((obj)->ob_type == &RangeType)
static PyInt RangeAssItem(PyObject *, PyInt, PyObject *);
static PyInt RangeAssSlice(PyObject *, PyInt, PyInt, PyObject *);
-/* Current objects type - Implementation functions
- * -----------------------------------------------
- */
+// Current objects type - Implementation functions
+// -----------------------------------------------
static PySequenceMethods BufferAsSeq = {
- (PyInquiry) BufferLength, /* sq_length, len(x) */
- (binaryfunc) 0, /* BufferConcat, sq_concat, x+y */
- (PyIntArgFunc) 0, /* BufferRepeat, sq_repeat, x*n */
- (PyIntArgFunc) BufferItem, /* sq_item, x[i] */
- (PyIntIntArgFunc) BufferSlice, /* sq_slice, x[i:j] */
- (PyIntObjArgProc) BufferAssItem, /* sq_ass_item, x[i]=v */
- (PyIntIntObjArgProc) BufferAssSlice, /* sq_ass_slice, x[i:j]=v */
+ (PyInquiry) BufferLength, // sq_length, len(x)
+ (binaryfunc) 0, // BufferConcat, sq_concat, x+y
+ (PyIntArgFunc) 0, // BufferRepeat, sq_repeat, x*n
+ (PyIntArgFunc) BufferItem, // sq_item, x[i]
+ (PyIntIntArgFunc) BufferSlice, // sq_slice, x[i:j]
+ (PyIntObjArgProc) BufferAssItem, // sq_ass_item, x[i]=v
+ (PyIntIntObjArgProc) BufferAssSlice, // sq_ass_slice, x[i:j]=v
(objobjproc) 0,
(binaryfunc) 0,
0,
};
-/* Buffer object - Implementation
- */
+// Buffer object - Implementation
static PyObject *
BufferGetattr(PyObject *self, char *name)
return Py_FindMethod(BufferMethods, self, name);
}
-/******************/
+//////////////////
static PyInt
BufferAssItem(PyObject *self, PyInt n, PyObject *val)
}
static PySequenceMethods RangeAsSeq = {
- (PyInquiry) RangeLength, /* sq_length, len(x) */
- (binaryfunc) 0, /* RangeConcat, */ /* sq_concat, x+y */
- (PyIntArgFunc) 0, /* RangeRepeat, */ /* sq_repeat, x*n */
- (PyIntArgFunc) RangeItem, /* sq_item, x[i] */
- (PyIntIntArgFunc) RangeSlice, /* sq_slice, x[i:j] */
- (PyIntObjArgProc) RangeAssItem, /* sq_ass_item, x[i]=v */
- (PyIntIntObjArgProc) RangeAssSlice, /* sq_ass_slice, x[i:j]=v */
+ (PyInquiry) RangeLength, // sq_length, len(x)
+ (binaryfunc) 0, /* RangeConcat, */ // sq_concat, x+y
+ (PyIntArgFunc) 0, /* RangeRepeat, */ // sq_repeat, x*n
+ (PyIntArgFunc) RangeItem, // sq_item, x[i]
+ (PyIntIntArgFunc) RangeSlice, // sq_slice, x[i:j]
+ (PyIntObjArgProc) RangeAssItem, // sq_ass_item, x[i]=v
+ (PyIntIntObjArgProc) RangeAssSlice, // sq_ass_slice, x[i:j]=v
(objobjproc) 0,
#if PY_MAJOR_VERSION >= 2
(binaryfunc) 0,
#endif
};
-/* Line range object - Implementation
- */
+// Line range object - Implementation
static PyObject *
RangeGetattr(PyObject *self, char *name)
return Py_FindMethod(RangeMethods, self, name);
}
-/****************/
+////////////////
static PyInt
RangeAssItem(PyObject *self, PyInt n, PyObject *val)
&((RangeObject *)(self))->end);
}
-/* TabPage object - Implementation
- */
+// TabPage object - Implementation
static PyObject *
TabPageGetattr(PyObject *self, char *name)
return Py_FindMethod(TabPageMethods, self, name);
}
-/* Window object - Implementation
- */
+// Window object - Implementation
static PyObject *
WindowGetattr(PyObject *self, char *name)
return Py_FindMethod(WindowMethods, self, name);
}
-/* Tab page list object - Definitions
- */
+// Tab page list object - Definitions
static PySequenceMethods TabListAsSeq = {
- (PyInquiry) TabListLength, /* sq_length, len(x) */
- (binaryfunc) 0, /* sq_concat, x+y */
- (PyIntArgFunc) 0, /* sq_repeat, x*n */
- (PyIntArgFunc) TabListItem, /* sq_item, x[i] */
- (PyIntIntArgFunc) 0, /* sq_slice, x[i:j] */
- (PyIntObjArgProc) 0, /* sq_ass_item, x[i]=v */
- (PyIntIntObjArgProc) 0, /* sq_ass_slice, x[i:j]=v */
+ (PyInquiry) TabListLength, // sq_length, len(x)
+ (binaryfunc) 0, // sq_concat, x+y
+ (PyIntArgFunc) 0, // sq_repeat, x*n
+ (PyIntArgFunc) TabListItem, // sq_item, x[i]
+ (PyIntIntArgFunc) 0, // sq_slice, x[i:j]
+ (PyIntObjArgProc) 0, // sq_ass_item, x[i]=v
+ (PyIntIntObjArgProc) 0, // sq_ass_slice, x[i:j]=v
(objobjproc) 0,
#if PY_MAJOR_VERSION >= 2
(binaryfunc) 0,
#endif
};
-/* Window list object - Definitions
- */
+// Window list object - Definitions
static PySequenceMethods WinListAsSeq = {
- (PyInquiry) WinListLength, /* sq_length, len(x) */
- (binaryfunc) 0, /* sq_concat, x+y */
- (PyIntArgFunc) 0, /* sq_repeat, x*n */
- (PyIntArgFunc) WinListItem, /* sq_item, x[i] */
- (PyIntIntArgFunc) 0, /* sq_slice, x[i:j] */
- (PyIntObjArgProc) 0, /* sq_ass_item, x[i]=v */
- (PyIntIntObjArgProc) 0, /* sq_ass_slice, x[i:j]=v */
+ (PyInquiry) WinListLength, // sq_length, len(x)
+ (binaryfunc) 0, // sq_concat, x+y
+ (PyIntArgFunc) 0, // sq_repeat, x*n
+ (PyIntArgFunc) WinListItem, // sq_item, x[i]
+ (PyIntIntArgFunc) 0, // sq_slice, x[i:j]
+ (PyIntObjArgProc) 0, // sq_ass_item, x[i]=v
+ (PyIntIntObjArgProc) 0, // sq_ass_slice, x[i:j]=v
(objobjproc) 0,
#if PY_MAJOR_VERSION >= 2
(binaryfunc) 0,
#endif
};
-/* External interface
- */
+// External interface
void
python_buffer_free(buf_T *buf)
static int
PythonMod_Init(void)
{
- /* The special value is removed from sys.path in Python_Init(). */
+ // The special value is removed from sys.path in Python_Init().
static char *(argv[2]) = {"/must>not&exist/foo", NULL};
if (init_types())
return -1;
- /* Set sys.argv[] to avoid a crash in warn(). */
+ // Set sys.argv[] to avoid a crash in warn().
PySys_SetArgv(1, argv);
vim_module = Py_InitModule4("vim", VimMethods, (char *)NULL,
return 0;
}
-/*************************************************************************
- * 4. Utility functions for handling the interface between Vim and Python.
- */
+//////////////////////////////////////////////////////////////////////////
+// 4. Utility functions for handling the interface between Vim and Python.
-/* Convert a Vim line into a Python string.
- * All internal newlines are replaced by null characters.
- *
- * On errors, the Python exception data is set, and NULL is returned.
- */
+// Convert a Vim line into a Python string.
+// All internal newlines are replaced by null characters.
+//
+// On errors, the Python exception data is set, and NULL is returned.
static PyObject *
LineToString(const char *str)
{
PyInt len = strlen(str);
char *p;
- /* Allocate an Python string object, with uninitialised contents. We
- * must do it this way, so that we can modify the string in place
- * later. See the Python source, Objects/stringobject.c for details.
- */
+ // Allocate an Python string object, with uninitialised contents. We
+ // must do it this way, so that we can modify the string in place
+ // later. See the Python source, Objects/stringobject.c for details.
result = PyString_FromStringAndSize(NULL, len);
if (result == NULL)
return NULL;
}
}
-/* Don't generate a prototype for the next function, it generates an error on
- * newer Python versions. */
+// Don't generate a prototype for the next function, it generates an error on
+// newer Python versions.
#if PYTHON_API_VERSION < 1007 /* Python 1.4 */ && !defined(PROTO)
char *
{
return "vim";
}
-#endif /* Python 1.4 */
+#endif // Python 1.4
int
set_ref_in_python(int copyID)
* Adaptations to support both python3.x and python2.x
*/
-/* uncomment this if used with the debug version of python */
-/* #define Py_DEBUG */
-/* Note: most of time you can add -DPy_DEBUG to CFLAGS in place of uncommenting
- */
-/* uncomment this if used with the debug version of python, but without its
- * allocator */
-/* #define Py_DEBUG_NO_PYMALLOC */
+// uncomment this if used with the debug version of python
+// #define Py_DEBUG
+// Note: most of time you can add -DPy_DEBUG to CFLAGS in place of uncommenting
+// uncomment this if used with the debug version of python, but without its
+// allocator
+// #define Py_DEBUG_NO_PYMALLOC
#include "vim.h"
# undef HAVE_PUTENV
#endif
#ifdef HAVE_STDARG_H
-# undef HAVE_STDARG_H /* Python's config.h defines it as well. */
+# undef HAVE_STDARG_H // Python's config.h defines it as well.
#endif
-#ifdef _POSIX_C_SOURCE /* defined in feature.h */
+#ifdef _POSIX_C_SOURCE // defined in feature.h
# undef _POSIX_C_SOURCE
#endif
#ifdef _XOPEN_SOURCE
-# undef _XOPEN_SOURCE /* pyconfig.h defines it as well. */
+# undef _XOPEN_SOURCE // pyconfig.h defines it as well.
#endif
#define PY_SSIZE_T_CLEAN
#include <Python.h>
-#undef main /* Defined in python.h - aargh */
-#undef HAVE_FCNTL_H /* Clash with os_win32.h */
+#undef main // Defined in python.h - aargh
+#undef HAVE_FCNTL_H // Clash with os_win32.h
-/* The "surrogateescape" error handler is new in Python 3.1 */
+// The "surrogateescape" error handler is new in Python 3.1
#if PY_VERSION_HEX >= 0x030100f0
# define CODEC_ERROR_HANDLER "surrogateescape"
#else
# define CODEC_ERROR_HANDLER NULL
#endif
-/* Python 3 does not support CObjects, always use Capsules */
+// Python 3 does not support CObjects, always use Capsules
#define PY_USE_CAPSULE
#define PyInt Py_ssize_t
static void(*py3_PyObject_GC_UnTrack)(void *);
static int (*py3_PyType_IsSubtype)(PyTypeObject *, PyTypeObject *);
-static HINSTANCE hinstPy3 = 0; /* Instance of python.dll */
+static HINSTANCE hinstPy3 = 0; // Instance of python.dll
-/* Imported exception objects */
+// Imported exception objects
static PyObject *p3imp_PyExc_AttributeError;
static PyObject *p3imp_PyExc_IndexError;
static PyObject *p3imp_PyExc_KeyError;
(PYTHON_PROC *)&py3_PyUnicode_AsEncodedString;
# if !(defined(PY_NO_RTLD_GLOBAL) && defined(PY3_NO_RTLD_GLOBAL)) && defined(UNIX) && defined(FEAT_PYTHON)
- /* Can't have Python and Python3 loaded at the same time.
- * It cause a crash, because RTLD_GLOBAL is needed for
- * standard C extension libraries of one or both python versions. */
+ // Can't have Python and Python3 loaded at the same time.
+ // It cause a crash, because RTLD_GLOBAL is needed for
+ // standard C extension libraries of one or both python versions.
if (python_loaded())
{
if (verbose)
}
}
- /* Load unicode functions separately as only the ucs2 or the ucs4 functions
- * will be present in the library. */
+ // Load unicode functions separately as only the ucs2 or the ucs4 functions
+ // will be present in the library.
# if PY_VERSION_HEX >= 0x030300f0
*ucs_from_string = symbol_from_dll(hinstPy3, "PyUnicode_FromString");
*ucs_decode = symbol_from_dll(hinstPy3, "PyUnicode_Decode");
return py3_runtime_link_init((char *)p_py3dll, verbose) == OK;
}
-/* Load the standard Python exceptions - don't import the symbols from the
+/*
+ * Load the standard Python exceptions - don't import the symbols from the
* DLL, as this can cause errors (importing data symbols is not reliable).
*/
static void
Py_XINCREF(p3imp_PyExc_OverflowError);
Py_XDECREF(exmod);
}
-#endif /* DYNAMIC_PYTHON3 */
+#endif // DYNAMIC_PYTHON3
static int py3initialised = 0;
#define PYINITIALISED py3initialised
#define PY3OBJ_DELETED(obj) (obj->ob_base.ob_refcnt<=0)
-/******************************************************
- * Internal function prototypes.
- */
+///////////////////////////////////////////////////////
+// Internal function prototypes.
static PyObject *Py3Init_vim(void);
-/******************************************************
- * 1. Python interpreter main program.
- */
+///////////////////////////////////////////////////////
+// 1. Python interpreter main program.
void
python3_end(void)
{
static int recurse = 0;
- /* If a crash occurs while doing this, don't try again. */
+ // If a crash occurs while doing this, don't try again.
if (recurse != 0)
return;
#endif
if (Py_IsInitialized())
{
- /* acquire lock before finalizing */
+ // acquire lock before finalizing
PyGILState_Ensure();
Py_Finalize();
{
size_t len = mbstowcs(NULL, (char *)p_py3home, 0) + 1;
- /* The string must not change later, make a copy in static memory. */
+ // The string must not change later, make a copy in static memory.
py_home_buf = ALLOC_MULT(wchar_t, len);
if (py_home_buf != NULL && mbstowcs(
py_home_buf, (char *)p_py3home, len) != (size_t)-1)
Py_Initialize();
- /* Initialise threads, and below save the state using
- * PyEval_SaveThread. Without the call to PyEval_SaveThread, thread
- * specific state (such as the system trace hook), will be lost
- * between invocations of Python code. */
+ // Initialise threads, and below save the state using
+ // PyEval_SaveThread. Without the call to PyEval_SaveThread, thread
+ // specific state (such as the system trace hook), will be lost
+ // between invocations of Python code.
PyEval_InitThreads();
#ifdef DYNAMIC_PYTHON3
get_py3_exceptions();
globals = PyModule_GetDict(PyImport_AddModule("__main__"));
- /* Remove the element from sys.path that was added because of our
- * argv[0] value in Py3Init_vim(). Previously we used an empty
- * string, but depending on the OS we then get an empty entry or
- * the current directory in sys.path.
- * Only after vim has been imported, the element does exist in
- * sys.path.
- */
+ // Remove the element from sys.path that was added because of our
+ // argv[0] value in Py3Init_vim(). Previously we used an empty
+ // string, but depending on the OS we then get an empty entry or
+ // the current directory in sys.path.
+ // Only after vim has been imported, the element does exist in
+ // sys.path.
PyRun_SimpleString("import vim; import sys; sys.path = list(filter(lambda x: not x.endswith('must>not&exist'), sys.path))");
- /* lock is created and acquired in PyEval_InitThreads() and thread
- * state is created in Py_Initialize()
- * there _PyGILState_NoteThreadState() also sets gilcounter to 1
- * (python must have threads enabled!)
- * so the following does both: unlock GIL and save thread state in TLS
- * without deleting thread state
- */
+ // lock is created and acquired in PyEval_InitThreads() and thread
+ // state is created in Py_Initialize()
+ // there _PyGILState_NoteThreadState() also sets gilcounter to 1
+ // (python must have threads enabled!)
+ // so the following does both: unlock GIL and save thread state in TLS
+ // without deleting thread state
PyEval_SaveThread();
py3initialised = 1;
return 0;
fail:
- /* We call PythonIO_Flush() here to print any Python errors.
- * This is OK, as it is possible to call this function even
- * if PythonIO_Init_io() has not completed successfully (it will
- * not do anything in this case).
- */
+ // We call PythonIO_Flush() here to print any Python errors.
+ // This is OK, as it is possible to call this function even
+ // if PythonIO_Init_io() has not completed successfully (it will
+ // not do anything in this case).
PythonIO_Flush();
return -1;
}
init_range(arg);
- Python_Release_Vim(); /* leave vim */
+ Python_Release_Vim(); // leave Vim
#if defined(HAVE_LOCALE_H) || defined(X_LOCALE)
- /* Python only works properly when the LC_NUMERIC locale is "C". */
+ // Python only works properly when the LC_NUMERIC locale is "C".
saved_locale = setlocale(LC_NUMERIC, NULL);
if (saved_locale == NULL || STRCMP(saved_locale, "C") == 0)
saved_locale = NULL;
else
{
- /* Need to make a copy, value may change when setting new locale. */
+ // Need to make a copy, value may change when setting new locale.
saved_locale = (char *)vim_strsave((char_u *)saved_locale);
(void)setlocale(LC_NUMERIC, "C");
}
pygilstate = PyGILState_Ensure();
- /* PyRun_SimpleString expects a UTF-8 string. Wrong encoding may cause
- * SyntaxError (unicode error). */
+ // PyRun_SimpleString expects a UTF-8 string. Wrong encoding may cause
+ // SyntaxError (unicode error).
cmdstr = PyUnicode_Decode(cmd, strlen(cmd),
(char *)ENC_OPT, CODEC_ERROR_HANDLER);
cmdbytes = PyUnicode_AsEncodedString(cmdstr, "utf-8", CODEC_ERROR_HANDLER);
}
#endif
- Python_Lock_Vim(); /* enter vim */
+ Python_Lock_Vim(); // enter Vim
PythonIO_Flush();
theend:
- return; /* keeps lint happy */
+ return; // keeps lint happy
}
/*
if (p_pyx == 0)
p_pyx = 3;
- /* Have to do it like this. PyRun_SimpleFile requires you to pass a
- * stdio file pointer, but Vim and the Python DLL are compiled with
- * different options under Windows, meaning that stdio pointers aren't
- * compatible between the two. Yuk.
- *
- * construct: exec(compile(open('a_filename', 'rb').read(), 'a_filename', 'exec'))
- *
- * Using bytes so that Python can detect the source encoding as it normally
- * does. The doc does not say "compile" accept bytes, though.
- *
- * We need to escape any backslashes or single quotes in the file name, so that
- * Python won't mangle the file name.
- */
+ // Have to do it like this. PyRun_SimpleFile requires you to pass a
+ // stdio file pointer, but Vim and the Python DLL are compiled with
+ // different options under Windows, meaning that stdio pointers aren't
+ // compatible between the two. Yuk.
+ //
+ // construct: exec(compile(open('a_filename', 'rb').read(), 'a_filename', 'exec'))
+ //
+ // Using bytes so that Python can detect the source encoding as it normally
+ // does. The doc does not say "compile" accept bytes, though.
+ //
+ // We need to escape any backslashes or single quotes in the file name, so that
+ // Python won't mangle the file name.
strcpy(buffer, "exec(compile(open('");
- p = buffer + 19; /* size of "exec(compile(open('" */
+ p = buffer + 19; // size of "exec(compile(open('"
for (i=0; i<2; ++i)
{
*p++ = '\\';
*p++ = *file++;
}
- /* If we didn't finish the file name, we hit a buffer overflow */
+ // If we didn't finish the file name, we hit a buffer overflow
if (*file != '\0')
return;
if (i==0)
}
- /* Execute the file */
+ // Execute the file
DoPyCommand(buffer,
(rangeinitializer) init_range_cmd,
(runner) run_cmd,
(void *)eap);
}
-/******************************************************
- * 2. Python output stream: writes output via [e]msg().
- */
+///////////////////////////////////////////////////////
+// 2. Python output stream: writes output via [e]msg().
-/* Implementation functions
- */
+// Implementation functions
static PyObject *
OutputGetattro(PyObject *self, PyObject *nameobj)
return OutputSetattr((OutputObject *)(self), name, val);
}
-/******************************************************
- * 3. Implementation of the Vim module for Python
- */
+///////////////////////////////////////////////////////
+// 3. Implementation of the Vim module for Python
-/* Window type - Implementation functions
- * --------------------------------------
- */
+// Window type - Implementation functions
+// --------------------------------------
#define WindowType_Check(obj) ((obj)->ob_base.ob_type == &WindowType)
-/* Buffer type - Implementation functions
- * --------------------------------------
- */
+// Buffer type - Implementation functions
+// --------------------------------------
#define BufferType_Check(obj) ((obj)->ob_base.ob_type == &BufferType)
static PyObject* BufferSubscript(PyObject *self, PyObject *idx);
static Py_ssize_t BufferAsSubscript(PyObject *self, PyObject *idx, PyObject *val);
-/* Line range type - Implementation functions
- * --------------------------------------
- */
+// Line range type - Implementation functions
+// --------------------------------------
#define RangeType_Check(obj) ((obj)->ob_base.ob_type == &RangeType)
static Py_ssize_t RangeAsItem(PyObject *, Py_ssize_t, PyObject *);
static Py_ssize_t RangeAsSubscript(PyObject *self, PyObject *idx, PyObject *val);
-/* Current objects type - Implementation functions
- * -----------------------------------------------
- */
+// Current objects type - Implementation functions
+// -----------------------------------------------
static PySequenceMethods BufferAsSeq = {
- (lenfunc) BufferLength, /* sq_length, len(x) */
- (binaryfunc) 0, /* sq_concat, x+y */
- (ssizeargfunc) 0, /* sq_repeat, x*n */
- (ssizeargfunc) BufferItem, /* sq_item, x[i] */
- 0, /* was_sq_slice, x[i:j] */
- 0, /* sq_ass_item, x[i]=v */
- 0, /* sq_ass_slice, x[i:j]=v */
- 0, /* sq_contains */
- 0, /* sq_inplace_concat */
- 0, /* sq_inplace_repeat */
+ (lenfunc) BufferLength, // sq_length, len(x)
+ (binaryfunc) 0, // sq_concat, x+y
+ (ssizeargfunc) 0, // sq_repeat, x*n
+ (ssizeargfunc) BufferItem, // sq_item, x[i]
+ 0, // was_sq_slice, x[i:j]
+ 0, // sq_ass_item, x[i]=v
+ 0, // sq_ass_slice, x[i:j]=v
+ 0, // sq_contains
+ 0, // sq_inplace_concat
+ 0, // sq_inplace_repeat
};
static PyMappingMethods BufferAsMapping = {
};
-/* Buffer object
- */
+// Buffer object
static PyObject *
BufferGetattro(PyObject *self, PyObject *nameobj)
return BufferSetattr((BufferObject *)(self), name, val);
}
-/******************/
+//////////////////
static PyObject *
BufferSubscript(PyObject *self, PyObject* idx)
}
static PySequenceMethods RangeAsSeq = {
- (lenfunc) RangeLength, /* sq_length, len(x) */
- (binaryfunc) 0, /* RangeConcat, sq_concat, x+y */
- (ssizeargfunc) 0, /* RangeRepeat, sq_repeat, x*n */
- (ssizeargfunc) RangeItem, /* sq_item, x[i] */
- 0, /* was_sq_slice, x[i:j] */
- (ssizeobjargproc) RangeAsItem, /* sq_as_item, x[i]=v */
- 0, /* sq_ass_slice, x[i:j]=v */
- 0, /* sq_contains */
- 0, /* sq_inplace_concat */
- 0, /* sq_inplace_repeat */
+ (lenfunc) RangeLength, // sq_length, len(x)
+ (binaryfunc) 0, // RangeConcat, sq_concat, x+y
+ (ssizeargfunc) 0, // RangeRepeat, sq_repeat, x*n
+ (ssizeargfunc) RangeItem, // sq_item, x[i]
+ 0, // was_sq_slice, x[i:j]
+ (ssizeobjargproc) RangeAsItem, // sq_as_item, x[i]=v
+ 0, // sq_ass_slice, x[i:j]=v
+ 0, // sq_contains
+ 0, // sq_inplace_concat
+ 0, // sq_inplace_repeat
};
static PyMappingMethods RangeAsMapping = {
/* mp_ass_subscript */ (objobjargproc)RangeAsSubscript,
};
-/* Line range object - Implementation
- */
+// Line range object - Implementation
static PyObject *
RangeGetattro(PyObject *self, PyObject *nameobj)
return PyObject_GenericGetAttr(self, nameobj);
}
-/****************/
+////////////////
static Py_ssize_t
RangeAsItem(PyObject *self, Py_ssize_t n, PyObject *val)
}
}
-/* TabPage object - Implementation
- */
+// TabPage object - Implementation
static PyObject *
TabPageGetattro(PyObject *self, PyObject *nameobj)
return PyObject_GenericGetAttr(self, nameobj);
}
-/* Window object - Implementation
- */
+// Window object - Implementation
static PyObject *
WindowGetattro(PyObject *self, PyObject *nameobj)
return WindowSetattr((WindowObject *)(self), name, val);
}
-/* Tab page list object - Definitions
- */
+// Tab page list object - Definitions
static PySequenceMethods TabListAsSeq = {
- (lenfunc) TabListLength, /* sq_length, len(x) */
- (binaryfunc) 0, /* sq_concat, x+y */
- (ssizeargfunc) 0, /* sq_repeat, x*n */
- (ssizeargfunc) TabListItem, /* sq_item, x[i] */
- 0, /* sq_slice, x[i:j] */
- (ssizeobjargproc)0, /* sq_as_item, x[i]=v */
- 0, /* sq_ass_slice, x[i:j]=v */
- 0, /* sq_contains */
- 0, /* sq_inplace_concat */
- 0, /* sq_inplace_repeat */
+ (lenfunc) TabListLength, // sq_length, len(x)
+ (binaryfunc) 0, // sq_concat, x+y
+ (ssizeargfunc) 0, // sq_repeat, x*n
+ (ssizeargfunc) TabListItem, // sq_item, x[i]
+ 0, // sq_slice, x[i:j]
+ (ssizeobjargproc)0, // sq_as_item, x[i]=v
+ 0, // sq_ass_slice, x[i:j]=v
+ 0, // sq_contains
+ 0, // sq_inplace_concat
+ 0, // sq_inplace_repeat
};
-/* Window list object - Definitions
- */
+// Window list object - Definitions
static PySequenceMethods WinListAsSeq = {
- (lenfunc) WinListLength, /* sq_length, len(x) */
- (binaryfunc) 0, /* sq_concat, x+y */
- (ssizeargfunc) 0, /* sq_repeat, x*n */
- (ssizeargfunc) WinListItem, /* sq_item, x[i] */
- 0, /* sq_slice, x[i:j] */
- (ssizeobjargproc)0, /* sq_as_item, x[i]=v */
- 0, /* sq_ass_slice, x[i:j]=v */
- 0, /* sq_contains */
- 0, /* sq_inplace_concat */
- 0, /* sq_inplace_repeat */
+ (lenfunc) WinListLength, // sq_length, len(x)
+ (binaryfunc) 0, // sq_concat, x+y
+ (ssizeargfunc) 0, // sq_repeat, x*n
+ (ssizeargfunc) WinListItem, // sq_item, x[i]
+ 0, // sq_slice, x[i:j]
+ (ssizeobjargproc)0, // sq_as_item, x[i]=v
+ 0, // sq_ass_slice, x[i:j]=v
+ 0, // sq_contains
+ 0, // sq_inplace_concat
+ 0, // sq_inplace_repeat
};
-/* Current items object - Implementation
+/*
+ * Current items object - Implementation
*/
static PyObject *
CurrentGetattro(PyObject *self, PyObject *nameobj)
return CurrentSetattr(self, name, value);
}
-/* Dictionary object - Definitions
- */
+// Dictionary object - Definitions
static PyObject *
DictionaryGetattro(PyObject *self, PyObject *nameobj)
return DictionarySetattr((DictionaryObject *)(self), name, val);
}
-/* List object - Definitions
- */
+// List object - Definitions
static PyObject *
ListGetattro(PyObject *self, PyObject *nameobj)
return ListSetattr((ListObject *)(self), name, val);
}
-/* Function object - Definitions
- */
+// Function object - Definitions
static PyObject *
FunctionGetattro(PyObject *self, PyObject *nameobj)
return PyObject_GenericGetAttr(self, nameobj);
}
-/* External interface
- */
+// External interface
void
python3_buffer_free(buf_T *buf)
static PyObject *
Py3Init_vim(void)
{
- /* The special value is removed from sys.path in Python3_Init(). */
+ // The special value is removed from sys.path in Python3_Init().
static wchar_t *(argv[2]) = {L"/must>not&exist/foo", NULL};
if (init_types())
return NULL;
- /* Set sys.argv[] to avoid a crash in warn(). */
+ // Set sys.argv[] to avoid a crash in warn().
PySys_SetArgv(1, argv);
if ((vim_module = PyModule_Create(&vimmodule)) == NULL)
return vim_module;
}
-/*************************************************************************
- * 4. Utility functions for handling the interface between Vim and Python.
- */
+//////////////////////////////////////////////////////////////////////////
+// 4. Utility functions for handling the interface between Vim and Python.
-/* Convert a Vim line into a Python string.
+/*
+ * Convert a Vim line into a Python string.
* All internal newlines are replaced by null characters.
*
* On errors, the Python exception data is set, and NULL is returned.
# define NT
# endif
# ifndef DYNAMIC_RUBY
-# define IMPORT /* For static dll usage __declspec(dllimport) */
+# define IMPORT // For static dll usage __declspec(dllimport)
# define RUBYEXTERN __declspec(dllimport)
# endif
#endif
#endif
#if defined(DYNAMIC_RUBY_VER) && DYNAMIC_RUBY_VER >= 19
-/* Ruby 1.9 defines a number of static functions which use rb_num2long and
- * rb_int2big */
+// Ruby 1.9 defines a number of static functions which use rb_num2long and
+// rb_int2big
# define rb_num2long rb_num2long_stub
# define rb_int2big rb_int2big_stub
#endif
#if defined(DYNAMIC_RUBY_VER) && DYNAMIC_RUBY_VER >= 19 \
&& VIM_SIZEOF_INT < VIM_SIZEOF_LONG
-/* Ruby 1.9 defines a number of static functions which use rb_fix2int and
- * rb_num2int if VIM_SIZEOF_INT < VIM_SIZEOF_LONG (64bit) */
+// Ruby 1.9 defines a number of static functions which use rb_fix2int and
+// rb_num2int if VIM_SIZEOF_INT < VIM_SIZEOF_LONG (64bit)
# define rb_fix2int rb_fix2int_stub
# define rb_num2int rb_num2int_stub
#endif
#if defined(DYNAMIC_RUBY_VER) && DYNAMIC_RUBY_VER == 21
-/* Ruby 2.1 adds new GC called RGenGC and RARRAY_PTR uses
- * rb_gc_writebarrier_unprotect_promoted if USE_RGENGC */
+// Ruby 2.1 adds new GC called RGenGC and RARRAY_PTR uses
+// rb_gc_writebarrier_unprotect_promoted if USE_RGENGC
# define rb_gc_writebarrier_unprotect_promoted rb_gc_writebarrier_unprotect_promoted_stub
#endif
#if defined(DYNAMIC_RUBY_VER) && DYNAMIC_RUBY_VER >= 22
#undef EXTERN
#undef _
-/* T_DATA defined both by Ruby and Mac header files, hack around it... */
+// T_DATA defined both by Ruby and Mac header files, hack around it...
#if defined(MACOS_X)
# define __OPENTRANSPORT__
# define __OPENTRANSPORTPROTOCOL__
#endif
#if defined(PROTO) && !defined(FEAT_RUBY)
-/* Define these to be able to generate the function prototypes. */
+// Define these to be able to generate the function prototypes.
# define VALUE int
# define RUBY_DATA_FUNC int
#endif
#if defined(DYNAMIC_RUBY) || defined(PROTO)
# if defined(PROTO) && !defined(HINSTANCE)
-# define HINSTANCE int /* for generating prototypes */
+# define HINSTANCE int // for generating prototypes
# endif
/*
# undef rb_intern
# define rb_intern dll_rb_intern
-# if VIM_SIZEOF_INT < VIM_SIZEOF_LONG /* 64 bits only */
+# if VIM_SIZEOF_INT < VIM_SIZEOF_LONG // 64 bits only
# if defined(DYNAMIC_RUBY_VER) && DYNAMIC_RUBY_VER <= 18
# define rb_fix2int dll_rb_fix2int
# define rb_num2int dll_rb_num2int
# undef rb_str_new
# define rb_str_new dll_rb_str_new
# ifdef rb_str_new2
-/* Ruby may #define rb_str_new2 to use rb_str_new_cstr. */
+// Ruby may #define rb_str_new2 to use rb_str_new_cstr.
# define need_rb_str_new_cstr 1
-/* Ruby's headers #define rb_str_new_cstr to make use of GCC's
- * __builtin_constant_p extension. */
+// Ruby's headers #define rb_str_new_cstr to make use of GCC's
+// __builtin_constant_p extension.
# undef rb_str_new_cstr
# define rb_str_new_cstr dll_rb_str_new_cstr
# else
static VALUE (*dll_rb_inspect) (VALUE);
static VALUE (*dll_rb_int2inum) (long);
static ID (*dll_rb_intern) (const char*);
-# if VIM_SIZEOF_INT < VIM_SIZEOF_LONG /* 64 bits only */
+# if VIM_SIZEOF_INT < VIM_SIZEOF_LONG // 64 bits only
static long (*dll_rb_fix2int) (VALUE);
static long (*dll_rb_num2int) (VALUE);
static unsigned long (*dll_rb_num2uint) (VALUE);
static VALUE (*dll_rb_str_concat) (VALUE, VALUE);
static VALUE (*dll_rb_str_new) (const char*, long);
# ifdef need_rb_str_new_cstr
-/* Ruby may #define rb_str_new2 to use rb_str_new_cstr. */
+// Ruby may #define rb_str_new2 to use rb_str_new_cstr.
static VALUE (*dll_rb_str_new_cstr) (const char*);
# else
static VALUE (*dll_rb_str_new2) (const char*);
# endif
# endif
- /* Do not generate a prototype here, VALUE isn't always defined. */
+ // Do not generate a prototype here, VALUE isn't always defined.
# if defined(USE_RGENGC) && USE_RGENGC && !defined(PROTO)
# if defined(DYNAMIC_RUBY_VER) && DYNAMIC_RUBY_VER == 21
void
}
# endif
-static HINSTANCE hinstRuby = NULL; /* Instance of ruby.dll */
+static HINSTANCE hinstRuby = NULL; // Instance of ruby.dll
/*
* Table of name to function pointer of ruby.
{"rb_inspect", (RUBY_PROC*)&dll_rb_inspect},
{"rb_int2inum", (RUBY_PROC*)&dll_rb_int2inum},
{"rb_intern", (RUBY_PROC*)&dll_rb_intern},
-# if VIM_SIZEOF_INT < VIM_SIZEOF_LONG /* 64 bits only */
+# if VIM_SIZEOF_INT < VIM_SIZEOF_LONG // 64 bits only
{"rb_fix2int", (RUBY_PROC*)&dll_rb_fix2int},
{"rb_num2int", (RUBY_PROC*)&dll_rb_num2int},
{"rb_num2uint", (RUBY_PROC*)&dll_rb_num2uint},
{
return ruby_runtime_link_init((char *)p_rubydll, verbose) == OK;
}
-#endif /* defined(DYNAMIC_RUBY) || defined(PROTO) */
+#endif // defined(DYNAMIC_RUBY) || defined(PROTO)
void
ruby_end(void)
ml_replace(i, (char_u *) StringValuePtr(line), 1);
changed();
#ifdef SYNTAX_HL
- syn_changed(i); /* recompute syntax hl. for this line */
+ syn_changed(i); // recompute syntax hl. for this line
#endif
}
}
{
#endif
#ifdef MSWIN
- /* suggested by Ariya Mizutani */
+ // suggested by Ariya Mizutani
int argc = 1;
char *argv[] = {"gvim.exe"};
char **argvp = argv;
str = rb_obj_as_string(str);
if (RSTRING_LEN(str) > 0)
{
- /* Only do this when the string isn't empty, alloc(0) causes trouble. */
+ // Only do this when the string isn't empty, alloc(0) causes trouble.
buff = ALLOCA_N(char, RSTRING_LEN(str) + 1);
strcpy(buff, RSTRING_PTR(str));
p = strchr(buff, '\n');
result = rb_str_new(tv->vval.v_blob->bv_ga.ga_data,
tv->vval.v_blob->bv_ga.ga_len);
}
- /* else return Qnil; */
+ // else return Qnil;
return result;
}
FOR_ALL_BUFFERS(b)
{
- /* Deleted buffers should not be counted
- * SegPhault - 01/07/05 */
+ // Deleted buffers should not be counted
+ // SegPhault - 01/07/05
if (b->b_p_bl)
n++;
}
FOR_ALL_BUFFERS(b)
{
- /* Deleted buffers should not be counted
- * SegPhault - 01/07/05 */
+ // Deleted buffers should not be counted
+ // SegPhault - 01/07/05
if (!b->b_p_bl)
continue;
if (buf != NULL)
return get_buffer_line(buf, (linenr_T)NUM2LONG(num));
- return Qnil; /* For stop warning */
+ return Qnil; // For stop warning
}
static VALUE
if (n > 0 && n <= buf->b_ml.ml_line_count && line != NULL)
{
- /* set curwin/curbuf for "buf" and save some things */
+ // set curwin/curbuf for "buf" and save some things
aucmd_prepbuf(&aco, buf);
if (u_savesub(n) == OK)
ml_replace(n, (char_u *)line, TRUE);
changed();
#ifdef SYNTAX_HL
- syn_changed(n); /* recompute syntax hl. for this line */
+ syn_changed(n); // recompute syntax hl. for this line
#endif
}
- /* restore curwin/curbuf and a few other things */
+ // restore curwin/curbuf and a few other things
aucmd_restbuf(&aco);
- /* Careful: autocommands may have made "buf" invalid! */
+ // Careful: autocommands may have made "buf" invalid!
update_curbuf(NOT_VALID);
}
if (n > 0 && n <= buf->b_ml.ml_line_count)
{
- /* set curwin/curbuf for "buf" and save some things */
+ // set curwin/curbuf for "buf" and save some things
aucmd_prepbuf(&aco, buf);
if (u_savedel(n, 1) == OK)
{
ml_delete(n, 0);
- /* Changes to non-active buffers should properly refresh
- * SegPhault - 01/09/05 */
+ // Changes to non-active buffers should properly refresh
+ // SegPhault - 01/09/05
deleted_lines_mark(n, 1L);
changed();
}
- /* restore curwin/curbuf and a few other things */
+ // restore curwin/curbuf and a few other things
aucmd_restbuf(&aco);
- /* Careful: autocommands may have made "buf" invalid! */
+ // Careful: autocommands may have made "buf" invalid!
update_curbuf(NOT_VALID);
}
}
else if (n >= 0 && n <= buf->b_ml.ml_line_count)
{
- /* set curwin/curbuf for "buf" and save some things */
+ // set curwin/curbuf for "buf" and save some things
aucmd_prepbuf(&aco, buf);
if (u_inssub(n + 1) == OK)
{
ml_append(n, (char_u *) line, (colnr_T) 0, FALSE);
- /* Changes to non-active buffers should properly refresh screen
- * SegPhault - 12/20/04 */
+ // Changes to non-active buffers should properly refresh screen
+ // SegPhault - 12/20/04
appended_lines_mark(n, 1L);
changed();
}
- /* restore curwin/curbuf and a few other things */
+ // restore curwin/curbuf and a few other things
aucmd_restbuf(&aco);
- /* Careful: autocommands may have made "buf" invalid! */
+ // Careful: autocommands may have made "buf" invalid!
update_curbuf(NOT_VALID);
}
win->w_cursor.lnum = NUM2LONG(lnum);
win->w_cursor.col = NUM2UINT(col);
win->w_set_curswant = TRUE;
- check_cursor(); /* put cursor on an existing line */
+ check_cursor(); // put cursor on an existing line
update_screen(NOT_VALID);
return Qnil;
}
objtbl = rb_hash_new();
rb_global_variable(&objtbl);
- /* The Vim module used to be called "VIM", but "Vim" is better. Make an
- * alias "VIM" for backwards compatibility. */
+ // The Vim module used to be called "VIM", but "Vim" is better. Make an
+ // alias "VIM" for backwards compatibility.
mVIM = rb_define_module("Vim");
rb_define_const(rb_cObject, "VIM", mVIM);
rb_define_const(mVIM, "VERSION_MAJOR", INT2NUM(VIM_VERSION_MAJOR));
rb_define_method(cBuffer, "delete", buffer_delete, 1);
rb_define_method(cBuffer, "append", buffer_append, 2);
- /* Added line manipulation functions
- * SegPhault - 03/07/05 */
+ // Added line manipulation functions
+ // SegPhault - 03/07/05
rb_define_method(cBuffer, "line_number", current_line_number, 0);
rb_define_method(cBuffer, "line", line_s_current, 0);
rb_define_method(cBuffer, "line=", set_current_line, 1);
void
vim_ruby_init(void *stack_start)
{
- /* should get machine stack start address early in main function */
+ // should get machine stack start address early in main function
ruby_stack_start = stack_start;
}
*/
#include "vim.h"
-#undef EXTERN /* tcl.h defines it too */
+#undef EXTERN // tcl.h defines it too
#ifdef DYNAMIC_TCL
-# define USE_TCL_STUBS /* use tcl's stubs mechanism */
+# define USE_TCL_STUBS // use tcl's stubs mechanism
#endif
#include <tcl.h>
#define VIMOUT ((ClientData)1)
#define VIMERR ((ClientData)2)
-/* This appears to be new in Tcl 8.4. */
+// This appears to be new in Tcl 8.4.
#ifndef CONST84
# define CONST84
#endif
struct ref *next;
Tcl_Interp *interp;
- Tcl_Command cmd; /* Tcl command that represents this object */
- Tcl_Obj *delcmd; /* Tcl command to call when object is being del. */
- void *vimobj; /* Vim window or buffer (win_T* or buf_T*) */
+ Tcl_Command cmd; // Tcl command that represents this object
+ Tcl_Obj *delcmd; // Tcl command to call when object is being del.
+ void *vimobj; // Vim window or buffer (win_T* or buf_T*)
};
static char * tclgetbuffer _ANSI_ARGS_((Tcl_Interp *interp, buf_T *buf));
static char * tclgetwindow _ANSI_ARGS_((Tcl_Interp *interp, win_T *win));
static void tclerrmsg _ANSI_ARGS_((char *text));
static void tclupdatevars _ANSI_ARGS_((void));
-static struct ref refsdeleted; /* dummy object for deleted ref list */
+static struct ref refsdeleted; // dummy object for deleted ref list
-/*****************************************************************************
- * TCL interface manager
- ****************************************************************************/
+//////////////////////////////////////////////////////////////////////////////
+// TCL interface manager
+////////////////////////////////////////////////////////////////////////////
#if defined(DYNAMIC_TCL) || defined(PROTO)
# ifndef DYNAMIC_TCL_DLL
# define DYNAMIC_TCL_VER "8.3"
# endif
-# ifndef DYNAMIC_TCL /* Just generating prototypes */
+# ifndef DYNAMIC_TCL // Just generating prototypes
typedef int HANDLE;
# endif
}
return OK;
}
-#endif /* defined(DYNAMIC_TCL) || defined(PROTO) */
+#endif // defined(DYNAMIC_TCL) || defined(PROTO)
#ifdef DYNAMIC_TCL
static char *find_executable_arg = NULL;
Tcl_DeleteInterp(interp);
stubs_initialized = TRUE;
}
- /* FIXME: When Tcl_InitStubs() was failed, how delete interp? */
+ // FIXME: When Tcl_InitStubs() was failed, how delete interp?
}
}
return stubs_initialized;
#endif
}
-/****************************************************************************
- Tcl commands
- ****************************************************************************/
+/////////////////////////////////////////////////////////////////////////////
+// Tcl commands
+////////////////////////////////////////////////////////////////////////////
/*
* Replace standard "exit" command.
case 2:
if (Tcl_GetIntFromObj(interp, objv[1], &value) != TCL_OK)
break;
- /* FALLTHROUGH */
+ // FALLTHROUGH
case 1:
tclinfo.exitvalue = value;
Tcl_SetResult(interp, _("invalid buffer number"), TCL_STATIC);
return TCL_ERROR;
}
- Tcl_ResetResult(interp); /* clear error from Tcl_GetIntFromObj */
+ Tcl_ResetResult(interp); // clear error from Tcl_GetIntFromObj
err = Tcl_GetIndexFromObj(interp, objv[1], bcmdoptions, "option", 0, &idx);
if (err != TCL_OK)
* Get line number of last line.
*/
opt = 1;
- /* fallthrough */
+ // fallthrough
case BUF_COUNT:
/*
* Get number of lines in buffer.
err = TCL_ERROR;
}
}
- else { /* objc == 3 */
+ else { // objc == 3
line = (char *)ml_get_buf(buf, (linenr_T)val1, FALSE);
Tcl_SetResult(interp, line, TCL_VOLATILE);
}
}
if (i < lc)
{
- /* append lines */
+ // append lines
do
{
line = Tcl_GetStringFromObj(lv[i], NULL);
}
else if (n <= val2)
{
- /* did not replace all lines, delete */
+ // did not replace all lines, delete
i = n;
do
{
++n;
} while (n <= val2);
}
- lc -= val2 - val1 + 1; /* number of lines to be replaced */
+ lc -= val2 - val1 + 1; // number of lines to be replaced
mark_adjust((linenr_T)val1, (linenr_T)val2, (long)MAXLNUM,
(long)lc);
changed_lines((linenr_T)val1, 0, (linenr_T)val2 + 1, (long)lc);
break;
setListError:
- u_undo(1); /* ??? */
+ u_undo(1); // ???
Tcl_SetResult(interp, _("cannot set line(s)"), TCL_STATIC);
err = TCL_ERROR;
}
case BUF_INSERT:
opt = 1;
- /* fallthrough */
+ // fallthrough
case BUF_APPEND:
if (objc != 4)
{
if (err != TCL_OK)
break;
}
- else { /* objc == 4 */
+ else { // objc == 4
err = tclgetlinenum(interp, objv[2], &val1, win->w_buffer);
if (err != TCL_OK)
break;
if (err != TCL_OK)
break;
}
- /* TODO: should check column */
+ // TODO: should check column
win->w_cursor.lnum = val1;
win->w_cursor.col = col2vim(val2);
win->w_set_curswant = TRUE;
return tclvimexpr(interp, objc, objv, 1);
}
-/****************************************************************************
- Support functions for Tcl commands
- ****************************************************************************/
+/////////////////////////////////////////////////////////////////////////////
+// Support functions for Tcl commands
+////////////////////////////////////////////////////////////////////////////
/*
* Get a line number from 'obj' and convert it to vim's range.
if (win->w_buffer == buf)
return win;
}
- return curwin; /* keep current window context */
+ return curwin; // keep current window context
}
/*
--emsg_off;
err = vimerror(interp);
- /* If the ex command created a new Tcl interpreter, remove it */
+ // If the ex command created a new Tcl interpreter, remove it
if (tclinfo.interp)
tcldelthisinterp();
memcpy(&tclinfo, &saveinfo, sizeof(tcl_info));
{
if (isnum)
{
- sval = NULL; /* avoid compiler warning */
+ sval = NULL; // avoid compiler warning
err = Tcl_GetIndexFromObj(interp, objv[objn], optkw, "", 0, &idx);
if (err != TCL_OK)
{
static char *
tclgetref(
Tcl_Interp *interp,
- void **refstartP, /* ptr to w_tcl_ref/b_tcl-ref member of
- win_T/buf_T struct */
- char *prefix, /* "win" or "buf" */
- void *vimobj, /* win_T* or buf_T* */
- Tcl_ObjCmdProc *proc) /* winselfcmd or bufselfcmd */
+ void **refstartP, // ptr to w_tcl_ref/b_tcl-ref member of
+ // win_T/buf_T struct
+ char *prefix, // "win" or "buf"
+ void *vimobj, // win_T* or buf_T*
+ Tcl_ObjCmdProc *proc) // winselfcmd or bufselfcmd
{
struct ref *ref, *unused = NULL;
static char name[VARNAME_SIZE];
(*refstartP) = (void *)ref;
}
- /* This might break on some exotic systems... */
+ // This might break on some exotic systems...
vim_snprintf(name, sizeof(name), "::vim::%s_%lx",
prefix, (unsigned long)vimobj);
cmd = Tcl_CreateObjCommand(interp, name, proc,
}
reflist = reflist->next;
}
- /* This should never happen. Famous last word? */
+ // This should never happen. Famous last word?
emsg(_("E280: TCL FATAL ERROR: reflist corrupt!? Please report this to vim-dev@vim.org"));
Tcl_SetResult(interp, _("cannot register callback command: buffer/window reference not found"), TCL_STATIC);
return TCL_ERROR;
}
-/*******************************************
- I/O Channel
-********************************************/
+////////////////////////////////////////////
+// I/O Channel
+////////////////////////////////////////////
static int
tcl_channel_close(ClientData instance, Tcl_Interp *interp UNUSED)
{
int err = 0;
- /* currently does nothing */
+ // currently does nothing
if (instance != VIMOUT && instance != VIMERR)
{
int *errptr)
{
- /* input is currently not supported */
+ // input is currently not supported
Tcl_SetErrno(EINVAL);
if (errptr)
char_u *str;
int result;
- /* The buffer is not guaranteed to be 0-terminated, and we don't if
- * there is enough room to add a '\0'. So we have to create a copy
- * of the buffer...
- */
+ // The buffer is not guaranteed to be 0-terminated, and we don't if
+ // there is enough room to add a '\0'. So we have to create a copy
+ // of the buffer...
str = vim_strnsave((char_u *)buf, bufsiz);
if (!str)
{
static Tcl_ChannelType tcl_channel_type =
{
- "vimmessage", /* typeName */
- TCL_CHANNEL_VERSION_2, /* version */
- tcl_channel_close, /* closeProc */
- tcl_channel_input, /* inputProc */
- tcl_channel_output, /* outputProc */
- NULL, /* seekProc */
- NULL, /* setOptionProc */
- NULL, /* getOptionProc */
- tcl_channel_watch, /* watchProc */
- tcl_channel_gethandle, /* getHandleProc */
- NULL, /* close2Proc */
- NULL, /* blockModeProc */
+ "vimmessage", // typeName
+ TCL_CHANNEL_VERSION_2, // version
+ tcl_channel_close, // closeProc
+ tcl_channel_input, // inputProc
+ tcl_channel_output, // outputProc
+ NULL, // seekProc
+ NULL, // setOptionProc
+ NULL, // getOptionProc
+ tcl_channel_watch, // watchProc
+ tcl_channel_gethandle, // getHandleProc
+ NULL, // close2Proc
+ NULL, // blockModeProc
#ifdef TCL_CHANNEL_VERSION_2
- NULL, /* flushProc */
- NULL, /* handlerProc */
+ NULL, // flushProc
+ NULL, // handlerProc
#endif
-/* The following should not be necessary since TCL_CHANNEL_VERSION_2 was
- * set above */
+// The following should not be necessary since TCL_CHANNEL_VERSION_2 was
+// set above
#ifdef TCL_CHANNEL_VERSION_3
- NULL, /* wideSeekProc */
+ NULL, // wideSeekProc
#endif
#ifdef TCL_CHANNEL_VERSION_4
- NULL, /* threadActionProc */
+ NULL, // threadActionProc
#endif
#ifdef TCL_CHANNEL_VERSION_5
- NULL /* truncateProc */
+ NULL // truncateProc
#endif
};
-/**********************************
- Interface to vim
- **********************************/
+///////////////////////////////////
+// Interface to vim
+//////////////////////////////////
static void
tclupdatevars(void)
{
- char varname[VARNAME_SIZE]; /* must be writeable */
+ char varname[VARNAME_SIZE]; // must be writeable
char *name;
strcpy(varname, VAR_RANGE1);
static int
tclinit(exarg_T *eap)
{
- char varname[VARNAME_SIZE]; /* Tcl_LinkVar requires writeable varname */
+ char varname[VARNAME_SIZE]; // Tcl_LinkVar requires writeable varname
char *name;
#ifdef DYNAMIC_TCL
Tcl_Interp *interp;
static Tcl_Channel ch1, ch2;
- /* Create replacement channels for stdout and stderr; this has to be
- * done each time an interpreter is created since the channels are closed
- * when the interpreter is deleted */
+ // Create replacement channels for stdout and stderr; this has to be
+ // done each time an interpreter is created since the channels are closed
+ // when the interpreter is deleted
ch1 = Tcl_CreateChannel(&tcl_channel_type, "vimout", VIMOUT, TCL_WRITABLE);
ch2 = Tcl_CreateChannel(&tcl_channel_type, "vimerr", VIMERR, TCL_WRITABLE);
Tcl_SetStdChannel(ch1, TCL_STDOUT);
return FAIL;
}
#if 0
- /* VIM sure is interactive */
+ // VIM sure is interactive
Tcl_SetVar(interp, "tcl_interactive", "1", TCL_GLOBAL_ONLY);
#endif
Tcl_SetChannelOption(interp, ch2, "-translation", "lf");
#endif
- /* replace standard Tcl exit command */
+ // replace standard Tcl exit command
Tcl_DeleteCommand(interp, "exit");
Tcl_CreateObjCommand(interp, "exit", exitcmd,
(ClientData)NULL, (Tcl_CmdDeleteProc *)NULL);
- /* new commands, in ::vim namespace */
+ // new commands, in ::vim namespace
Tcl_CreateObjCommand(interp, "::vim::buffer", buffercmd,
(ClientData)NULL, (Tcl_CmdDeleteProc *)NULL);
Tcl_CreateObjCommand(interp, "::vim::window", windowcmd,
Tcl_CreateObjCommand(interp, "::vim::expr", exprcmd,
(ClientData)NULL, (Tcl_CmdDeleteProc *)NULL);
- /* "lbase" variable */
+ // "lbase" variable
tclinfo.lbase = 1;
strcpy(varname, VAR_LBASE);
Tcl_LinkVar(interp, varname, (char *)&tclinfo.lbase, TCL_LINK_INT);
- /* "range" variable */
+ // "range" variable
tclinfo.range_start = eap->line1;
strcpy(varname, VAR_RANGE1);
Tcl_LinkVar(interp, varname, (char *)&tclinfo.range_start, TCL_LINK_INT|TCL_LINK_READ_ONLY);
strcpy(varname, VAR_RANGE3);
Tcl_LinkVar(interp, varname, (char *)&tclinfo.range_end, TCL_LINK_INT|TCL_LINK_READ_ONLY);
- /* "current" variable */
+ // "current" variable
tclinfo.curbuf = Tcl_Alloc(VARNAME_SIZE);
tclinfo.curwin = Tcl_Alloc(VARNAME_SIZE);
name = tclgetbuffer(interp, curbuf);
}
else
{
- /* Interpreter already exists, just update variables */
+ // Interpreter already exists, just update variables
tclinfo.range_start = row2tcl(eap->line1);
tclinfo.range_end = row2tcl(eap->line2);
tclupdatevars();
if (!Tcl_InterpDeleted(tclinfo.interp))
Tcl_DeleteInterp(tclinfo.interp);
Tcl_Release(tclinfo.interp);
- /* The interpreter is now gets deleted. All registered commands (esp.
- * window and buffer commands) are deleted, triggering their deletion
- * callback, which deletes all refs pointing to this interpreter.
- * We could garbage-collect the unused ref structs in all windows and
- * buffers, but unless the user creates hundreds of sub-interpreters
- * all referring to lots of windows and buffers, this is hardly worth
- * the effort. Unused refs are recycled by other interpreters, and
- * all refs are free'd when the window/buffer gets closed by vim.
- */
+ // The interpreter is now gets deleted. All registered commands (esp.
+ // window and buffer commands) are deleted, triggering their deletion
+ // callback, which deletes all refs pointing to this interpreter.
+ // We could garbage-collect the unused ref structs in all windows and
+ // buffers, but unless the user creates hundreds of sub-interpreters
+ // all referring to lots of windows and buffers, this is hardly worth
+ // the effort. Unused refs are recycled by other interpreters, and
+ // all refs are free'd when the window/buffer gets closed by vim.
tclinfo.interp = NULL;
Tcl_Free(tclinfo.curbuf);
{
int newerr = OK;
- if (Tcl_InterpDeleted(tclinfo.interp) /* True if we intercepted Tcl's exit command */
+ if (Tcl_InterpDeleted(tclinfo.interp) // True if we intercepted Tcl's exit command
#if (TCL_MAJOR_VERSION == 8 && TCL_MINOR_VERSION >= 5) || TCL_MAJOR_VERSION > 8
- || Tcl_LimitExceeded(tclinfo.interp) /* True if the interpreter cannot continue */
+ || Tcl_LimitExceeded(tclinfo.interp) // True if the interpreter cannot continue
#endif
)
{
{
char *script, *line;
int err, rs, re, lnum;
- char var_lnum[VARNAME_SIZE]; /* must be writeable memory */
+ char var_lnum[VARNAME_SIZE]; // must be writeable memory
char var_line[VARNAME_SIZE];
linenr_T first_line = 0;
linenr_T last_line = 0;
char *result;
#ifdef DYNAMIC_TCL
- /* TODO: this code currently crashes Vim on exit */
+ // TODO: this code currently crashes Vim on exit
if (exiting)
return;
#endif
struct ref *reflist;
#ifdef DYNAMIC_TCL
- if (!stubs_initialized) /* Not using Tcl, nothing to do. */
+ if (!stubs_initialized) // Not using Tcl, nothing to do.
return;
#endif
struct ref *reflist;
#ifdef DYNAMIC_TCL
- if (!stubs_initialized) /* Not using Tcl, nothing to do. */
+ if (!stubs_initialized) // Not using Tcl, nothing to do.
return;
#endif
}
}
-/* The End */
+// The End
typedef struct PendingCommand
{
- int serial; /* Serial number expected in result. */
- int code; /* Result Code. 0 is OK */
- char_u *result; /* String result for command (malloc'ed).
- * NULL means command still pending. */
+ int serial; // Serial number expected in result.
+ int code; // Result Code. 0 is OK
+ char_u *result; // String result for command (malloc'ed).
+ // NULL means command still pending.
struct PendingCommand *nextPtr;
- /* Next in list of all outstanding commands.
- * NULL means end of list. */
+ // Next in list of all outstanding commands.
+ // NULL means end of list.
} PendingCommand;
static PendingCommand *pendingCommands = NULL;
- /* List of all commands currently
- * being waited for. */
+ // List of all commands currently
+ // being waited for.
/*
* The information below is used for communication between processes
typedef struct x_cmdqueue x_queue_T;
-/* dummy node, header for circular queue */
+// dummy node, header for circular queue
static x_queue_T head = {NULL, 0, NULL, NULL};
/*
static void save_in_queue(char_u *buf, long_u len);
static void server_parse_message(Display *dpy, char_u *propInfo, long_u numItems);
-/* Private variables for the "server" functionality */
+// Private variables for the "server" functionality
static Atom registryProperty = None;
static Atom vimProperty = None;
static int got_x_error = FALSE;
-static char_u *empty_prop = (char_u *)""; /* empty GetRegProp() result */
+static char_u *empty_prop = (char_u *)""; // empty GetRegProp() result
/*
* Associate an ASCII name with Vim. Try real hard to get a unique one.
*/
int
serverRegisterName(
- Display *dpy, /* display to register with */
- char_u *name) /* the name that will be used as a base */
+ Display *dpy, // display to register with
+ char_u *name) // the name that will be used as a base
{
int i;
int res;
*/
void
serverChangeRegisteredWindow(
- Display *dpy, /* Display to register with */
- Window newwin) /* Re-register to this ID */
+ Display *dpy, // Display to register with
+ Window newwin) // Re-register to this ID
{
char_u propInfo[MAX_NAME_LENGTH + 20];
commWindow = newwin;
- /* Always call SendInit() here, to make sure commWindow is marked as a Vim
- * window. */
+ // Always call SendInit() here, to make sure commWindow is marked as a Vim
+ // window.
if (SendInit(dpy) < 0)
return;
- /* WARNING: Do not step through this while debugging, it will hangup the X
- * server! */
+ // WARNING: Do not step through this while debugging, it will hangup the X
+ // server!
XGrabServer(dpy);
DeleteAnyLingerer(dpy, newwin);
if (serverName != NULL)
{
- /* Reinsert name if we was already registered */
+ // Reinsert name if we was already registered
(void)LookupName(dpy, serverName, /*delete=*/TRUE, NULL);
sprintf((char *)propInfo, "%x %.*s",
(int_u)newwin, MAX_NAME_LENGTH, serverName);
*/
int
serverSendToVim(
- Display *dpy, /* Where to send. */
- char_u *name, /* Where to send. */
- char_u *cmd, /* What to send. */
- char_u **result, /* Result of eval'ed expression */
- Window *server, /* Actual ID of receiving app */
- Bool asExpr, /* Interpret as keystrokes or expr ? */
- int timeout, /* seconds to wait or zero */
- Bool localLoop, /* Throw away everything but result */
- int silent) /* don't complain about no server */
+ Display *dpy, // Where to send.
+ char_u *name, // Where to send.
+ char_u *cmd, // What to send.
+ char_u **result, // Result of eval'ed expression
+ Window *server, // Actual ID of receiving app
+ Bool asExpr, // Interpret as keystrokes or expr ?
+ int timeout, // seconds to wait or zero
+ Bool localLoop, // Throw away everything but result
+ int silent) // don't complain about no server
{
Window w;
char_u *property;
int length;
int res;
- static int serial = 0; /* Running count of sent commands.
- * Used to give each command a
- * different serial number. */
+ static int serial = 0; // Running count of sent commands.
+ // Used to give each command a
+ // different serial number.
PendingCommand pending;
char_u *loosename = NULL;
if (result != NULL)
*result = NULL;
if (name == NULL || *name == NUL)
- name = (char_u *)"GVIM"; /* use a default name */
+ name = (char_u *)"GVIM"; // use a default name
if (commProperty == None && dpy != NULL)
{
return -1;
}
- /* Execute locally if no display or target is ourselves */
+ // Execute locally if no display or target is ourselves
if (dpy == NULL || (serverName != NULL && STRICMP(name, serverName) == 0))
return sendToLocalVim(cmd, asExpr, result);
while (TRUE)
{
w = LookupName(dpy, name, FALSE, &loosename);
- /* Check that the window is hot */
+ // Check that the window is hot
if (w != None)
{
if (!WindowValid(dpy, w))
0, asExpr ? 'c' : 'k', 0, name, 0, p_enc, 0, cmd);
if (name == loosename)
vim_free(loosename);
- /* Add a back reference to our comm window */
+ // Add a back reference to our comm window
serial++;
sprintf((char *)property + length, "%c-r %x %d",
0, (int_u)commWindow, serial);
- /* Add length of what "-r %x %d" resulted in, skipping the NUL. */
+ // Add length of what "-r %x %d" resulted in, skipping the NUL.
length += STRLEN(property + length + 1) + 1;
res = AppendPropCarefully(dpy, w, commProperty, property, length + 1);
return -1;
}
- if (!asExpr) /* There is no answer for this - Keys are sent async */
+ if (!asExpr) // There is no answer for this - Keys are sent async
return 0;
/*
check_due_timer();
#endif
- /* Just look out for the answer without calling back into Vim */
+ // Just look out for the answer without calling back into Vim
if (localLoop)
{
#ifndef HAVE_SELECT
return ga.ga_data;
}
-/* ----------------------------------------------------------
- * Reply stuff
- */
+/////////////////////////////////////////////////////////////
+// Reply stuff
static struct ServerReply *
ServerReplyFind(Window w, enum ServerReplyOp op)
{
sprintf((char *)property, "%cn%c-E %s%c-n %s%c-w %x",
0, 0, p_enc, 0, str, 0, (unsigned int)commWindow);
- /* Add length of what "%x" resulted in. */
+ // Add length of what "%x" resulted in.
length += STRLEN(property + length);
res = AppendPropCarefully(dpy, win, commProperty, property, length + 1);
vim_free(property);
}
else
{
- /* Last string read. Remove from list */
+ // Last string read. Remove from list
ga_clear(&p->strings);
ServerReplyFind(win, SROP_Delete);
}
WhitePixel(dpy, DefaultScreen(dpy)),
WhitePixel(dpy, DefaultScreen(dpy)));
XSelectInput(dpy, commWindow, PropertyChangeMask);
- /* WARNING: Do not step through this while debugging, it will hangup
- * the X server! */
+ // WARNING: Do not step through this while debugging, it will hangup
+ // the X server!
XGrabServer(dpy);
DeleteAnyLingerer(dpy, commWindow);
XUngrabServer(dpy);
}
- /* Make window recognizable as a vim window */
+ // Make window recognizable as a vim window
XChangeProperty(dpy, commWindow, vimProperty, XA_STRING,
8, PropModeReplace, (char_u *)VIM_VERSION_SHORT,
(int)STRLEN(VIM_VERSION_SHORT) + 1);
*/
static Window
LookupName(
- Display *dpy, /* Display whose registry to check. */
- char_u *name, /* Name of a server. */
- int delete, /* If non-zero, delete info about name. */
- char_u **loose) /* Do another search matching -999 if not found
- Return result here if a match is found */
+ Display *dpy, // Display whose registry to check.
+ char_u *name, // Name of a server.
+ int delete, // If non-zero, delete info about name.
+ char_u **loose) // Do another search matching -999 if not found
+ // Return result here if a match is found
{
char_u *regProp, *entry;
char_u *p;
* Scan the property for the desired name.
*/
returnValue = (int_u)None;
- entry = NULL; /* Not needed, but eliminates compiler warning. */
+ entry = NULL; // Not needed, but eliminates compiler warning.
for (p = regProp; (long_u)(p - regProp) < numItems; )
{
entry = p;
*/
static void
DeleteAnyLingerer(
- Display *dpy, /* Display whose registry to check. */
- Window win) /* Window to remove */
+ Display *dpy, // Display whose registry to check.
+ Window win) // Window to remove
{
char_u *regProp, *entry = NULL;
char_u *p;
if (GetRegProp(dpy, ®Prop, &numItems, FALSE) == FAIL)
return;
- /* Scan the property for the window id. */
+ // Scan the property for the window id.
for (p = regProp; (long_u)(p - regProp) < numItems; )
{
if (*p != 0)
{
int lastHalf;
- /* Copy down the remainder to delete entry */
+ // Copy down the remainder to delete entry
entry = p;
while (*p != 0)
p++;
Display *dpy,
char_u **regPropp,
long_u *numItemsp,
- int domsg) /* When TRUE give error message. */
+ int domsg) // When TRUE give error message.
{
int result, actualFormat;
long_u bytesAfter;
if (actualType == None)
{
- /* No prop yet. Logically equal to the empty list */
+ // No prop yet. Logically equal to the empty list
*numItemsp = 0;
*regPropp = empty_prop;
return OK;
}
- /* If the property is improperly formed, then delete it. */
+ // If the property is improperly formed, then delete it.
if (result != Success || actualFormat != 8 || actualType != XA_STRING)
{
if (*regPropp != NULL)
void
serverEventProc(
Display *dpy,
- XEvent *eventPtr, /* Information about event. */
- int immediate) /* Run event immediately. Should mostly be 0. */
+ XEvent *eventPtr, // Information about event.
+ int immediate) // Run event immediately. Should mostly be 0.
{
char_u *propInfo;
int result, actualFormat;
&actualFormat, &numItems, &bytesAfter,
&propInfo);
- /* If the property doesn't exist or is improperly formed then ignore it. */
+ // If the property doesn't exist or is improperly formed then ignore it.
if (result != Success || actualType != XA_STRING || actualFormat != 8)
{
if (propInfo != NULL)
node = ALLOC_ONE(x_queue_T);
if (node == NULL)
- return; /* out of memory */
+ return; // out of memory
node->propInfo = propInfo;
node->len = len;
- if (head.next == NULL) /* initialize circular queue */
+ if (head.next == NULL) // initialize circular queue
{
head.next = &head;
head.prev = &head;
}
- /* insert node at tail of queue */
+ // insert node at tail of queue
node->next = &head;
node->prev = head.prev;
head.prev->next = node;
x_queue_T *node;
if (!X_DISPLAY)
- return; /* cannot happen? */
+ return; // cannot happen?
while (head.next != NULL && head.next != &head)
{
node = head.next;
static void
server_parse_message(
Display *dpy,
- char_u *propInfo, /* A string containing 0 or more X commands */
- long_u numItems) /* The size of propInfo in bytes. */
+ char_u *propInfo, // A string containing 0 or more X commands
+ long_u numItems) // The size of propInfo in bytes.
{
char_u *p;
int code;
else
{
p = serial = end + 1;
- clientWindow = resWindow; /* Remember in global */
+ clientWindow = resWindow; // Remember in global
}
break;
case 'n':
{
garray_T reply;
- /* Initialize the result property. */
+ // Initialize the result property.
ga_init2(&reply, 1, 100);
(void)ga_grow(&reply, 50 + STRLEN(p_enc));
sprintf(reply.ga_data, "%cr%c-E %s%c-s %s%c-r ",
0, 0, p_enc, 0, serial, 0);
reply.ga_len = 14 + STRLEN(p_enc) + STRLEN(serial);
- /* Evaluate the expression and return the result. */
+ // Evaluate the expression and return the result.
if (res != NULL)
ga_concat(&reply, res);
else
*/
static int
AppendPropCarefully(
- Display *dpy, /* Display on which to operate. */
- Window window, /* Window whose property is to be modified. */
- Atom property, /* Name of property. */
- char_u *value, /* Characters to append to property. */
- int length) /* How much to append */
+ Display *dpy, // Display on which to operate.
+ Window window, // Window whose property is to be modified.
+ Atom property, // Name of property.
+ char_u *value, // Characters to append to property.
+ int length) // How much to append
{
XErrorHandler old_handler;
return (len > 1 && vim_isdigit(str[len - 1]));
}
-#endif /* FEAT_CLIENTSERVER */
+#endif // FEAT_CLIENTSERVER
static int included_patches[] =
{ /* Add new patch number below this line */
+/**/
+ 2387,
/**/
2386,
/**/
projects / vim / commitdiff