25 Years of Programming
An open source source for C, C++, OWL, BASIC, MDB, XLS, DOT, and more... 		Home   Projects   Up   Sitemap   Search   Blog   Forum+Chat   About Us   Privacy   Terms of Use   Feedback   FAQ   Images   Services   Ads   Donate   Humor

Microsoft Word 2003 Visual Basic macros to reformat C, C++, and ASM source code

The CPROGRAM.DOT Microsoft Word 2003 template contains several Visual Basic macros that fix up, reformat, and beautify C, C++, and assembly language source code files. The macros were auto-converted from the Word 6.0 WordBasic versions by Word 2003.

If you download the project here (cprogramdot2003.zip, 54 KB), the code is already in the template.

The main purpose of this template is its reformatting capabilities. You would normally:

  1. Open your source file (just this once) in Word.
  2. Use the AttachCProgramDOT macro (which you should place in Normal.dot) to
    attach CPROGRAM.DOT to the file and set the tab stops properly,
  3. Do the reformatting,
  4. Re-save the file as Text Only.

ASMChangeCase

Attribute VB_Name = "ASMChangeCase"

Public Sub MAIN()
Attribute MAIN.VB_Description = "Changes the case of comments in an assembly language program (comments marked with ;)"
Attribute MAIN.VB_ProcData.VB_Invoke_Func = "TemplateProject.ASMChangeCase.MAIN"
Dim casetype
Dim OldFontName$
Dim OldFontSize
Rem Macro ASMChangeCase
Rem CHANGES CASE OF COMMENTS IN AN ASSEMBLY LANGUAGE PROGRAM.
Rem WHERE COMMENTS ARE MARKED WITH A SEMI-COLON (;) (SUCH AS MASM)
Rem Copyright (C)1996, 1998, 2006 Steven Whitney.
Rem Published under GNU GPL (General Public License) Version 2, with ABSOLUTELY NO WARRANTY.
Rem 2-18-96, changes 10-1-98 to allow sentence case.

Rem USER INPUT
Let casetype = 5
While ((casetype < 0) Or (casetype > 2))
    casetype = WordBasic.Val(WordBasic.[InputBox$]("0=Sentence  1=lower  2=UPPER: ", "Change case of comments to...", "2"))
Wend

Rem TEMPORARILY CHANGE THE DOCUMENT TO A TINY FONT, SO NONE OF THE DOCUMENT'S
Rem LINES ARE WRAPPED TO A FOLLOWING LINE.  IF THAT HAPPENS, THE WRAPPED
Rem PORTION OF A COMMENT WOULD NOT BE CAUGHT AND CHANGED.

WordBasic.StartOfDocument
Rem SAVE CURRENT SETTINGS:
OldFontName$ = WordBasic.[Font$]()
OldFontSize = WordBasic.FontSize()

Rem CHANGE FONT TO ARIAL 8
WordBasic.EditSelectAll
WordBasic.Font "Arial", 8

Rem SEARCH FOR ASM COMMENTS: ;
WordBasic.StartOfDocument
WordBasic.EditFindClearFormatting
WordBasic.EditFind Find:=";", Direction:=0, MatchCase:=0, WholeWord:=0, PatternMatch:=0, SoundsLike:=0, Format:=0, Wrap:=0
While WordBasic.EditFindFound()
    WordBasic.EndOfLine 1
    WordBasic.FormatChangeCase Type:=casetype
    WordBasic.CharRight
    WordBasic.RepeatFind
Wend
WordBasic.StartOfDocument
WordBasic.EditSelectAll
WordBasic.Font OldFontName$, OldFontSize
WordBasic.StartOfDocument
End Sub

AutoIndent

Attribute VB_Name = "AutoIndent"

Public Sub MAIN()
Attribute MAIN.VB_Description = "C-style autoindenting when user types Ctrl+Enter."
Attribute MAIN.VB_ProcData.VB_Invoke_Func = "TemplateProject.AutoIndent.MAIN"
Dim B
Dim E
Dim CPMoved
Dim A$
Dim TabCount
Dim I
Rem 1-7-99 macro AUTOINDENT.
Rem Copyright (C)1999, 2006 Steven Whitney.
Rem Published under GNU GPL (General Public License) Version 2, with ABSOLUTELY NO WARRANTY.
Rem WHEN USER TYPES CTRL+ENTER, MAINTAINS CURRENT INDENT
Rem LEVEL FOR THE NEXT LINE, USING TABS, PLUS 1 IF THE LINE JUST FINISHED CONTAINED
Rem AN OPENING { BUT NO CLOSING }.
Rem YOU CAN'T ASSIGN A MACRO TO THE ENTER KEY.
Rem *HOWEVER*, YOU CAN REMAP YOUR KEYBOARD (or assign macros) SO THAT
Rem <ENTER> AND <CTRL>+<ENTER> ARE INTERCHANGED.
Rem FOR NOW, I HAVE THIS ASSIGNED TO CTRL-ENTER.
Rem not completely tested, but seems ok so far.

