I used to make macros from time to time, sometimes quite complex ones, for Word and excel, but haven’t for a few years. The following, however, works quite well, and since there was generally a lack of information on how to do just this, I thought I’d share it with you.

First off, here are the three files involved, NumberInsert.frm, NumberInsert.frx and PatentTranslationMacros.bas.

The code for Sequence(), the main macro, is as follows:

Sub Sequence()
	Dim regEx, Match, Matches

	' Get the active word document
	Set objWdDoc = Word.Application.ActiveDocument          

	' Set our range to be the entire document contents
	Set objWdRange = objWdDoc.Content                       

	' To be used for the result string
	Dim Result As String                                    

	' Create a regular expression object.
	Set regEx = CreateObject("VBScript.RegExp")             

	'Show our form
	NumberInsert.Show

	If NumberInsert.Tag Then
		' Get the value of the string we want to find from the form
		regEx.Pattern = NumberInsert.FindStr.Value
		' Set case sensitivity.
		regEx.IgnoreCase = False
		' Set global applicability to false. This was the odd part since
		' no examples on the internet, that I could find, used
		' Globabl = False.
		regEx.Global = False                        

		' A little silly but we have to use something to catch the return value from MoveStart
		Dim temp As Long        

		Dim length As Long, repStart As String, repEnd As String
		' How many digits to show, retrieved from the form and converted to Long
		length = CLng(NumberInsert.NumberLength.Value)
		' the replacement string for the portion BEFORE the inserted number
		repStart = NumberInsert.ReplaceStart
		' the replacement string for the portion AFTER the inserted number
		repEnd = NumberInsert.ReplaceEnd                

		Dim realIndex As Long

		Dim i As Integer        ' For our step counter
	        i = 0
		Do
			' Get the first match (Global = False, remember)
			Set Matches = regEx.Execute(objWdRange) 

			' If there isn't a match, Exit
			If Matches.Count = 0 Then
		                Exit Do
		        End If

			' Get the first match from the MatchCollection.
	        	Set Match = Matches(0)                  

			' Increment our counter. Since we're starting from 1 we increment before we
			' change the value
			i = i + 1                               

			' Convert the characters to full width Japanese characters
			' String(Length, "0") gives us the format pattern for the number
			tStr = StrConv(Format(i, String(length, "0")), vbWide, 1041)    

			' regex replace using the found value and our pattern from the form
			Result = regEx.Replace(Match.Value, repStart & tStr & repEnd)   

			' add the index for the range start and the match index which only considers
			' its position within the range
			realIndex = objWdRange.Start + Match.FirstIndex         

			' Insert our result into the range
			objWdDoc.Range(realIndex, realIndex + Len(Match.Value)).Text = Result   

			' move the start point on our range by the length
			' of our replacement plus the position within the
			' range, plus one
			temp = objWdRange.MoveStart(wdCharacter, Match.FirstIndex + Len(Match.Value) + 1)
        Loop
    End If

End Sub

However, let’s look at some of the individual components in more detail

Set regEx = CreateObject("VBScript.RegExp")

The most portable way to include regular expressions in your macro code is to use the VBScript object – It’s just been around longer than VBA support for regex.

regEx.Global = False

Every example for using regex in VBA or VBScript will show you Global = True, even the MSDN library. Global = False finds the first match only. Otherwise it performs the same. Execute() still returns an array of matches even though there’s only one element.

length = CLng(NumberInsert.NumberLength.Value)
' How many digits to show, retrieved from the form and converted to Long

tStr = StrConv(Format(i, String(length, "0")), vbWide, 1041)
' Convert the characters to full width Japanese characters

length is just the number of digits to show and in the tStr assignment I use String(length, "0") to generate the format string needed, for example if the user wanted to show a number 4 digits long, then the format string produced would be "0000".

tStr also uses the StrConv() function, which takes up to three parameters. The first parameter is the string to convert, the second is the format to convert to, in this case I used vbWide, but other formats include vbLower, vbUpper, vbHiragana, and others.  The best resource for this info is at MSDN. Amazingly, many pages omit over half of the formats available and never included better resources. The third parameter is the Locale ID. In this case, I used 1041, the Japanese locale, because I was converting to full-width and needed a far-east locale to do so.  This table at MSDN has the best info on locale IDs.

' add the index for the range start and the match index which only considers
' its position within the range
realIndex = objWdRange.Start + Match.FirstIndex

As the start point of our range can, and does, change, we need to get the index in the document, not just the index within the range. Simply summing the two values does the job.

temp = objWdRange.MoveStart(wdCharacter, Match.FirstIndex + Len(Match.Value) + 1)
	' move the start point on our range by the length
	' of our replacement plus the position within the
	' range, plus one

Finally, we move the start of the range. MoveStart takes two parameters. The first is the unit to change by. In this case characters (wdCharacter), but you could use wdWord, wdLine, etc. The second parameter is the amount to move by, NOT the position to move to.

Why do a non-global regex match? Why move the start of our range? Well, whenever we insert replacement text that is longer or shorter than the original, the indexes stored in the match array are no longer valid as those character have moved since we executed the regex. Therefore, we need to get one at a time. As to the second question, we want to begin our next step of the search only on the text after our previous match, otherwise the replaced value could also match and we’d end up with an infinite loop continually replacing the first match. And that’s a bad thing, trust me.

The other components of the above are pretty standard and,  if you have a passing familiarity with regex and macros, are hopefully clear from the comments.

The second part of this system is the form. The best way is to import the form file into your word app and have a look, but here’s a screen shot of the form with values filled in.

NumberInsert.frm Example

The code behind it is VERY simple and doesn’t do any validation on the fields. For something more professional you’d definitely want to add some checks on the inputs.

Private Sub CancelBtn_Click()
    Me.Tag = False
    Me.Hide
End Sub

Private Sub NumberLength_Change()
    NumberLengthSpin.Value = NumberLength.Value
    MakeSample
End Sub

Private Sub OKBtn_Click()
    Me.Tag = True
    Me.Hide
End Sub

Private Sub ReplaceEnd_Change()
    MakeSample
End Sub

Private Sub ReplaceStart_Change()
    MakeSample
End Sub

Private Sub MakeSample()
    SampleText.Caption = ReplaceStart.Value & Format("15", String(CLng(NumberLength.Value), "0")) & ReplaceEnd.Value

End Sub

Private Sub NumberLengthSpin_SpinUp()
    NumberLength.Value = NumberLengthSpin.Value
    MakeSample
End Sub

Private Sub NumberLengthSpin_SpinDown()
    NumberLength.Value = NumberLengthSpin.Value
    MakeSample
End Sub

There’s not too much to say about this other than making sure your spin buttons and numerical field update eachother when they’re changed. Me.Tag is used to pass True or False so Sequence() knows if the user canceled (False) or not (True). Finally MakeSample is called from any procedure which can change the value of the sample shown… so almost all of them. Again, adding some checks here   could help. For example, you could check to make sure the user has the right number of ( and ) and that they aren’t nested in any way, and check that the number of stored values called for in the replacement is also equal to the number of (, ) pairs.

Hopefully this helps the next poor soul who goes looking through web pages in the hopes of doing something like this.