Cyd
2b8ca921cb
Complete disaster-recovery snapshot: engine/game source, game data assets, VC6 toolchain + DX SDKs, build outputs, deployed game, and _UNUSED archive. Large binaries in Git LFS; text preserved byte-for-byte (core.autocrlf=false, no eol attributes). See RECOVERY.md for the one-clone rebuild procedure.
767 lines
24 KiB
Plaintext
767 lines
24 KiB
Plaintext
'------------------------------------------------------------------------------
|
|
'FILE DESCRIPTION: SAMPLE.DSM is a collection of sample editor macros.
|
|
'------------------------------------------------------------------------------
|
|
|
|
'This routine has many uses if you are trying to determine the type of source
|
|
' file.
|
|
'Return value: 0 Unknown file type
|
|
' 1 C-related file, this includes .c, .cpp, .cxx, .h, .hpp, .hxx
|
|
' 2 Java-related file, this includes .jav, .java
|
|
' 3 ODL-style file, .odl, .idl
|
|
' 4 Resource file, .rc, .rc2
|
|
' 5 HTML-style file, this includes .html, and .htm
|
|
' 6 VBS-style file, .dsm
|
|
' 7 Def-style file, .def
|
|
'USE: Pass this function the document that you wish to get information for.
|
|
Function FileType (ByVal doc)
|
|
ext = doc.Name
|
|
FileType = 0
|
|
pos = Instr(ext, ".")
|
|
if pos > 0 then
|
|
Do While pos <> 1
|
|
ext = Mid(ext, pos, Len(ext) - pos + 1)
|
|
pos = Instr(ext, ".")
|
|
Loop
|
|
ext = LCase(ext)
|
|
end if
|
|
If ext = ".rc" Or ext = ".rc2" Then
|
|
FileType = 4
|
|
ElseIf doc.Language = dsCPP Then
|
|
FileType = 1
|
|
ElseIf doc.Language = dsJava Then
|
|
FileType = 2
|
|
ElseIf doc.Language = dsIDL Then
|
|
FileType = 3
|
|
ElseIf doc.Language = dsHTML_IE3 Or doc.Language = dsHTML_RFC1866 Then
|
|
FileType = 5
|
|
ElseIf doc.Language = dsVBSMacro Then '
|
|
FileType = 6
|
|
ElseIf ext = ".def" Then
|
|
FileType = 7
|
|
Else
|
|
FileType = 0
|
|
End If
|
|
End Function
|
|
|
|
|
|
'This routine has many uses if you are trying to determine if an identifier
|
|
' is a valid C identifier.
|
|
' These identifiers do not include qualification syntax, for example:
|
|
' foo.bar is not valid
|
|
' foo is valid
|
|
'Parameters: String to test for a valid C identifier.
|
|
'Return value: True: passed parameter is a valid C identifier.
|
|
' False: passed parameter is not a valid C identifier.
|
|
Function ValidId(Id)
|
|
ValidId = True
|
|
|
|
'Don't permit an empty string
|
|
' (how can you identify nothing with something?)
|
|
if Id = "" then
|
|
ValidID = False
|
|
Exit Function
|
|
End If
|
|
|
|
For i = 1 To Len(Id)
|
|
if Mid(Id, i, 1) < "a" Or Mid(Id, i, 1) > "z" Then
|
|
if Mid(Id, i, 1) < "A" Or Mid(Id, i, 1) > "Z" Then
|
|
if Mid(Id, i, 1) < "0" Or Mid(Id, i, 1) > "9" Then
|
|
if Mid(Id, i, 1) <> "_" Then
|
|
ValidId = False
|
|
End if
|
|
End If
|
|
End If
|
|
End If
|
|
Next
|
|
If IsNumeric(Left(Id, 1)) = True Then
|
|
ValidId = False
|
|
End If
|
|
End Function
|
|
|
|
|
|
Dim ParamArr () ' Dynamic array to store function arguments.
|
|
|
|
Sub AddFunctionDescription ( )
|
|
'DESCRIPTION: Creates a comment block for the currently selected C/C++ function prototype
|
|
|
|
'Throughout this file, ActiveDocument.Selection is used in place
|
|
'of ActiveDocument.Selection.Text. The two are equivalent, and can
|
|
'be used interchangeably. The reason for the equivalence is that
|
|
'Text is regarded as the default property to use. All uses of
|
|
'ActiveDocument.Selection without any other property default to the Text
|
|
'property.
|
|
if ActiveDocument.Language = dsCPP Then
|
|
Header = StripTabs(Trim(ActiveDocument.Selection))
|
|
|
|
'Get the function return type.
|
|
if Header <> "" then
|
|
Reti = InStr(Header, " ")
|
|
Loc = InStr(Header, "(")
|
|
if Reti < Loc Then
|
|
RetTp = Left(Header, Reti)
|
|
Header = Right(Header, Len(Header) - Reti)
|
|
End If
|
|
|
|
'Get the function name.
|
|
Loc = InStr(Header, "(") - 1
|
|
Loc2 = InStr(Header, ")")
|
|
if Loc > 0 And Loc2 > 0 then 'make sure there is a '(' and a ')'
|
|
fcName = Left(Header, Loc)
|
|
Header = Right(Header, Len(Header) - Len(fcName))
|
|
|
|
'Do we have storage type on the return type?
|
|
Trim (fcName)
|
|
If InStr(fcName," ") <> 0 Then
|
|
retTp = retTp + Left(fcName,InStr (fcName," "))
|
|
fcName = Right(fcName, Len(fcName) - InStr(fcName," "))
|
|
End If
|
|
|
|
'Get the function parameters.
|
|
iPrm = 0
|
|
iPrmA = 0
|
|
prms = Header
|
|
|
|
'Count the number of parameters.
|
|
Do While InStr(prms, ",") <> 0
|
|
iPrm = iPrm + 1
|
|
prms = Right(prms, Len(prms) - InStr(prms, ","))
|
|
Loop
|
|
|
|
'Store the parameter list in the array.
|
|
If iPrm > 0 Then ' If multiple params.
|
|
iPrm = iPrm + 1
|
|
iPrmA = iPrm
|
|
Redim ParamArr(iPrm)
|
|
Do While InStr(header, ",") <> 0
|
|
ParamArr(iPrm) = Left(Header, InStr (Header, ",") - 1)
|
|
'Remove brace from first parameter.
|
|
If InStr(ParamArr(iPrm), " (") <> 0 Then
|
|
ParamArr(iPrm) = Right(ParamArr(iPrm), _
|
|
Len(ParamArr(iPrm))-InStr(ParamArr(iPrm)," ("))
|
|
Trim(ParamArr(iPrm))
|
|
End If
|
|
Header = Right(Header, Len(Header) - InStr(Header,","))
|
|
iPrm = iPrm - 1
|
|
Loop
|
|
ParamArr(iPrm) = Header
|
|
'Remove trailing brace from last parameter.
|
|
If InStr(ParamArr(iPrm), ")") <> 0 Then
|
|
ParamArr(iPrm) = Left(ParamArr(iPrm), _
|
|
InStr(ParamArr(iPrm), ")") - 1)
|
|
Trim(ParamArr(iPrm))
|
|
End If
|
|
Else 'Possibly one param.
|
|
Redim ParamArr(1)
|
|
Header = Right(Header, Len(Header) - 1) ' Strip the first brace.
|
|
Trim(Header)
|
|
ParamArr(1) = StripTabs(Header)
|
|
If InStr(ParamArr(1), ")") <> 1 Then
|
|
ParamArr(1) = Left(ParamArr(1), InStr(ParamArr(1), ")") - 1)
|
|
Trim(ParamArr(1))
|
|
iPrmA = 1
|
|
End If
|
|
End If
|
|
|
|
'Position the cursor one line above the selected text.
|
|
ActiveDocument.Selection.LineUp
|
|
ActiveDocument.Selection.LineDown
|
|
ActiveDocument.Selection.StartOfLine
|
|
ActiveDocument.Selection = vbLf
|
|
|
|
Descr = "// Function name : " + fcName + _
|
|
vbLf + "// Description : " + _
|
|
vbLf + "// Return type : " + RetTp + vbLf
|
|
|
|
'Print the parameter list.
|
|
Last = iPrmA
|
|
Do While iPrmA <> 0
|
|
'Remove a line feed from any of the arguments.
|
|
If InStr(ParamArr(iPrmA), vbLf) <> 0 Then
|
|
ParamArr(iPrmA) = Right(ParamArr(iPrmA), _
|
|
(Len(ParamArr(iPrmA)) - _
|
|
InStr(ParamArr(iPrmA), vbLf)))
|
|
Trim(ParamArr(iPrmA))
|
|
End If
|
|
ParamArr(iPrmA) = StripTabs(ParamArr(iPrmA))
|
|
'If there are 2+ parameters, the first parameter will
|
|
'have a '(' prepended to it, remove it here:
|
|
if iPrmA = Last AND Last <> 1 then
|
|
ParamArr(iPrmA) = Right(ParamArr(iPrmA), _
|
|
Len(ParamArr(iPrmA)) - 1)
|
|
End If
|
|
Descr = Descr + "// Argument : " + _
|
|
ParamArr(iPrmA) + vbLf
|
|
iPrmA = iPrmA - 1
|
|
Loop
|
|
ActiveDocument.Selection = Descr
|
|
Else
|
|
MsgBox("It is possible that the function you are trying to"+_
|
|
" work with has a syntax error.")
|
|
End if
|
|
End If
|
|
Else
|
|
MsgBox("You need to have an active C/C++ document open"+ _
|
|
vbLF+"with the function prototype selected.")
|
|
End If
|
|
End Sub
|
|
|
|
'Strips the leading tab spaces.
|
|
Function StripTabs (ByVal MyStr)
|
|
Do While InStr(MyStr, vbTab) <> 0
|
|
MyStr = Right(MyStr, Len(MyStr) - InStr(MyStr, vbTab))
|
|
Loop
|
|
StripTabs = Trim(MyStr)
|
|
End Function
|
|
|
|
Sub ToggleCommentStyle ( )
|
|
'DESCRIPTION: Toggles between comment styles /* and //.
|
|
|
|
TmpBlock = ""
|
|
CmtBlock = ActiveDocument.Selection
|
|
TypeOfFile = FileType(ActiveDocument)
|
|
If TypeOfFile > 0 And TypeOfFile < 5 Then 'C/C++ style comment.
|
|
'Get the first two characters of the comment block.
|
|
Trim(CmtBlock)
|
|
If Instr(CmtBlock,"//") <> 0 Then
|
|
Do While Instr (CmtBlock,"//") <> 0
|
|
TmpBlock = TmpBlock + Left (CmtBlock, Instr (CmtBlock,"//") - 1)
|
|
CmtBlock = Right(CmtBlock, (Len(CmtBlock) - (Instr(CmtBlock,_
|
|
"//") + 1)))
|
|
Loop
|
|
CmtBlock = "/*" + TmpBlock + CmtBlock + "*/"
|
|
ElseIf Instr(CmtBlock, "/*") <> 0 Then
|
|
CmtBlock = Right(CmtBlock, Len(CmtBlock) - (Instr(CmtBlock,"/*")_
|
|
+ 1))
|
|
Do While Instr (CmtBlock, vbLf) <> 0
|
|
TmpBlock = TmpBlock + Left (CmtBlock, Instr(CmtBlock, vbLf))_
|
|
+ "//"
|
|
CmtBlock = Right(CmtBlock, (Len(CmtBlock) - (Instr(CmtBlock,_
|
|
vbLf))))
|
|
Loop
|
|
CmtBlock = "//" + TmpBlock + Trim(CmtBlock)
|
|
CmtBlock = Left(CmtBlock, Instr(CmtBlock,"*/")-1)
|
|
End If
|
|
ActiveDocument.Selection.Delete
|
|
ActiveDocument.Selection = CmtBlock
|
|
Else
|
|
MsgBox "This macro does not work on this type of file."
|
|
End If
|
|
|
|
End Sub
|
|
|
|
|
|
|
|
Sub AddRevisionMarks ( )
|
|
'DESCRIPTION: Adds comments to a file that describe the changes made.
|
|
|
|
'This routine adds a new comment block to the top of a file, where the
|
|
' programmer can place revision marks to describe the changes made to the file.
|
|
'The rules this routine uses are as follows:
|
|
' 1) Start at the top of the file.
|
|
' 2) Scan through each line; if the current line starts with a comment,
|
|
' advance to the next line..
|
|
' 3) If we are currently in a group comment block, keep advancing until
|
|
' the end of the block is found.
|
|
' 4) If we are in a line item comment (e.g.: //, ', rem, etc), keep advancing
|
|
' until a line that does not start with a comment is found.
|
|
' By 'start with a comment', it is meant a line, where after
|
|
' stripping off spaces and tabs from the beginning, the first set of
|
|
' characters is not a comment delimiter.
|
|
' 5) Insert a blank line; this allows the next invocation of this macro
|
|
' to place the newer revision mark before all others.
|
|
' 6) Insert the revision block.
|
|
|
|
'Change this to the programmer's name for a default.
|
|
DefaultUserName = "..."
|
|
|
|
'Because the user may not have closed a comment (e.g. a /* without a */),
|
|
' try to protect ourselves from an infinite loop...
|
|
BreakAfter = 10 'Max number of lines to look at scan before aborting
|
|
CurrentCount = 1
|
|
|
|
BeginComment = "" 'The token for the specified language for the beginning
|
|
' of a comment.
|
|
EndComment = "" 'Same, except for the end of a comment.
|
|
EveryLine = "" 'Does the comment mark need to be placed on every line
|
|
' (VBS, DEF types)?
|
|
|
|
'First, make sure the active document is a text window
|
|
' (Not really necessary, but good practice).
|
|
If ActiveDocument.Type = "Text" Then
|
|
TypeOfFile = FileType(ActiveDocument)
|
|
|
|
'Set ourselves at the very top of the document.
|
|
'This also clears any selection made.
|
|
ActiveDocument.Selection.StartOfDocument
|
|
ActiveDocument.Selection.SelectLine
|
|
CurrText = ActiveDocument.Selection
|
|
CurrText = LTrim(CurrText)
|
|
|
|
'All of the following do relatively the same thing,
|
|
' except they look for different comment types.
|
|
If TypeOfFile > 0 And TypeOfFile < 5 Then 'C/C++ family of code
|
|
ContSearch = True
|
|
BeginComment = "/*"
|
|
EndComment = "*/"
|
|
EveryLine = " "
|
|
|
|
'In C/C++ style code, we need to look for a //;
|
|
' if not found, then look for a /*.
|
|
Do
|
|
ActiveDocument.Selection = CurrText
|
|
If InStr(CurrText, "//") = 1 Then 'is a "//" available?
|
|
ActiveDocument.Selection.SelectLine
|
|
CurrText = LTrim(ActiveDocument.Selection) 'Remove whitespace.
|
|
ContSearch = False ' Looking at // style comments,
|
|
'don't look for a /* style.
|
|
Else
|
|
Exit Do
|
|
End If
|
|
Loop
|
|
|
|
If ContSearch = False Then
|
|
ActiveDocument.Selection.LineUp
|
|
End If
|
|
|
|
'When the method ActiveDocument.Selection.SelectLine is called,
|
|
' it is the same as when you click the mouse in the margin; it
|
|
' selects the whole line, including the carriage return.
|
|
' Because of this, the cursor comes down to the next line, which
|
|
' can really confuse this algorithm. So in a number of places,
|
|
' you will see a grouping of LineUp/LineDown commands. By executing
|
|
' these commands, the cursor is moved down, which clears the current
|
|
' selection (including getting us past the carriage return),
|
|
' then moves us back up, thus putting us on the same line. This
|
|
' removesthe danger of skipping a line (which is what will
|
|
' happen without the LineUp/LineDown combination).
|
|
If ContSearch = True Then
|
|
ActiveDocument.Selection.StartOfDocument
|
|
'Prime the loop with the first line.
|
|
ActiveDocument.Selection.SelectLine
|
|
CurrText = ActiveDocument.Selection
|
|
ActiveDocument.Selection.LineDown
|
|
ActiveDocument.Selection.LineUp
|
|
'Remove leading whitespace.
|
|
CurrText = LTrim(CurrText)
|
|
'Does line start with a /*?
|
|
If InStr(CurrText,"/*") = 1 Then
|
|
while (InStr(CurrText, "*/") = 0) And _
|
|
(BreakAfter > CurrentCount)
|
|
ActiveDocument.Selection.SelectLine
|
|
CurrText = ActiveDocument.Selection
|
|
CurrText = LTrim(CurrText)
|
|
ActiveDocument.Selection.LineDown
|
|
ActiveDocument.Selection.LineUp
|
|
CurrentCount = CurrentCount + 1
|
|
wend
|
|
If (BreakAfter > CurrentCount) Then
|
|
'Exit the loop because the search has gone on for an
|
|
' unreasonable number of lines.
|
|
MsgBox "Could not find a closing comment mark"
|
|
End If
|
|
End If
|
|
End If
|
|
|
|
'The code for these is really just a copy of that from the
|
|
' C/C++ section...
|
|
|
|
ElseIf TypeOfFile = 5 Then 'HTML code
|
|
BeginComment = "<!--"
|
|
EndComment = "-->"
|
|
EveryLine = " "
|
|
If InStr(CurrText,"<!--") = 1 Then
|
|
If InStr(CurrText,"-->") <> 0 Then
|
|
ActiveDocument.Selection.LineDown
|
|
Else
|
|
Do
|
|
ActiveDocument.Selection.SelectLine
|
|
CurrText = ActiveDocument.Selection
|
|
CurrText = Left(CurrText, Len(CurrText) - 2)
|
|
ActiveDocument.Selection = CurrText + vbLf
|
|
If InStr(CurrText, "-->") Then
|
|
Exit Do
|
|
End If
|
|
Loop
|
|
End If
|
|
End If
|
|
|
|
ElseIf TypeOfFile = 6 Then 'VBS code
|
|
BeginComment = "'"
|
|
EndComment = "'"
|
|
EveryLine = "'"
|
|
Do
|
|
ActiveDocument.Selection = CurrText
|
|
If InStr(CurrText, "'") = 1 Or _
|
|
InStr(LCase(CurrText), "Rem") = 1 Then
|
|
ActiveDocument.Selection.SelectLine
|
|
CurrText = LTrim(ActiveDocument.Selection)
|
|
ContSearch = False
|
|
Else
|
|
Exit Do
|
|
End If
|
|
Loop
|
|
If ContSearch = False Then
|
|
ActiveDocument.Selection.LineUp
|
|
End If
|
|
|
|
ElseIf TypeOfFile = 7 Then 'DEF code
|
|
BeginComment = ";"
|
|
EndComment = ""
|
|
EveryLine = ";"
|
|
Do
|
|
ActiveDocument.Selection = CurrText
|
|
If InStr(CurrText, ";") = 1 Then
|
|
ActiveDocument.Selection.SelectLine
|
|
CurrText = LTrim(ActiveDocument.Selection)
|
|
ContSearch = False
|
|
Else
|
|
Exit Do
|
|
End If
|
|
Loop
|
|
If ContSearch = False Then
|
|
ActiveDocument.Selection.LineUp
|
|
End If
|
|
End If
|
|
|
|
If TypeOfFile = 0 Then 'Unknown type of code.
|
|
MsgBox("Unable to add revision marks. Unrecgonized file type")
|
|
ElseIf (CurrentCount < BreakAfter) Then
|
|
'The BeginComment, EveryLine, and EndComment were set as
|
|
' avoid duplicating this section...
|
|
' just insert the generalized block, with the comment markers.
|
|
ActiveDocument.Selection.StartOfLine(True)
|
|
'This is added with one assignment statement, which enables the user
|
|
' to hit undo once, and remove the entire change.
|
|
ActiveDocument.Selection = vbLf + _
|
|
BeginComment + "***********************************" + vbLf + _
|
|
EveryLine + " REVISION LOG ENTRY" + vbLf + _
|
|
EveryLine + " Revision By: " + DefaultUserName + vbLf + _
|
|
EveryLine + " Revised on " + CStr(Now) + vbLf + _
|
|
EveryLine + " Comments: ..." + vbLf + _
|
|
EveryLine + "***********************************" + _
|
|
EndComment + vbLf + vbLf
|
|
End If
|
|
End If
|
|
End Sub
|
|
|
|
|
|
Sub CloseExceptActive ()
|
|
'DESCRIPTION: Closes all editor windows except the current one.
|
|
|
|
'Windows.Item(1) is always the currently active window. So to close all
|
|
' the windows except the active one, keep looping until there is no
|
|
' longer a Windows.Item(2).
|
|
do while Windows.Count > 1
|
|
Windows.Item(2).Close(dsSaveChangesPrompt)
|
|
Loop
|
|
End Sub
|
|
|
|
|
|
Sub CommentOut ()
|
|
'DESCRIPTION: Comments out a selected block of text.
|
|
Dim win
|
|
set win = ActiveWindow
|
|
if win.type <> "Text" Then
|
|
MsgBox "This macro can only be run when a text editor window is active."
|
|
else
|
|
TypeOfFile = FileType(ActiveDocument)
|
|
If TypeOfFile > 0 And TypeOfFile < 5 Then 'C & Java use the same
|
|
'style of comments.
|
|
ActiveDocument.Selection = "/*" + ActiveDocument.Selection + "*/"
|
|
ElseIf TypeOfFile = 5 Then
|
|
ActiveDocument.Selection = "<!-- " + ActiveDocument.Selection + " -->"
|
|
ElseIf TypeOfFile = 6 Or TypeOfFile = 7 Then
|
|
'There is no group comment like there is in the other file types,
|
|
'so we need to iterate through each line, and prepend a ' to the line.
|
|
'Also, because VBS/DEF does not have a 'end the comment at this
|
|
'particular column' delimiter, entire lines of code must be
|
|
'commented out, not sections.
|
|
If TypeOfFile = 6 Then
|
|
CommentType = " ' "
|
|
Else
|
|
CommentType = " ; "
|
|
End If
|
|
|
|
StartLine = ActiveDocument.Selection.TopLine
|
|
EndLine = ActiveDocument.Selection.BottomLine
|
|
If EndLine < StartLine Then
|
|
Temp = StartLine
|
|
StartLine = EndLine
|
|
EndLine = Temp
|
|
End If
|
|
|
|
If EndLine = StartLine Then
|
|
ActiveDocument.Selection = CommentType + ActiveDocument.Selection
|
|
|
|
Else
|
|
For i = StartLine To EndLine
|
|
ActiveDocument.Selection.GoToLine i
|
|
ActiveDocument.Selection.SelectLine
|
|
ActiveDocument.Selection = CommentType + _
|
|
ActiveDocument.Selection
|
|
Next
|
|
End If
|
|
Else
|
|
MsgBox("Unable to comment out the highlighted text" + vbLf + _
|
|
"because the file type was unrecognized." + vbLf + _
|
|
"If the file has not yet been saved, " + vbLf + _
|
|
"please save it and try again.")
|
|
End If
|
|
End If
|
|
End Sub
|
|
|
|
|
|
Sub MultiplePaste ()
|
|
'DESCRIPTION: Performs a paste of what is on the clipboard a multiple number of times.
|
|
|
|
NumPastes = InputBox("Number of pastes to make", "Multiple Paste Macro",_
|
|
"1")
|
|
For i = 1 To CInt(NumPastes)
|
|
ActiveDocument.Selection.Paste
|
|
'Because the selection remains active, the following two lines
|
|
'clear the selection, while keeping the cursor in the same place.
|
|
ActiveDocument.Selection.LineUp
|
|
ActiveDocument.Selection.LineDown
|
|
ActiveDocument.Selection = vbLf
|
|
Next
|
|
End Sub
|
|
|
|
|
|
Sub PrintAllOpenDocuments ()
|
|
'DESCRIPTION: Prints all open, active documents.
|
|
|
|
'Small, quick macro, but it can be usefull.
|
|
for each doc in Application.Documents
|
|
Doc.PrintOut
|
|
next
|
|
End Sub
|
|
|
|
|
|
Sub PoundDefOut (ifndef)
|
|
If ifndef = true Then
|
|
PoundType = "#ifndef "
|
|
Else
|
|
PoundType = "#ifdef "
|
|
End If
|
|
|
|
If FileType(ActiveDocument) <> 1 Then
|
|
MsgBox ("This macro only works on" + vbLf + _
|
|
".c, .cpp, .cxx, .h, .hpp, or .hxx files")
|
|
Else
|
|
ControlVarName = InputBox("What should the control variable be?" + _
|
|
vbLf + vbLf + "Example: #ifdef ControlVariable", PoundType + _
|
|
" out a section of code")
|
|
OK = True
|
|
If ValidId (ControlVarName) = False Then
|
|
Ok = False
|
|
MsgBox("""" + ControlVarName + """" + _
|
|
" is not a valid C identifier." + _
|
|
vbLf + "please re-run the macro with a valid C identifier")
|
|
End If
|
|
|
|
|
|
Sel = ActiveDocument.Selection
|
|
For i = 1 To Len(Sel) - 1
|
|
If Mid(Sel, i, 1) = vbLf Then
|
|
Sel = Left(Sel,i) + vbTab + Right(Sel, Len(Sel)-i)
|
|
End If
|
|
Next
|
|
If ControlVarName <> "" And Ok = True Then
|
|
Sel = vbLf + PoundType + ControlVarName + vbLf + vbTab + Sel + _
|
|
vbLf+ "#endif //" + ControlVarName
|
|
If Right(Sel,1) <> vbLf Then
|
|
Sel = Sel + vbLf
|
|
End If
|
|
ActiveDocument.Selection = Sel
|
|
End If
|
|
End If
|
|
End Sub
|
|
|
|
'The next two macros are exactly the same, except one uses ifndef and the
|
|
' other ifdef. We recycle the same code and just use a different
|
|
' preprocessor directive.
|
|
Sub ifdefOut ()
|
|
'DESCRIPTION: #ifdef / #endif out a section of code.
|
|
|
|
PoundDefOut (False)
|
|
End Sub
|
|
|
|
Sub ifndefOut ()
|
|
'DESCRIPTION: #ifndef / #endif out a section of code.
|
|
|
|
PoundDefOut (True)
|
|
End Sub
|
|
|
|
'Allows the user to make sure the current header file is included only once.
|
|
' There are two ways to do this, using the #pragma once directive or
|
|
' surrounding the entire file in a #ifndef/#endif structure. The first way
|
|
' is much cleaner, but it is VC++ specific, and therefore not portable. If
|
|
' you plan on compiling your code with other compilers, use the
|
|
' #ifndef/#endif method, otherwise, the #pragma once option is preferrable.
|
|
Sub OneTimeInclude ()
|
|
'DESCRIPTION: Adds code to the current header file so it is included only once per c/cpp file.
|
|
|
|
ext = ActiveDocument.Name
|
|
If ext = "" Then
|
|
If MsgBox("The file you are working with does not have a file extension." + _
|
|
vbLF + "Are you sure this is a C/C++ header file?", 4) = vbCancel Then
|
|
Exit Sub
|
|
End If
|
|
ext = "nofilenamegiven.h"
|
|
End If
|
|
DocName = UCase(ext)
|
|
pos = Instr(ext, ".")
|
|
Do While pos <> 1
|
|
ext = Mid(ext, pos, (Len(ext) - pos + 1))
|
|
pos = Instr(ext, ".")
|
|
Loop
|
|
ext = LCase(ext)
|
|
pos = Instr(DocName, ".")
|
|
If ext = ".h" Or ext = ".hpp" Then
|
|
'Warn user that this will not work with a compiler other than VC++.
|
|
If MsgBox("This macro uses the Visual C++ dependant #pragma once" + _
|
|
vbLf + "Is the source to be portable across compilers?", 4) _
|
|
= 6 Then
|
|
ActiveDocument.Selection.StartOfDocument (False)
|
|
Examp = "__" + Left(DocName, pos - 1) + "_" + _
|
|
UCase(Right(ext, len(ext) - 1)) + "__"
|
|
ControlVarName = InputBox("What should the control variable be?" _
|
|
+ vbLf + vbLf + "Example: #ifdef " + _
|
|
Examp, "One time header include protection", Examp)
|
|
If ValidId (ControlVarName) = True Then
|
|
ActiveDocument.Selection = "#ifndef " + ControlVarName + _
|
|
vbLf + "#define " + ControlVarName + vbLf
|
|
ActiveDocument.Selection.EndOfDocument(False)
|
|
ActiveDocument.Selection = vbLf + "#endif //" + _
|
|
ControlVarName
|
|
Else
|
|
MsgBox(ControlVarName + " is not a valid c identifier." + _
|
|
vbLf + "please re-run the macro with a valid C identifier")
|
|
End If
|
|
Else
|
|
ActiveDocument.Selection.StartOfDocument(False)
|
|
ActiveDocument.Selection = "#pragma once" + vbLf + vbLf
|
|
End If
|
|
Else
|
|
MsgBox("This macro can only be run on .h or .hpp files")
|
|
End If
|
|
End Sub
|
|
|
|
|
|
|
|
'Auto completion macro
|
|
Dim previousSelection
|
|
Dim completionWords
|
|
Dim completionWordsIndex
|
|
|
|
Sub AddToCompletionWords (word)
|
|
' If the word is already there, abort
|
|
if InStr(1, completionWords, " " & word & " ", 1) <> 0 Then
|
|
Exit Sub
|
|
End If
|
|
|
|
completionWords = completionWords & word & " "
|
|
End Sub
|
|
|
|
Function ExtractNextCompletionWord()
|
|
ExtractNextCompletionWord = ""
|
|
|
|
' If no words yet, go away
|
|
if Len(completionWords) <= 1 Then
|
|
Exit Function
|
|
End If
|
|
|
|
' Wrap to beginning if necessary
|
|
if completionWordsIndex > Len(completionWords) Then
|
|
completionWordsIndex = 2
|
|
End If
|
|
|
|
' Find next <space>
|
|
Dim newIndex
|
|
newIndex = InStr (completionWordsIndex, completionWords, " ", 0)
|
|
if newIndex = 0 Then
|
|
Exit Function
|
|
End If
|
|
|
|
ExtractNextCompletionWord = Mid(completionWords, completionWordsIndex, _
|
|
newIndex-completionWordsIndex)
|
|
completionWordsIndex = newIndex+1 'Skip over <space>
|
|
End Function
|
|
|
|
Sub FillCompletionWords (word)
|
|
' Find all words in this file which match word, and
|
|
' add them, space separated, into completionWords
|
|
previousSelection = word
|
|
completionWords = " "
|
|
completionWordsIndex = 2
|
|
dim sel
|
|
set sel = ActiveDocument.Selection
|
|
|
|
Dim searchString
|
|
searchString = "\{^\![^a-zA-Z0-9]\}" & word
|
|
Dim firstTime
|
|
firstTime = True
|
|
Dim firstLine, firstCol
|
|
Do while sel.FindText (searchString, dsMatchBackward + dsMatchRegExp)
|
|
if firstTime Then
|
|
firstLine = sel.TopLine
|
|
firstCol = sel.CurrentColumn
|
|
firstTime = False
|
|
ElseIf firstLine = sel.TopLine And firstCol = sel.CurrentColumn Then
|
|
Exit Do ' Jump out of loop before repeat
|
|
End If
|
|
sel.WordRight
|
|
sel.WordLeft dsExtend
|
|
AddToCompletionWords Trim(sel.text)
|
|
sel.Cancel
|
|
Loop
|
|
End Sub
|
|
|
|
Function SuggestNextCompletionWord()
|
|
SuggestNextCompletionWord = True
|
|
Dim word
|
|
word = ExtractNextCompletionWord()
|
|
if word <> "" then
|
|
ActiveDocument.Selection = word
|
|
previousSelection = word
|
|
end if
|
|
End Function
|
|
|
|
Sub AutoCompleteFromFile()
|
|
'DESCRIPTION: Looks through the active file, searching for the rest of the word that you began to type.
|
|
Dim doc
|
|
set doc = ActiveDocument
|
|
|
|
' Be sure active document is a text document
|
|
if doc Is Nothing Then
|
|
Exit Sub
|
|
elseif doc.Type <> "Text" Then
|
|
Exit Sub
|
|
End If
|
|
|
|
' Get word to be completed
|
|
Dim sel
|
|
set sel = doc.Selection
|
|
sel.Cancel
|
|
dim origLine, origCol
|
|
origLine = sel.TopLine
|
|
origCol = sel.CurrentColumn
|
|
sel.WordLeft dsExtend
|
|
|
|
'If the cursor is sitting just to the right of a space, an infinite loop
|
|
'results. This bit of code protects from that:
|
|
if Right(sel, 1) = " " then
|
|
sel.CharRight
|
|
Exit Sub
|
|
end If
|
|
|
|
if sel <> previousSelection Or completionWords = "" Then
|
|
FillCompletionWords sel
|
|
sel.MoveTo origLine, origCol
|
|
sel.WordLeft dsExtend
|
|
End If
|
|
|
|
SuggestNextCompletionWord
|
|
|
|
End Sub
|