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

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

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

使用说明:
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/可以找到很多宏定义文件，但大多数没什么用。
/*附上宏定义文件（一下是我精心挑选的十分好用的宏定义，不试不知道，一试真有用）*/
/* mymacro.em – a small collection of useful editing macros */
/******************************************************************************
* InsFunHeader — insert function’s information
*
* modification history
* ——————–
* 01a, 23mar2003, added DESCRIPTION by t357
* 01a, 05mar2003, t357 written
* ——————–
******************************************************************************/
macro InsFunHeader()
{
// Get the owner’s name from the environment variable: szMyName.
// If the variable doesn’t exist, then the owner field is skipped.

/*#########################################################
#########################################################
####### Set szMyName variable to your name ########
####### for example szMyName = “t357″ ########
#########################################################
#########################################################*/
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 = “/******************************************************************************”
InsBufLine(hbuf, ln, sz)
InsBufLine(hbuf, ln + 1, ” * @szFunc@ – @szInf@”)
InsBufLine(hbuf, ln + 2, ” * DESCRIPTION: – “)
InsBufLine(hbuf, ln + 3, ” * @szDescription@ “)
// remove by t357. CutWord(szDescription)
InsBufLine(hbuf, ln + 4, ” * Input: “)
InsBufLine(hbuf, ln + 5, ” * Output: “)
InsBufLine(hbuf, ln + 6, ” * Returns: “)
InsBufLine(hbuf, ln + 7, ” * “)
InsBufLine(hbuf, ln + 8, ” * modification history”)
InsBufLine(hbuf, ln + 9, ” * ——————–”)
InsBufLine(hbuf, ln + 10, ” * 01a, @szDay@@szMonth@@Year@, @szMyName@ written”)
InsBufLine(hbuf, ln + 11, ” * ——————–”)
InsBufLine(hbuf, ln + 12, ” ******************************************************************************/”)

// put the insertion point inside the header comment
SetBufIns(hbuf, ln + 1, strlen(szFunc) + strlen(szInf) + }
/******************************************************************************
* NumToName — change the month number to name
*
* modification history
* ——————–
* 01a, 05mar2003, t357 written
* ——————–
******************************************************************************/
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 == return “aug”
if (Month == 9)
return “sep”
if (Month == 10)
return “oct”
if (Month == 11)
return “nov”
if (Month == 12)
return “dec”
}

/******************************************************************************
* CutWord — auto newline
*
* modification history
* ——————–
* 01a, 24mar2003, t357 fix some bug
* 01a, 05mar2003, t357 written
* ——————–
******************************************************************************/
macro CutWord(ncurLine, szInf)
{
LENGTH = 63
nlength = StrLen(szInf)
i = 0 /* loop control */
begin = 0 /* first character’s index of current line */
pre = 0 /* preceding word’s index */
hbuf = GetCurrentBuf()
// nline = GetBufLnCur()
while (i < nlength)
{
/* remove by t357
nrow = 0
sz = “”
while (nrow < 80)
{
if (nlength < 0)
break
sz = Cat(sz, szInf[nrow])
nrow = nrow + 1
nlength = nlength – 1
}
InsBufLine(hbuf, nline, sz)
szInf = szInf[nrow]
}
*/
c = szInf[i]
if (” ” == @c@ && (i – b < LENGTH))
{
pre = i
}
else if (” ” == @c@)
{
szOutput = “”
k = begin /* loop control */
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 /* loop control */
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 /* @sz@ */”)
SetBufIns(hbuf, lnFirst + 2, 0)
}
/* A U T O E X P A N D */
/*————————————————————————-
Automatically expands C statements like if, for, while, switch, etc..

To use this macro,
1. Add this file to your project or your Base project.

2. Run the Options->Key Assignments command and assign a
convenient keystroke to the “AutoExpand” command.

3. After typing a keyword, press the AutoExpand keystroke to have the
statement expanded. The expanded statement will contain a ### string
which represents a field where you are supposed to type more.

The ### string is also loaded in to the search pattern so you can
use “Search Forward” to select the next ### field.

For example:
1. you type “for” + AutoExpand key
2. this is inserted:
for (###; ###; ###)
{
###
}
3. and the first ### field is selected.
————————————————————————-*/
/******************************************************************************
* AutoExpand – Automatically expands C statements
*
* DESCRIPTION: – Automatically expands C statements like if, for, while,
* switch, etc..
*
* Input:
* Output:
* Returns:
*
* modification history
* ——————–
* 01a, 27mar2003, t357 modified
* ——————–
******************************************************************************/
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
}
/* G E T W O R D L E F T O F I C H */
/*————————————————————————-
Given an index to a character (ich) and a string (sz),
return a “wordinfo” record variable that describes the
text word just to the left of the ich.

Output:
wordinfo.szWord = the word string
wordinfo.ich = the first ich of the word
wordinfo.ichLim = the limit ich of the word
————————————————————————-*/
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;
}