sourceinsight使用技巧

1 sourceinsight　screen font　的默认字体是Verdana的，它是一直变宽字体。在Document style中可以将字体改为定宽的Courier

2   勾掉indent Open Brace和Indent Close Brace的效果: 继上一段，在相对缩进行里, 如果输入"{"或"}", 则自动和上一行列对齐

3 今天把一个用sourceinsight排版整齐的C文件，偶然用VC打开一看，全乱了。研究了半天，发现SI对每个字符的宽度不太一致。

    发现选上"view --> draft view"， 就可以让每个字符的宽度一致了。快捷键是 "Alt + F12"

4选中几行代码按tab键或者shift+tab可以左右移动代码，调整代码时很有用。

配置成简单好用的c/java代码编辑器

1、缩进与tab

（1）Options菜单àPreferencesàTyping卡，勾掉下面两项∶

Typing tab indents line，regardless of selection，空行按tab无法前进

Typing tab replaces current selection，选定部分内容、再按tab时会清除所选

（2）Options菜单àDocument Options（针对不同文件类型，分别进行设置）à下拉左上文件类型框、选择合适类型（c源文件）àEditing Options框中，tab width=2à Editing Options框中，勾选Expand tabs（这样，按tab键、等价于输入2个空格）

（3）Options菜单àDocument Optionsà选择合适的文件类型à点击右边中间的Auto Indent钮à在弹出的框中，左边一定要点Smart，右边有两个复选框Indent Open Brace和Indent Close Brace，具体效果可以看SIS的HELP。按照部门里的编程风格要求，最方便的就是把两个复选框都取消掉，然后点OK。

勾选Auto Indent之SMART的效果∶在C程序里, 如果遇到行末没有分号的语句,如IF, WHILE, SWITCH等, 写到该行末按回车，则新行自动相对上一行缩进两列。

勾掉Indent Open Brace和Indent Close Brace的效果∶继上一段，在相对缩进行里, 如果输入"}", 则自动和上一行列对齐（好像勾不勾都会有这个功能）；而输入"{"时，不会与下面的行对齐（这是勾上Indent Open Brace时的效果）。

2、向项目中添加文件时，只添加特定类型的文件（文件类型过滤器）

有个同事比较生猛，得整汇编代码，但在SIS里建立PROJECT并ADD TREE的时候，根据默认设置并不会把该TREE里面所有汇编文件都包含进来，只加了.inc和.asm后缀的，.s后缀的没有。而且用SIS打开.s的文件，一片黑白没有色彩，感觉回到DOS的EDIT时代了…… 解决方法是在Options->Document Options里面，点左上的Document Type下拉菜单，选择x86 Asm Source File，然后在右边的File filter里*.asm；*.inc；的后面加上*.s；接着CLOSE就可以了。上面两个问题解决了，但注意加入*.s后还需要重新ADD TREE一遍才能把这些汇编加到PROJECT里面。

3、去掉功能强大但是无用的自动完成功能

Options菜单àPreferences àTyping卡àAuto Completion框，勾掉Use automatic symbol completion window（这里是SIS的全局设置）

Options菜单àDocument OptionsàEditing Options框中，勾掉Allow auto-complete（局部设置）

上面两项必须全部勾选，才能启用Auto Completion功能

4、恢复小键盘的“+，-，*，/”功能

Options菜单àKey assignments，通过关键词Scroll 找到Scroll Half Page Up，取消小键盘/；通过关键词Scroll 找到Scroll Half Page Down取消小键盘*；通过关键词Function找到Function Up，取消小键盘-，通过关键词Function找到Function down，取消小键盘+。

5、恢复ctrl+a的全选功能

通过关键词save 找到save all，更改为ctrl+shift+a，通过关键词select找到select all， 更改为ctrl +a

6、解决字符等宽对齐问题。

SIS默认字体是VERDANA，很漂亮。这网页上应该也是用的VERDANA字体。但由于美观的缘故，VERDANA字体是不等宽的。比如下面两行

llllllllll

MMMMMMMMMM