Rem //////////////////////////////////////////////////////////////////////////////
Rem IF THERE IS A SELECTION, JUST INSERT THE CR, SINCE USER WANTED TO REPLACE
Rem THE SELECTION WITH A CR.

B = WordBasic.GetSelStartPos()
E = WordBasic.GetSelEndPos()

If B <> E Then
    WordBasic.InsertPara
    GoTo bye
End If

CPMoved = WordBasic.StartOfLine(1)
A$ = WordBasic.[Selection$]()

Rem IF ALREADY AT THE START OF THE LINE (& nothing was selected), DON'T CHAR RIGHT,
If CPMoved <> 0 Then WordBasic.CharRight
WordBasic.InsertPara
TabCount = CountLeadingTabs(A$) + OneMore(A$)
For I = 1 To TabCount
    WordBasic.Insert Chr(9)
Next I

bye:

End Sub

Rem //////////////////////////////////////////////////////////////////////////////
Private Function CountLeadingTabs(A$)
Dim Count_
Dim I
Count_ = 0
I = 1
While I <= Len(A$)
    If Mid(A$, I, 1) = Chr(9) Then
        Count_ = Count_ + 1
    Else                        ' first nontab ends search
        I = Len(A$)             ' force loop end next pass
    End If
    I = I + 1
Wend
CountLeadingTabs = Count_
End Function
Rem //////////////////////////////////////////////////////////////////////////////
Private Function OneMore(A$)
If InStr(A$, "{") > 0 And InStr(A$, "}") = 0 Then
    OneMore = 1
Else
    OneMore = 0
End If
End Function

CommentChangeCase

Attribute VB_Name = "CommentChangeCase"

Public Sub MAIN()
Attribute MAIN.VB_Description = "Changes the case of comments in a C or CPP program (catches both /* */ and // comments.)"
Attribute MAIN.VB_ProcData.VB_Invoke_Func = "TemplateProject.CommentChangeCase.MAIN"
Dim casetype
Dim OldFontName$
Dim OldFontSize
Rem 2-18-96, changes 10-1-98 to allow sentence case.
Rem Copyright (C)1996, 1998, 2006 Steven Whitney.
Rem Published under GNU GPL (General Public License) Version 2, with ABSOLUTELY NO WARRANTY.
Rem CHANGES CASE OF COMMENTS IN A C OR C++ PROGRAM.
Rem LOWER OR SENTENCE CASE IS BEST WHILE WORKING ON A PROGRAM.
Rem UPPER CASE SEPARATES COMMENTS FROM CODE WELL ON PRINTOUTS.

Rem USER INPUT
Let casetype = 5
While ((casetype < 0) Or (casetype > 2))
    casetype = WordBasic.Val(WordBasic.[InputBox$]("0=Sentence  1=lower  2=UPPER: ", "Change case of comments to...", "1"))
Wend

Rem TEMPORARILY CHANGE THE DOCUMENT TO A TINY FONT, SO NONE OF THE DOCUMENT'S
Rem LINES ARE WRAPPED TO A FOLLOWING LINE.  IF THAT HAPPENS, THE WRAPPED
Rem PORTION OF A // COMMENT WOULD NOT BE CAUGHT AND CHANGED.

WordBasic.StartOfDocument
Rem SAVE CURRENT SETTINGS:
OldFontName$ = WordBasic.[Font$]()
OldFontSize = WordBasic.FontSize()

Rem CHANGE FONT TO SMALL ARIAL
WordBasic.EditSelectAll
WordBasic.Font "Arial", 8

Rem SEARCH FOR C STYLE COMMENTS: /* */
WordBasic.StartOfDocument
WordBasic.EditFindClearFormatting
WordBasic.EditFind Find:="(/\*)*(\*/)", Direction:=0, MatchCase:=0, WholeWord:=0, PatternMatch:=1, SoundsLike:=0, Format:=0, Wrap:=0
While WordBasic.EditFindFound()
    WordBasic.FormatChangeCase Type:=casetype
    WordBasic.RepeatFind
Wend

Rem SEARCH FOR C++ STYLE COMMENTS: //
WordBasic.StartOfDocument
WordBasic.EditFindClearFormatting
WordBasic.EditFind Find:="//", Direction:=0, MatchCase:=0, WholeWord:=0, PatternMatch:=0, SoundsLike:=0, Format:=0, Wrap:=0
While WordBasic.EditFindFound()
    WordBasic.EndOfLine 1
    WordBasic.FormatChangeCase Type:=casetype
    WordBasic.CharRight
    WordBasic.RepeatFind