同样10个字符，长度差多了.用VERDANA来看程序，有些本应该对齐的就歪了。解放方法是使用等宽的字体，但肯定比较丑。可以用DOS字体，也就是记事本里的默认字体sysfixed 很丑，要有心理准备。比较推荐的是用Courier New。

SourceInsight提供的功能

1、解析日志信息时非常有用的Source Link

总地说来，SourceLink根据特定的搜索模式，把当前文件中满足模式的行、链接到由该行指定的其他源文件中。

所谓特定的搜索模式，共有两种“File, then line”和“Line, then file”，其中前后两部分依靠正则表达式的组的概念来予以分割。如果当前文件具有匹配行，比如“Error d:tcsrcq5.c 18: Lvalue required in function jsSort”，那么SourceInsight在该行创建SourceLink、把该行链接到由该行指定的文件中（即d:tcsrcq5.c，第18行）。

1.1 创建SourceLink

运行Search菜单的Parse Source Links…命令，在弹出的框中、选择搜索模式、并填入相应的正则表达式串，点OK，SIS就会解析当前文件，如果有匹配，就创建SourceLink。

1.2 在解析日志信息时，使用SourceLink

可以打开日志信息，运行Parse Source Links命令，日志中能够匹配模式的每一行（通常是含有错误信息的行）、就会被设置上一个SourceLink

1.3在解析自定义命令输出时，使用SourceLink

首先勾选Custom Command 中的“Parse Links in Output”，然后选择特定的搜索模式，最后填入合适的正则表达式。这样，Source Insight把输出信息作为当前搜索用文件；并且，如果有匹配行（通常即编译错误信息行），SIS为 该行创建SourceLink、并把每一个错误信息中给定的文件（和行号）作为link目的地，这对于我们修改源代码错误非常有帮助。

2、替换（Replace） VS 上下文敏感的智能重命名（Context-Sensitive Smart Rename）

2.1 替换（Replace）

目前来说，普通的替换命令、快捷键为ctrl+H，足以已满足工作要求。

在弹出的替换窗口中，在Search框中勾选Selection来只在所选文本区域中替换（当然这时你要先选定区域然后再按ctrl+H）、勾选WholeFile来在整个当前文件内替换、两者都不勾选来从当前光标处替换至文件末尾；点右边的Files…按钮，可选择替换多个文件的内容。

2.2上下文敏感的智能重命名（Context-Sensitive Smart Rename）

Smart Rename命令、快捷键是Ctrl+’，是上下文敏感的全局搜索替换。它可以智能地重命名全部项目文件中的一个标示符。SourceInsight的搜索索引（search index）使得搜索过程进行地非常快。而且，使用Smart Rename所做的替换会被记录在Search Results窗口中，每一条替换记录旁有一个SourceLink链接到替换发生地文件。

Smart Rename可以用来重命名标记（symbol）。如果勾选了Smart Reference Matching选项，Smart Rename就只在正确的上下文范围内进行重命名。它可以智能地重命名全部项目文件中的一个标示符；它可以重命名函数本地变量，类或结构体成员、函数。

在弹出的Smart Rename窗口中有下面几项∶

Old Name 填旧名称。光标下的词会被自动加载；光标的位置非常重要，这是因为Source Insight会根据本地上下文背景、准确地确定你想要重命名哪一个标记。

推荐只填单个词、而不是字符串。

如果你在命名成员变量、或本地变量（），Old Name框中会显示完全标记名、即上层容器名+标记名。例如，框中的“DocDraw.paintStruc”代表DocDraw是函数名，paintStruc是函数的本地成员变量。

New Name 填新名称。只填标记名，不填上层容器名。

Output Search Results 如果勾选，搜索替换结果日志会被输出到Search Results窗口中。可以通过Windows菜单来切换，或ctrl+tab切换察看。并且每一条记录旁会有SourceLink链接到替换发生地文件。

Confirm Each Replacement 每次替换询问。

Skip Comments 不重名注释部分。

 

【使用心得列表】

（１）如何用Smart Rename重命名数组的数组名？如果只选取数组名，会报错！

（２）如果勾掉Smart Reference Matching，会搜索全部项目文件，并且Old Name框中不显示完全限定名；如果勾选Smart Reference Matching，无法重命名数组名，而且鼠标位置不正确时会报错。应该如何应对？

3、在SourceInsight中提供的正则表达式

3.1在SourceInsight中提供的正则表达式

正则表达式，是用来匹配复杂模式的特殊搜索用字符串。正则表达式串中，许多字符具有特殊的含义。例如，有个特殊的字符代表 “行首”。

下面是SourceInsight提供的所有可用特殊字符∶

Table 4.3: Regular Expression Characters
Character	Matches
^ (at the beginning only)	beginning of line。如^Hello，匹配Hello在句首。
.	any single character
[abc]	any single character that belongs to the set abc
[^abc]	any single character that does not belong to the set abc
*	zero or more occurrences of the preceding character
+	one or more occurrences of the preceding character
t	a tab character
s	a space character
w	white space (a tab or a space character)
$	the end of the line。如TRUE$，匹配TRUE在句尾。
	转义字符。如果在它后面有元字符，取消其特殊含义。

 

可利用 “(”和 “)”、把正则表达式分割成不同的组；模式中的每个组自左向右指定为 Group #n，n=1,2,…；组的概念在替换时很有用。

例如∶

abc(xyz)可匹配abcxyz，其中xyz被认为是group#1，

利用21来替换(abc)(xyz)，替换结果为xyzabc。

3.2 正则表达式在配置tc编译器中的应用∶

正则表达式格式与源代码文件路径相对应，这里我的tc安装目录为d:tc，tc源文件放在d:tcsrc下，并命名为qn.c或qtn.c（其中n=1,2,…）。

观察Tc编译器某一次输出错误信息的格式∶

Error d:tcsrcq5.c 18: Lvalue required in function jsSort

则我们要匹配“d:tcsrcq5.c 18”部分，进一步地，按照SourceInsight捕捉输出并加以解析时的要求，要以组的形式、分别匹配“d:tcsrcq5.c 18”中的文件部分和行号部分∶

行号([1-9][0-9]*)

空格行号s([1-9][0-9]*)

文件名(d:tcsrc[qQ][tT][1-9][0-9]*.[cC])

全部加起来为∶

(d:tcsrc[qQ][tT]*[1-9][0-9]*.[cC])s([1-9][0-9]*)

 

3.3 正则表达式在配置javac编译器中的应用∶

我的JAVA_HOME是c:jdk，我的java源文件放于d:javasrc中，并命名为qn.java或qtn.java（其中n=1,2,…）。

观察JDK编译器某一次输出错误信息的格式∶

D:javasrcQ3.java:3: ';' expected

正则表达式为∶

([dD]:javasrc[qQ][tT]*[1-9][0-9]*.java):([1-9][0-9]*)

 

4、自定义命令

自定义命令与项目相关，在一个项目中定义的所有自定义命令属于该项目、只对该项目有效（包括快捷键等）。

自定义命令类似于命令行批处理文件。SIS允许自定义命令在后台运行；并可以捕捉自定义命令的输出、放置于文件中、或粘贴入当前光标插入点。

分别利用上面SIS对输出信息的处理方式，自定义命令对集成编译器相当有用，可以捕捉编译器输出并创建SourceLink寻错；自定义命令对于文本过滤也相当有用，可选中待过滤区块、运行Sort自定义命令、粘贴回选定区块、即完成文本过滤。

请按下面步骤创建自定义命令∶

Options菜单àCustom Command

à点右边Add钮、填入新自定义命令名称，或下拉左边Commands、选择命令进行修改

àRun框、填入待执行命令行，可含有特殊元字符，见后面的元字符表

àDir框、执行命令行时应处的目录，如不填，以源代码文件所在目录为命令执行目录

à勾选Output框的Capture Output、输出被捕捉，如果勾选Paste Output，输出被粘贴

à勾选Control Group框中的Save Files First、SIS会在运行命令前先检查文件是否保存

à勾选Control Group框中的Pause When Done、SIS会在命令结束后暂停、方便检查

à勾选Source Links in Output框中的Parse Source Links，?/p>

5使用最强大的宏功能，真的达到的完美境界