Wend
WordBasic.StartOfDocument
WordBasic.EditSelectAll
WordBasic.Font OldFontName$, OldFontSize
WordBasic.StartOfDocument
End Sub

FormatCPP

Attribute VB_Name = "FormatCPP"

Public Sub MAIN()
Attribute MAIN.VB_Description = "Reformats a Borland-style CPP file into the style I prefer.  Indenting, spacing, etc."
Attribute MAIN.VB_ProcData.VB_Invoke_Func = "TemplateProject.FormatCPP.MAIN"
Dim TRUE_
Dim FALSE_
Dim Completed
Dim CR$
Dim OldFontName$
Dim OldFontSize
Dim Dashes$
Dim Slashes$
Dim T$
Dim IndentLevel
Dim Increase
Dim FirstCase
Dim InASwitch
Dim Decrease
Rem MACRO FormatCPP
Rem Copyright (C)1998, 1999, 2006 Steven Whitney.
Rem This program is free software; you can redistribute it and/or
Rem modify it under the terms of the GNU General Public License
Rem Version 2 as published by the Free Software Foundation.
Rem This program is distributed in the hope that it will be useful,
Rem but WITHOUT ANY WARRANTY; without even the implied warranty of
Rem MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
Rem GNU General Public License for more details.
Rem You should have received a copy of the GNU General Public License
Rem along with this program; if not, write to the Free Software
Rem Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
Rem
Rem I mainly used this to reformat the Borland example CPP files to the style I prefer,
Rem to make them easier to study without being distracted by unfamiliar formatting.
Rem started 12/3/98
Rem LAST 1-30-99
Rem 6-8-99 one file in Borland DIAGXPRT project caused endless loop, in declaration of a
Rem bunch of static strings in nested braces (?)
Rem Tested:  attaching cprogram.dot, running this macro, and saving as text
Rem results in a fully compilable source file.  No extraneous garbage.
Rem No additional editing required in Borland IDE.
Rem THE VARIOUS STEPS IN THIS MACRO MUST BE DONE IN EXACTLY THE ORDER THEY ARE IN.

Rem ----------------------------------------------------------------------------
Rem ENSURE EXTEND MODE IS OFF WHEN STARTING.
Rem IF THERE IS A SELECTION, THE FIRST STARTOFDOCUMENT CANCELS IT.
WordBasic.Cancel

TRUE_ = (1 = 1)
FALSE_ = Not TRUE_

Rem TRUE IF EVERYTHING COMPLETED WITHOUT ERROR OR ABORT
Completed = FALSE_

Rem ----------------------------------------------------------------------------
Rem The string used for CR$ must not appear in the file.
Rem if macro aborts, change it to something else here.
Rem CR$ = "~~"      'for reference if CR$ is temporarily changed
Let CR$ = "~~"

Rem ----------------------------------------------------------------------------
Rem TEMPORARILY CHANGE THE DOCUMENT TO A TINY FONT, SO NONE OF THE DOCUMENT'S
Rem LINES ARE WRAPPED TO A FOLLOWING LINE. IF THAT HAPPENS, SOME SEARCHES MAY FAIL.

Rem SAVE CURRENT SETTINGS:
WordBasic.StartOfDocument                       'ASSUMES WHOLE DOCUMENT IS SAME FONT
OldFontName$ = WordBasic.[Font$]()
OldFontSize = WordBasic.FontSize()

Rem CHANGE FONT TO ARIAL 8
WordBasic.EditSelectAll
WordBasic.Font "Arial", 8
WordBasic.StartOfDocument                   'THIS DOES CANCEL THE SELECTION

Rem ----------------------------------------------------------------------------
Rem 1. IF FILE ALREADY CONTAINS OUR SUBSTITUTE PARAGRAPH MARK, QUIT
WordBasic.StartOfDocument
WordBasic.EditFind Find:=CR$, Direction:=0, MatchCase:=1, WholeWord:=0, PatternMatch:=0, SoundsLike:=0, Format:=0, Wrap:=1
If WordBasic.EditFindFound() Then
    WordBasic.MsgBox "This file already contains the string that this macro temporarily substitutes for paragraph marks.  You must modify the macro for use with this file.", "Cannot Run Macro", 64
    GoTo bye
End If

Rem ----------------------------------------------------------------------------
Rem 2. CHANGE ALL TABS TO SPACES (so whitespace searches need only deal with spaces)
WordBasic.StartOfDocument
WordBasic.EditReplace Find:="^t", Replace:=" ", Direction:=0, MatchCase:=1, WholeWord:=0, PatternMatch:=0, SoundsLike:=0, ReplaceAll:=1, Format:=0, Wrap:=1