说明:
    该宏文件实现一些编码程中能会到的功能, 如添加文件头、函数说明和宏定义等, 使用时能自动添加文件名、函数名和当前日期.

使用说明:
    1. Project->Open Project... 打开Base工程(该工程一般在"我的文档/Source Insight/Projects/Base"中);
    2. Project->Add and Remove Project Files... 加入宏文件(即mymacro.em);
    3. Options->Menu Assignments 打开Menu Assignments窗口, 在Command中输入Macro, 选中要使用的宏, 添加到合适的菜单中.
在http://www.sourceinsight.com/public/macros/可以找到很多宏定义文件，但大多数没什么用。

macro InsFunHeader()
{
// Get the owner's name from the environment variable: szMyName.
// If the variable doesn't exist, then the owner field is skipped.

szMyName = "LW"

// Get a handle to the current file buffer and the name
// and location of the current symbol where the cursor is.
hbuf = GetCurrentBuf()
szFunc = GetCurSymbol()
ln = GetSymbolLine(szFunc)

// Get current time
szTime = GetSysTime(1)
Day = szTime.Day
Month = szTime.Month
Year = szTime.Year
if (Day < 10)
szDay = "0@Day@"
else
szDay = Day
szMonth = NumToName(Month)
szInf = Ask("Enter the information of function:")
szDescription = Ask("Enter the description of function:")

// begin assembling the title string
sz = "")

// put the insertion point inside the header comment
SetBufIns(hbuf, ln + 1, strlen(szFunc) + strlen(szInf) + 8)
}

macro NumToName(Month)
{
if (Month == 1)
return "jan"
if (Month == 2)
return "feb"
if (Month == 3)
return "mar"
if (Month == 4)
return "apr"
if (Month == 5)
return "may"
if (Month == 6)
return "jun"
if (Month == 7)
return "jul"
if (Month == 8)
return "aug"
if (Month == 9)
return "sep"
if (Month == 10)
return "oct"
if (Month == 11)
return "nov"
if (Month == 12)
return "dec"
}

macro CutWord(ncurLine, szInf)
{
LENGTH = 63
nlength = StrLen(szInf)
i = 0
begin = 0
pre = 0
hbuf = GetCurrentBuf()
// nline = GetBufLnCur()
while (i < nlength)
{

        c = szInf[i]
        if (" " == @c@ && (i - b < LENGTH))
        {
            pre = i
        }
        else if (" " == @c@)
        {
            szOutput = ""
            k = begin
            while (k < pre)
            {
                szOutput = Cat(szOutput, szInf[k])
                k = k + 1
            }
            InsBufLine(hbuf, ncurLine, sz)
            ncurLine = ncurLine + 1
            begin = pre
        }
        i = i + 1
    }
    if (h != i - 1)
    {
        szOutput = ""
        k = begin
        while (k < pre)
        {
            szOutput = Cat(szOutput, szInf[k])
            k = k + 1
        }
        InsBufLine(hbuf, ncurLine, sz)
        ncurLine = ncurLine + 1
    }
}

 

// Wrap ifdeinef <sz> .. endif around the current selection
macro IfdefineSz(sz)
{
hwnd = GetCurrentWnd()
lnFirst = GetWndSelLnFirst(hwnd)
lnLast = GetWndSelLnLast(hwnd)

hbuf = GetCurrentBuf()
InsBufLine(hbuf, lnFirst, "#ifndef @sz@")
InsBufLine(hbuf, lnFirst + 1, "#define @sz@")
InsBufLine(hbuf, lnLast + 3, "#endif ")
SetBufIns(hbuf, lnFirst + 2, 0)
}

 

macro AutoExpand()
{
// get window, sel, and buffer handles
hwnd = GetCurrentWnd()
if (hwnd == 0)
stop
sel = GetWndSel(hwnd)
if (sel.ichFirst == 0)
stop
hbuf = GetWndBuf(hwnd)

// get line the selection (insertion point) is on
szLine = GetBufLine(hbuf, sel.lnFirst);

// parse word just to the left of the insertion point
wordinfo = GetWordLeftOfIch(sel.ichFirst, szLine)
ln = sel.lnFirst;

chTab = CharFromAscii(9)

// prepare a new indented blank line to be inserted.
// keep white space on left and add a tab to indent.
// this preserves the indentation level.
ich = 0
while (szLine[ich] == ' ' || szLine[ich] == chTab)
{
ich = ich + 1
}

szLine = strmid(szLine, 0, ich)
sel.lnFirst = sel.lnLast
sel.ichFirst = wordinfo.ich
sel.ichLim = wordinfo.ich

// expand szWord keyword...

if (wordinfo.szWord == "if" ||
wordinfo.szWord == "while" ||
wordinfo.szWord == "elseif")
{
SetBufSelText(hbuf, " (###)")
InsBufLine(hbuf, ln + 1, "@szLine@" # "{");
InsBufLine(hbuf, ln + 2, "@szLine@" # chTab);
InsBufLine(hbuf, ln + 3, "@szLine@" # "}");
}
else if (wordinfo.szWord == "for")
{
SetBufSelText(hbuf, " (###; ###; ###)")
InsBufLine(hbuf, ln + 1, "@szLine@" # "{");
InsBufLine(hbuf, ln + 2, "@szLine@" # chTab);
InsBufLine(hbuf, ln + 3, "@szLine@" # "}");
}
else if (wordinfo.szWord == "switch")
{
SetBufSelText(hbuf, " (###)")
InsBufLine(hbuf, ln + 1, "@szLine@" # "{")
InsBufLine(hbuf, ln + 2, "@szLine@" # "case ")
InsBufLine(hbuf, ln + 3, "@szLine@" # chTab)
InsBufLine(hbuf, ln + 4, "@szLine@" # chTab # "break;")
InsBufLine(hbuf, ln + 5, "@szLine@" # "default:")
InsBufLine(hbuf, ln + 6, "@szLine@" # chTab)
InsBufLine(hbuf, ln + 7, "@szLine@" # "}")
}
else if (wordinfo.szWord == "do")
{
InsBufLine(hbuf, ln + 1, "@szLine@" # "{")
InsBufLine(hbuf, ln + 2, "@szLine@" # chTab);
InsBufLine(hbuf, ln + 3, "@szLine@" # "} while ();")
}
else if (wordinfo.szWord == "case")
{
SetBufSelText(hbuf, " ###")
InsBufLine(hbuf, ln + 1, "@szLine@" # chTab)
InsBufLine(hbuf, ln + 2, "@szLine@" # chTab # "break;")
}
else
stop

SetWndSel(hwnd, sel)
LoadSearchPattern("###", true, false, false);
Search_Forward
}

macro GetWordLeftOfIch(ich, sz)
{
wordinfo = "" // create a "wordinfo" structure

chTab = CharFromAscii(9)

// scan backwords over white space, if any
ich = ich - 1;
if (ich >= 0)
while (sz[ich] == " " || sz[ich] == chTab)
   {
   ich = ich - 1;
   if (ich < 0)
    break;
   }

// scan backwords to start of word
ichLim = ich + 1;
asciiA = AsciiFromChar("A")
asciiZ = AsciiFromChar("Z")
while (ich >= 0)
{
ch = toupper(sz[ich])
asciiCh = AsciiFromChar(ch)
if ((asciiCh < asciiA || asciiCh > asciiZ) && !IsNumber(ch))
   break // stop at first non-identifier character
ich = ich - 1;
}

ich = ich + 1
wordinfo.szWord = strmid(sz, ich, ichLim)
wordinfo.ich = ich
wordinfo.ichLim = ichLim;

return wordinfo
}

//
// Comment the selected block of text using single line comments and indent it
//
macro CommentBlock()
{
hbuf = GetCurrentBuf();
hwnd = GetCurrentWnd();

sel = GetWndSel(hwnd);

iLine = sel.lnFirst;

while (iLine <= sel.lnLast)
{
   szLine = GetBufLine(hbuf, iLine);
   szLine = cat("// ", szLine);
   PutBufLine(hbuf, iLine, szLine);
   iLine = iLine + 1;
}

if (sel.lnFirst == sel.lnLast)
{
   tabSize = _tsGetTabSize() - 1;
   sel.ichFirst = sel.ichFirst + tabSize;
   sel.ichLim = sel.ichLim + tabSize;
}
SetWndSel(hwnd, sel);
}

//
// Undo the CommentBlock for the selected text.
//
macro UnCommentBlock()
{
hbuf = GetCurrentBuf();
hwnd = GetCurrentWnd();

sel = GetWndSel(hwnd);

iLine = sel.lnFirst;

tabSize = 0;
while (iLine <= sel.lnLast)
{
   szLine = GetBufLine(hbuf, iLine);
   len = strlen(szLine);
   szNewLine = "";
   if (len > 1)
   {
    if (szLine[0] == "/" && szLine[1] == "/")
    {
     if (len > 2)
     {
      if (AsciiFromChar(szLine[2]) == 9)
      {
       tabSize = _tsGetTabSize() - 1;
       szNewLine = strmid(szLine, 3, strlen(szLine));
      }
     }

     if (szNewLine == "")
     {
      szNewLine = strmid(szLine, 2, strlen(szLine));
      tabSize = 2;
     }
    
     PutBufLine(hbuf, iLine, szNewLine);
    }
   }
   iLine = iLine + 1;
}

if (sel.lnFirst == sel.lnLast)
{
   sel.ichFirst = sel.ichFirst - tabSize;
   sel.ichLim = sel.ichLim - tabSize;
}

SetWndSel(hwnd, sel);
}

 

macro _tsGetTabSize()
{
szTabSize = GetReg("TabSize");

if (szTabSize != "")
{
   tabSize = AsciiFromChar(szTabSize[0]) - AsciiFromChar("0");
}
else
{
   tabSize = 4;
}

return tabSize;
}

 

//
// Reformat a selected comment block to wrap text at 80 columns.
// The start of the selection (upper left most character of the selection) is
// handled specially, in that it specifies the left most column at which all
// lines will begin. For example, if the following block was selected starting
// at the @ symbol, through the last line of the block...
//------------------------------------------------------------------------------
// preamble: @ This is a line that will be wrapped keeping the "at" symbol in its current column.
// All lines following it that are selected will use that as their starting column. See below to see how the wrapping
// works for this block of text.
//------------------------------------------------------------------------------
// preamble: @ This is a line that will be wrapped keeping the "at" symbol in
//     its current column. All lines following it that are selected
//     will use that as their starting column. See below to see how
//     the wrapping works for this block of text.
//
macro tsReformatCommentBlock()
{
hbuf = GetCurrentBuf();
hwnd = GetCurrentWnd();

sel = GetWndSel(hwnd);

tabSize = _tsGetTabSize();
leftTextCol = 0 - 1;
colWrap = 80;

// Find the starting column, and create a Margin string
ichFirst = sel.ichFirst;

// Single line comment reformat?
if (sel.ichFirst == sel.ichLim && sel.lnFirst == sel.lnLast)
{
   ichFirst = 0;
}

rec = _tsGetStartColumn(hbuf, ichFirst, sel.lnFirst);

if (rec == "")
   stop;

colLeftMargin = rec.colMargin;
szMargin = "";

colComment = 0;
if (rec.colComment >= 0)
{
   colComment = rec.colComment + 2
   szMargin = _tsAddWhiteToColumn(szMargin, 0, rec.colComment, tabSize);
   szMargin = cat(szMargin, "//");
}

szMargin = _tsAddWhiteToColumn(szMargin, colComment, rec.colMargin, tabSize);

rec = "";

szCurMargin = "";
if (ichFirst != 0)
{
   szLine = GetBufLine(hbuf, sel.lnFirst);
   szCurMargin = strmid(szLine, 0, ichFirst);
}
else
{
   szCurMargin = szMargin;
   szMargin = "";
}

insertLine = sel.lnFirst;
iLine = sel.lnFirst;
szRemainder = "";
while (1)
{
//   msg("$0-" # iLine # ":" # szRemainder);
   rec = _tsGetNextCommentString(hbuf, ichFirst, szRemainder, iLine, sel.lnLast, colWrap);
   ichFirst = 0;

   if (rec == "")
    break;

//   msg("$1-" # rec.ln # ":" # rec.szComment);
   szLine = rec.szComment;

   ich = 0;
   col = colLeftMargin;
   len = strlen(szLine);
  
   ichPrevCharToWhite = 0-1;
   ichPrevWhiteToChar = 0-1;
//   msg("Leftovers @szRemainder@");

   while (ich < len)
   {
    if (AsciiFromChar(szLine[ich]) == 9)
    {
     col = (((col + tabSize) / tabSize) * tabSize);
    }
    else
    {
     col = col + 1;
    }

    if (col > colWrap)
     break;

    fIsWhitespace = _tsIsWhitespaceChar(szLine[ich]);
    fIsWhitespace1 = 1;

    if (ich + 1 < len)
    {
     fIsWhitespace1 = _tsIsWhitespaceChar(szLine[ich + 1]);
    }

    if (!fIsWhitespace && fIsWhitespace1)
     ichPrevCharToWhite = ich;
   
    ich = ich + 1;
   }

   if (ichPrevCharToWhite > 0)
   {
//    msg("$2:" # strmid(szLine, 0, ichPrevCharToWhite + 1));
    ich = ichPrevCharToWhite + 1;

    while (ich < len)
    {
     if (!_tsIsWhitespaceChar(szLine[ich]))
     {
      ichPrevWhiteToChar = ich - 1;
//      msg("$3:" # strmid(szLine, ichPrevWhiteToChar + 1, len));
      break;
     }
     ich = ich + 1;
    }
   }

   if (ichPrevCharToWhite > 0 && col > colWrap)
   {
    szNewLine = cat(szCurMargin, strmid(szLine, 0, ichPrevCharToWhite + 1));
    szRemainder = "";
    if (ichPrevWhiteToChar > 0)
     szRemainder = strmid(szLine, ichPrevWhiteToChar + 1, len);
    
    if (ichPrevCharToWhite > ichPrevWhiteToChar)
     msg("!!!Wrap, duplicating word " # ichPrevWhiteToChar # " " # ichPrevCharToWhite # " " # szNewLine # " >>> " # szRemainder);
//     msg(szLine);
//     msg(col # " " # ichPrevWhiteToChar # " " # ichPrevCharToWhite # " " # szNewLine # " >>> " # szRemainder);
   }
   else if (szLine != "")
   {
    szNewLine = cat(szCurMargin, szLine );
    szRemainder = "";
//    sel.lnLast = sel.lnLast + 1;
   }

   iLine = rec.ln;
   if (insertLine == iLine)
   {
    iLine = iLine + 1;
    sel.lnLast = sel.lnLast + 1;
   
//    msg("$5-" # insertLine # ":" # szNewLine);
    InsBufLine(hbuf, insertLine, szNewLine);
   }
   else
   {
    szLine = GetBufLine(hbuf, insertLine);
    if (szLine != szNewLine)
    {
//     msg("$6-" # insertLine # ":" # szNewLine);
     PutBufLine(hbuf, insertLine, szNewLine);
    }
   }
   insertLine = insertLine + 1;

   if (szMargin != "")
   {
    szCurMargin = szMargin;
    szMargin = "";
   }
}

while (insertLine <= sel.lnLast)
{
   DelBufLine(hbuf, insertLine);
   sel.lnLast = sel.lnLast - 1;
}

len = GetBufLineLength(hbuf, insertLine-1);

sel.ichFirst = len;
sel.ichLim = len;
sel.lnFirst = sel.lnLast;
SetWndSel(hwnd, sel);
}

macro _tsAddWhiteToColumn(sz, col0, col, tabSize)
{
szTabs = "                               ";
szSpaces = "                ";

tabs0 = col0 / tabSize;
tabs = (col / tabSize) - tabs0;

if (tabs == 0)
   foo = col0;
else
   foo = (tabs + tabs0) * tabSize;
spaces = col - foo;
// msg(col0 # " " # col # " " # tabs # " " # spaces # " " # tabs0);

if (tabs)
   sz = cat(sz, strmid(szTabs, 0, tabs));

if (spaces)
   sz = cat(sz, strmid(szSpaces, 0, spaces));

return sz;
}

macro _tsGetStartColumn(hbuf, ichBegin, ln)
{
szLine = GetBufLine(hbuf, ln);
len = strlen(szLine);
tabSize = _tsGetTabSize();
ich = 0;

colMargin = 0;
colComment = 0-1;

rec = "";
rec.colMargin = colMargin;
rec.colComment = colComment;

while (ich < len)
{
   if (AsciiFromChar(szLine[ich]) == 9)
   {
    colMargin = (((colMargin + tabSize) / tabSize) * tabSize);
   }
   else
   {
    colMargin = colMargin + 1;
   }

   if (colComment < 0)
   {
    if (ich + 1 < len)
    {
     if (szLine[ich] == "/" && szLine[ich+1] == "/")
     {
      colComment = colMargin - 1;
      ich = ich + 2;
      colMargin = colMargin + 1;
      continue;
     }
    }
   }

   if (ich >= ichBegin)
   {
    if (!_tsIsWhitespaceChar(szLine[ich]))
    {
     rec.colMargin = colMargin - 1;
     rec.colComment = colComment;
//     msg(szLine[ich]);
     return rec;
    }
   }

   ich = ich + 1;
}

return rec;
}

macro _tsGetNextCommentString(hbuf, ichSkip, szRemainder, ln, lnLast, colWrap)
{
rec = "";

// Go until we get a string that is at least long enough to fill a line
// or, we run out of lines.
if (szRemainder == "" && ln > lnLast)
   return "";
  
ichFirst = ichSkip;
// msg(ichSkip);
while (1)
{
   if (ln > lnLast)
   {
    rec.szComment = szRemainder;
    rec.ln = ln;
    return rec;
   }

   cchRemainder = strlen(szRemainder);

   if (cchRemainder > colWrap)
   {
    rec.szComment = szRemainder;
    rec.ln = ln;
    return rec;
   }

   szLine = GetBufLine(hbuf, ln);
   len = strlen(szLine);

   if (ichSkip == 0)
    ichFirst = _tsSkipPastCommentAndWhitespace(szLine, len);
   ichSkip = 0;
   
   ichLast = len - 1;

   // Now, strip out all whitespace at the end of the line
   while (ichLast >= ichFirst)
   {
    if (!_tsIsWhitespaceChar(szLine[ichLast]))
    {
     break;
    }
    ichLast = ichLast - 1;
   }

   // Entire line is whitespace?
   if (ichLast < ichFirst)
   {
    if (szRemainder == "")
     ln = ln + 1;
    rec.szComment = szRemainder;
    rec.ln = ln;
    return rec;

   }
   // length of the non whitespaced comment + 1 space + cchRemainder
   if ((ichLast + 1) - ichFirst + cchRemainder + 1 > 255)
   {
    // It may not format the current line quite right, but
    // but at least we won't throw away some of the comment.
    rec.szComment = szRemainder;
    rec.ln = ln;
    return rec;
   }

   if (szRemainder != "")
    szRemainder = cat(szRemainder, " ");
   szRemainder = cat(szRemainder, strmid(szLine, ichFirst, ichLast + 1));
   ln = ln + 1;
}
}

 

macro _tsSkipPastCommentAndWhitespace(szLine, len)
{
ichFirst = 0;
// Skip past the comment initiator "//" if there is one.
while (ichFirst < len)
{
   if (ichFirst + 1 < len)
   {
    if (szLine[ichFirst] == "/" && szLine[ichFirst+1] == "/")
    {
     ichFirst = ichFirst + 2;
     break;
    }
   }
   ichFirst = ichFirst + 1;
}

// If no comment found in line, then start from the beginning
if (ichFirst >= len)
   ichFirst = 0;

ichFirst = ichFirst;
// Now, strip out all whitespace after the comment start.
while (ichFirst < len)
{
   if (!_tsIsWhitespaceChar(szLine[ichFirst]))
   {
    break;
   }
   ichFirst = ichFirst + 1;
}

return ichFirst;
}