Rem ----------------------------------------------------------------------------
Rem 3. CHANGE ALL PARAGRAPH MARKS TO CR$ SO YOU CAN USE PATTERN MATCHING IN SEARCHES
WordBasic.StartOfDocument
WordBasic.EditReplace Find:="^p", Replace:=CR$, Direction:=0, MatchCase:=1, WholeWord:=0, PatternMatch:=0, SoundsLike:=0, ReplaceAll:=1, Format:=0, Wrap:=1

Rem ----------------------------------------------------------------------------
Rem 4. remove leading spaces in lines (indenting), by stripping spaces that follow CRs.
StripAllLeadingSpaces (CR$)

Rem ----------------------------------------------------------------------------
Rem ANY OF THESE THAT *SHOULD* BE ON THE SAME LINE ARE RESTORED LATER.
Rem 5. MOVE ALL SAME-LINE { THAT IMMEDIATELY FOLLOW ( TO THE NEXT LINE DOWN
WordBasic.StartOfDocument
WordBasic.EditReplace Find:="){", Replace:=")" + CR$ + "{", Direction:=0, MatchCase:=1, WholeWord:=0, PatternMatch:=0, SoundsLike:=0, ReplaceAll:=1, Format:=0, Wrap:=1

Rem MOVE ALL SAME-LINE { CHARS THAT FOLLOW SPACES TO THE NEXT LINE DOWN
WordBasic.StartOfDocument
WordBasic.EditReplace Find:=" {1,}\{", Replace:=CR$ + "{", Direction:=0, MatchCase:=1, WholeWord:=0, PatternMatch:=1, SoundsLike:=0, ReplaceAll:=1, Format:=0, Wrap:=1

Rem ----------------------------------------------------------------------------
Rem 6. SEPARATE }ELSE TO SEPARATE LINES
WordBasic.StartOfDocument
WordBasic.EditReplace Find:="}else", Replace:="}" + CR$ + "else", Direction:=0, MatchCase:=1, WholeWord:=0, PatternMatch:=0, SoundsLike:=0, ReplaceAll:=1, Format:=0, Wrap:=1

Rem SEPARATE } ELSE TO SEPARATE LINES
WordBasic.StartOfDocument
WordBasic.EditReplace Find:="\} {1,}else", Replace:="}" + CR$ + "else", Direction:=0, MatchCase:=1, WholeWord:=0, PatternMatch:=1, SoundsLike:=0, ReplaceAll:=1, Format:=0, Wrap:=1

Rem ----------------------------------------------------------------------------
Rem SEPARATE ALL ELSE IF LINES TO SEPARATE ELSE, IF LINES
Rem THIS CAN BREAK APART COMMENTS, BUT AN OBVIOUS ERROR WILL RESULT.
WordBasic.StartOfDocument
WordBasic.EditReplace Find:="else {1,}if", Replace:="else" + CR$ + "if", Direction:=0, MatchCase:=1, WholeWord:=0, PatternMatch:=1, SoundsLike:=0, ReplaceAll:=1, Format:=0, Wrap:=1

Rem ----------------------------------------------------------------------------
Rem 8. again remove leading spaces in lines, by stripping spaces that follow CRs.
StripAllLeadingSpaces (CR$)

Rem ----------------------------------------------------------------------------
Rem 9. remove extra trailing spaces at line ends, by stripping spaces that precede each CR.
StripAllTrailingSpaces (CR$)

Rem ----------------------------------------------------------------------------
Rem 10. REMOVE EXTRA INTERNAL SPACES FROM IF, FOR, WHILE, SWITCH STMTS
Rem REMOVE EXTRA SPACES FROM IF () STMTS
WordBasic.StartOfDocument
WordBasic.EditReplace Find:=CR$ + "if {1,}\(", Replace:=CR$ + "if(", Direction:=0, MatchCase:=1, WholeWord:=0, PatternMatch:=1, SoundsLike:=0, ReplaceAll:=1, Format:=0, Wrap:=1

Rem REMOVE EXTRA SPACES FROM FOR () STMTS
WordBasic.StartOfDocument
WordBasic.EditReplace Find:=CR$ + "for {1,}\(", Replace:=CR$ + "for(", Direction:=0, MatchCase:=1, WholeWord:=0, PatternMatch:=1, SoundsLike:=0, ReplaceAll:=1, Format:=0, Wrap:=1

Rem REMOVE EXTRA SPACES FROM WHILE () STMTS
WordBasic.StartOfDocument
WordBasic.EditReplace Find:=CR$ + "while {1,}\(", Replace:=CR$ + "while(", Direction:=0, MatchCase:=1, WholeWord:=0, PatternMatch:=1, SoundsLike:=0, ReplaceAll:=1, Format:=0, Wrap:=1

Rem REMOVE EXTRA SPACES FROM SWITCH () STMTS
WordBasic.StartOfDocument
WordBasic.EditReplace Find:=CR$ + "switch {1,}\(", Replace:=CR$ + "switch(", Direction:=0, MatchCase:=1, WholeWord:=0, PatternMatch:=1, SoundsLike:=0, ReplaceAll:=1, Format:=0, Wrap:=1

Rem ----------------------------------------------------------------------------
Rem RECOMBINE FN RETURN TYPES THAT APPEAR A LINE ABOVE THE FUNCTIONS THEY DESCRIBE
Rem AND INSERT A DASHED LINE SEPARATOR.
Rem 1 PASS FOR EACH TYPE
Dashes$ = "//----------------------------------------------------------------------------"

Rem VOID
WordBasic.StartOfDocument
WordBasic.EditReplace Find:=CR$ + "void" + CR$, Replace:=CR$ + Dashes$ + CR$ + "void ", Direction:=0, MatchCase:=1, WholeWord:=0, PatternMatch:=0, SoundsLike:=0, ReplaceAll:=1, Format:=0, Wrap:=1

Rem VOID*
WordBasic.StartOfDocument
WordBasic.EditReplace Find:=CR$ + "void*" + CR$, Replace:=CR$ + Dashes$ + CR$ + "void* ", Direction:=0, MatchCase:=1, WholeWord:=0, PatternMatch:=0, SoundsLike:=0, ReplaceAll:=1, Format:=0, Wrap:=1

Rem TWindow*
WordBasic.StartOfDocument
WordBasic.EditReplace Find:=CR$ + "TWindow*" + CR$, Replace:=CR$ + Dashes$ + CR$ + "TWindow* ", Direction:=0, MatchCase:=1, WholeWord:=0, PatternMatch:=0, SoundsLike:=0, ReplaceAll:=1, Format:=0, Wrap:=1

Rem const char*
WordBasic.StartOfDocument
WordBasic.EditReplace Find:=CR$ + "const char*" + CR$, Replace:=CR$ + Dashes$ + CR$ + "const char* ", Direction:=0, MatchCase:=1, WholeWord:=0, PatternMatch:=0, SoundsLike:=0, ReplaceAll:=1, Format:=0, Wrap:=1

Rem BOOL
WordBasic.StartOfDocument
WordBasic.EditReplace Find:=CR$ + "BOOL" + CR$, Replace:=CR$ + Dashes$ + CR$ + "BOOL ", Direction:=0, MatchCase:=1, WholeWord:=0, PatternMatch:=0, SoundsLike:=0, ReplaceAll:=1, Format:=0, Wrap:=1

Rem INT
WordBasic.StartOfDocument
WordBasic.EditReplace Find:=CR$ + "int" + CR$, Replace:=CR$ + Dashes$ + CR$ + "int ", Direction:=0, MatchCase:=1, WholeWord:=0, PatternMatch:=0, SoundsLike:=0, ReplaceAll:=1, Format:=0, Wrap:=1

Rem DOUBLE
WordBasic.StartOfDocument
WordBasic.EditReplace Find:=CR$ + "double" + CR$, Replace:=CR$ + Dashes$ + CR$ + "double ", Direction:=0, MatchCase:=1, WholeWord:=0, PatternMatch:=0, SoundsLike:=0, ReplaceAll:=1, Format:=0, Wrap:=1

Rem UINT
WordBasic.StartOfDocument
WordBasic.EditReplace Find:=CR$ + "UINT" + CR$, Replace:=CR$ + Dashes$ + CR$ + "UINT ", Direction:=0, MatchCase:=1, WholeWord:=0, PatternMatch:=0, SoundsLike:=0, ReplaceAll:=1, Format:=0, Wrap:=1

Rem LRESULT
WordBasic.StartOfDocument
WordBasic.EditReplace Find:=CR$ + "LRESULT" + CR$, Replace:=CR$ + Dashes$ + CR$ + "LRESULT ", Direction:=0, MatchCase:=1, WholeWord:=0, PatternMatch:=0, SoundsLike:=0, ReplaceAll:=1, Format:=0, Wrap:=1

Rem ----------------------------------------------------------------------------
Rem 12. ADD CLASS SEPARATOR LINES
Slashes$ = "//////////////////////////////////////////////////////////////////////////////"
WordBasic.StartOfDocument
WordBasic.EditReplace Find:=CR$ + "class {1,}", Replace:=CR$ + Slashes$ + CR$ + "class ", Direction:=0, MatchCase:=1, WholeWord:=0, PatternMatch:=1, SoundsLike:=0, ReplaceAll:=1, Format:=0, Wrap:=1

Rem ----------------------------------------------------------------------------
Rem THE STEP AFTER RESTORING PARAGRAPH MARKS (BELOW) (restoring same-line {} )
Rem REQUIRES THAT THERE BE NO TRAILING SPACES.
Rem PROBABLY UNNECESSARY WITH CURRENT STEP ORDER, BUT DO IT JUST IN CASE.

StripAllTrailingSpaces (CR$)

Rem ----------------------------------------------------------------------------
Rem RESTORE CR PARAGRAPH MARKS
WordBasic.StartOfDocument
WordBasic.EditReplace Find:=CR$, Replace:="^p", Direction:=0, MatchCase:=1, WholeWord:=0, PatternMatch:=0, SoundsLike:=0, ReplaceAll:=1, Format:=0, Wrap:=1

Rem ----------------------------------------------------------------------------
Rem 1-30-99
Rem RESTORE SAME-LINE { whatever } TO THE PREVIOUS LINES THEY WERE SEPARATED FROM.
Rem E.G. SHORT INLINES IN A CLASS DECLARATION or char* s = {'1','2','3'};

WordBasic.StartOfDocument
While Not WordBasic.AtEndOfDocument()
    WordBasic.LineDown 1
    Rem SELECT ENTIRE LINE WITHOUT THE PARAGRAPH MARK, AND MAKE COPY.
    WordBasic.EndOfLine
    WordBasic.StartOfLine 1
    T$ = WordBasic.[Selection$]()
    Rem IF IT STARTS WITH AN OPENING { AND ALSO CONTAINS A CLOSING },
    If WordBasic.[Left$](T$, 1) = "{" And InStr(T$, "}") > 0 Then

	Rem SELECT PREVIOUS LINE (WITH PARA MARK)SO EDITREPLACES OCCUR WITHIN IT.
        WordBasic.LineUp 1
        WordBasic.StartOfLine
        WordBasic.EndOfLine 1

	Rem REPLACE THE PARAGRAPH MARK WITH A SPACE, TO REJOIN THE 2 LINES.
        WordBasic.EditReplace Find:="^p", Replace:=" ", Direction:=0, MatchCase:=0, WholeWord:=0, PatternMatch:=0, SoundsLike:=0, ReplaceAll:=1, Format:=0, Wrap:=0

	Rem RE-EXTEND THE SELECTION TO THE NEW END OF THE LENGTHENED LINE.
        WordBasic.EndOfLine 1

	Rem REMOVE ANY EXTRA SPACES BEFORE THE {
        WordBasic.EditReplace Find:=" {1,}\{", Replace:=" {", Direction:=0, MatchCase:=0, WholeWord:=0, PatternMatch:=1, SoundsLike:=0, ReplaceAll:=1, Format:=0, Wrap:=0

	Rem REMOVE ANY EXTRA SPACES AFTER THE CLOSING }.
        Rem CAN'T SPECIFY BETWEEN { AND PARAMARK BECAUSE IT'S A PATTERN MATCH SEARCH.
        Rem IT CAN ACCIDENTALLY CLOSE UP DESIRABLE GAP TO A TRAILING COMMENT.
        Rem UNNECESSARY, ANYWAY, SINCE TRAILING SPACES WERE REMOVED ABOVE.
Rem         EditReplace .Find = "\} {1,}", .Replace = "}", .Direction = 0, .MatchCase = 0, .WholeWord = 0, .PatternMatch = 1, .SoundsLike = 0, .ReplaceAll, .Format = 0, .Wrap = 0

	Rem CANCEL SELECTION
        WordBasic.EndOfLine
    End If          'IF LINE CONTAINED {...}
Wend                'WHILE NOT AT END OF DOCUMENT


Rem =======================================================================
Rem INDENTING
Rem -----------------------------------------------------------------------
Rem SINGLE-LINE INDENTS, I.E. THOSE NOT CONTAINED WITHIN AN INDENTED {} BLOCK.
Rem YOU MUST DO THESE BEFORE THE BLOCK INDENTS.

IndentLevel = 0
Increase = FALSE_

WordBasic.StartOfDocument
While Not WordBasic.AtEndOfDocument()
    Rem SELECT ENTIRE LINE WITHOUT THE PARAGRAPH MARK
    WordBasic.EndOfLine
    WordBasic.StartOfLine 1
    T$ = WordBasic.[Selection$]()
    Rem FIRST TAB IN THIS LINE TO THE EXISTING INDENT LEVEL.
    Rem UNLESS IT'S AN OPENING {, WHICH STAYS ONE LEVEL LESS THAN CURRENT.
    Rem E.G. IF PREVIOUS LINE IF() INCREASED IT, IT DOESN'T AFFECT THE NEXT {.
    If WordBasic.[Left$](T$, 1) <> "{" Then TabLineIn (IndentLevel)
    Rem NOW DECIDE WHETHER SUCCEEDING LINES SHOULD BE FURTHER INDENTED.
    Increase = FALSE_
    If WordBasic.[Left$](T$, 3) = "if(" And WordBasic.[Right$](T$, 1) <> ";" Then Increase = TRUE_
    If WordBasic.[Left$](T$, 4) = "for(" And WordBasic.[Right$](T$, 1) <> ";" Then Increase = TRUE_
    If WordBasic.[Left$](T$, 6) = "while(" And WordBasic.[Right$](T$, 1) <> ";" Then Increase = TRUE_
    If WordBasic.[Left$](T$, 4) = "else" And WordBasic.[Right$](T$, 1) <> ";" Then Increase = TRUE_
    If Increase = TRUE_ Then
        IndentLevel = IndentLevel + 1
    Else
        IndentLevel = 0     'IF CHAIN OF INDENTS IS BROKEN, RESTART AT MARGIN
    End If

    Rem HERE, YOU CAN DO SOME MISC SINGLE-LINE INDENTING UNRELATED TO Increase,
    Rem SUCH AS:
    Rem IF LINE STARTS WITH ": " TO INTRODUCE A CONSTRUCTOR INITIALIZER LIST,
    Rem TAB IT IN BY 1.  THE SPACE DISTINGUISHES IT FROM A ::GLOBAL FUNCTION CALL.
    If Len(T$) > 1 Then
        If Mid(T$, 1, 2) = ": " Then TabLineIn (1)
    End If

    WordBasic.LineDown
Wend

Rem ----------------------------------------------------------------------------
Rem 15. NOW DO BLOCK INDENTS

Rem STARTING LEVEL IS -1 SO FUNCTION BODIES START OUT ALIGNED AT MARGIN.
IndentLevel = -1

Rem THE FIRST CASE IN A SWITCH STMT MUST BE HANDLED SPECIALLY
Rem MUST ALSO KNOW WHEN WE ARE WITHIN A SWITCH BLOCK
FirstCase = TRUE_
InASwitch = FALSE_

WordBasic.StartOfDocument
While Not WordBasic.AtEndOfDocument()
    Rem SELECT ENTIRE LINE WITHOUT THE PARAGRAPH MARK
    WordBasic.EndOfLine
    WordBasic.StartOfLine 1
    T$ = WordBasic.[Selection$]()
    Increase = 0
    Decrease = 0

    If WordBasic.[Left$](T$, 7) = "switch(" Then
        FirstCase = TRUE_
        InASwitch = TRUE_
    End If

    Rem DETERMINE IF THE CURRENT LINE CHANGES THE INDENT LEVEL EITHER WAY (OR BOTH)
    Rem THE BASIC BLOCK INDENT AND UNINDENTS
    Rem ONLY CHANGE IF { AND } ARE NOT ON THE SAME LINE.
    If WordBasic.[Left$](T$, 1) = "{" And InStr(T$, "}") = 0 Then Increase = 1
    If WordBasic.[Left$](T$, 1) = "}" Then
        Decrease = 1
        Rem IF WE ARE ENDING A SWITCH BLOCK, IT'S A DOUBLE-DECREASE.
        Rem A NESTED SWITCH, OR OTHER ENCLOSED {}, WILL STILL THROW IT OFF.
        If InASwitch = TRUE_ Then Decrease = 2
        InASwitch = FALSE_              '(PROBABLY) NOT IN A SWITCH ANYMORE
    End If

    Rem EACH CASE OF A SWITCH UN-INDENTS FROM THE PREVIOUS CASE, THEN
    Rem RE-INDENTS FOR THE REST OF THE CASE CODE.
    If WordBasic.[Left$](T$, 4) = "case" Or WordBasic.[Left$](T$, 7) = "default" Then
        Increase = 1
        Decrease = 1
        Rem BUT THE FIRST CASE DOES NOT UN-INDENT
        If FirstCase = TRUE_ Then Decrease = 0
        FirstCase = FALSE_                  'NOT THE FIRST CASE ANYMORE
    End If

    Rem ANY DECREASE IS DONE NOW (STARTING WITH THE CURRENT LINE)
    IndentLevel = IndentLevel - Decrease

    Rem RESPONSE TABLE MUST OVERRIDE WITH EXPLICIT VALUE BECAUSE AS A LEVEL 1 INDENT
    Rem LIKE A FUNCTION BODY, IT WOULD OTHERWISE NOT GET INDENTED AT ALL.
    Rem WHEN IT ENDS, MUST RESTORE NORMAL INDENTLEVEL.
    If WordBasic.[Left$](T$, 18) = "END_RESPONSE_TABLE" Then IndentLevel = -1

    TabLineIn (IndentLevel)

    Rem ANY INCREASE STARTS WITH NEXT LINE
    IndentLevel = IndentLevel + Increase

    Rem RESPONSE TABLE EXPLICIT OVERRIDE
    If WordBasic.[Left$](T$, 21) = "DEFINE_RESPONSE_TABLE" Then IndentLevel = 1

    WordBasic.LineDown
Wend

Completed = TRUE_

Rem ----------------------------------------------------------------------------


bye:

Rem ----------------------------------------------------------------------------
Rem RESTORE CR PARAGRAPH MARKS
WordBasic.StartOfDocument
WordBasic.EditReplace Find:=CR$, Replace:="^p", Direction:=0, MatchCase:=1, WholeWord:=0, PatternMatch:=0, SoundsLike:=0, ReplaceAll:=1, Format:=0, Wrap:=1

Rem ----------------------------------------------------------------------------
Rem RESTORE ORIGINAL FONT
WordBasic.EditSelectAll
WordBasic.Font OldFontName$, OldFontSize
WordBasic.StartOfDocument                       'THIS DOES CANCEL THE SELECTION

Rem SET TAB STOPS TO EVERY 4 CHARS AT 12CPI = 1/3"
WordBasic.FormatTabs Position:="", DefTabs:="0.33" + Chr(34), Align:=0, Leader:=0

If Completed = TRUE_ Then WordBasic.MsgBox "There are some other macros that can make further changes: IndentClass, and maybe others.", "Done.", 64


End Sub             ' MAIN

Rem //////////////////////////////////////////////////////////////////////////////
Rem 11/3/98 Inserts the given number of TABS at start of current line.
Private Sub TabLineIn(HowMany)
Dim I
WordBasic.StartOfLine                   'ALSO CANCELS SELECTION, IF ANY
For I = 1 To HowMany
    WordBasic.Insert Chr(9)
Next I
End Sub

Rem //////////////////////////////////////////////////////////////////////////////
Rem 1/30/99 STRIPS LEADING SPACES FROM ALL LINES IN FILE
Rem ALL PARAGRAPH MARKS IN FILE MUST ALREADY HAVE BEEN CONVERTED TO CR$
Private Sub StripAllLeadingSpaces(CR$)
WordBasic.StartOfDocument
WordBasic.EditReplace Find:=CR$ + " {1,}", Replace:=CR$, Direction:=0, MatchCase:=1, WholeWord:=0, PatternMatch:=1, SoundsLike:=0, ReplaceAll:=1, Format:=0, Wrap:=1
End Sub

Rem //////////////////////////////////////////////////////////////////////////////
Rem 1/30/99 STRIPS TRAILING SPACES FROM ALL LINES IN FILE
Rem ALL PARAGRAPH MARKS IN FILE MUST ALREADY HAVE BEEN CONVERTED TO CR$
Private Sub StripAllTrailingSpaces(CR$)
WordBasic.StartOfDocument
WordBasic.EditReplace Find:=" {1,}" + CR$, Replace:=CR$, Direction:=0, MatchCase:=1, WholeWord:=0, PatternMatch:=1, SoundsLike:=0, ReplaceAll:=1, Format:=0, Wrap:=1
End Sub

IndentClass

Attribute VB_Name = "IndentClass"

Public Sub MAIN()
Attribute MAIN.VB_Description = "Properly indents selected class declaration."
Attribute MAIN.VB_ProcData.VB_Invoke_Func = "TemplateProject.IndentClass.MAIN"
Rem MACRO IndentClass
Rem Copyright (C)1998, 1999, 2006 Steven Whitney.
Rem Published under GNU GPL (General Public License) Version 2, with ABSOLUTELY NO WARRANTY.
Rem 1-31-99 INDENTS A CLASS DECLARATION
Rem BEFORE CALLING, SELECT THE BODY OF THE CLASS DECLARATION,
Rem EXCLUDING THE DECLARATION LINE AND EXCLUDING THE FINAL BRACE.
Rem ----------------------------------------------------------------------------
Rem YOU DON'T WANT TO DO THE WHOLE FILE. (just one class) IF YOU DO, SELECT ALL FIRST.
If Len(WordBasic.[Selection$]()) = 1 Then
    WordBasic.MsgBox "Select class before calling macro.", "Cannot Continue", 48
    GoTo bye
End If

Rem TAB IN ENTIRE BLOCK
WordBasic.Call "TabIn"

WordBasic.EditReplace Find:="^tpublic:", Replace:="public:", Direction:=0, MatchCase:=1, WholeWord:=0, PatternMatch:=0, SoundsLike:=0, ReplaceAll:=1, Format:=0, Wrap:=0

WordBasic.EditReplace Find:="^tprotected:", Replace:="protected:", Direction:=0, MatchCase:=1, WholeWord:=0, PatternMatch:=0, SoundsLike:=0, ReplaceAll:=1, Format:=0, Wrap:=0

WordBasic.EditReplace Find:="^tprivate:", Replace:="private:", Direction:=0, MatchCase:=1, WholeWord:=0, PatternMatch:=0, SoundsLike:=0, ReplaceAll:=1, Format:=0, Wrap:=0

bye:

End Sub

 

 

Valid HTML 4.01 Transitional Valid CSS
View content labeling at ICRA.
Copyright ©2007 Steven Whitney. Last modified 09/25/2007.