Extending the regular expression

To this point we've shown how to separate the red, green and blue fields, with commas with the following expressions;

• Search expression - ^(\d+(?=\x20))\x20([\d\w\s\-()]+(?=\x20\d{2}\x20))\x20
• Replace expression - \1,\2,

We've already considered the general approach to the digit fields (in black) right at the beginning of this excercise. At the time we considered that a good (if not perfect) approach would be to simply replace the spaces. The problem is that now we have partially processed the file, some of our comma separated fields have spaces within them. We could simply replace spaces with commas, but our existing cell definitions would be broken into separate fields

This then is the clue as to how to proceed. If we can find the last comma on each line, all we need to do is to find the next space after that, and replace it with a comma. We implement this behaviour as follows. (.+,.+?(?=\x20))\x20 Having come this far with us, we're going to assume that you're beginning to get the hang of all this.

This expression works by saying "Find anything as many times as possible, terminated by a comma. Find anything, terminated by a space, but don't capture it for replacement. Capture the space such that it may be removed.". It's a bit of a leap. The only important thing that we've not already discussed is the question mark, following the second plus. The first plus is greedy, so on each test, it will select anything it can until it finds the last comma. At this point what we want to do, is gobble up the digit field that we know follows the comma. We can do this by terminating with a space, but the problem is there will be more than one digit field followed by a space. Since the plus is greedy, it'll just simply gobble up all the digit fields.

The question mark acts on the second plus, to make it lazy. This ensures that it will only capture the first digit field. As usual the space is declared as a metatoken, and then matched formally outside the group, such that it may be replaced. The important thing to notice here is that we've not really considered where the match begins. It's quite likely that the match in the first bracket is quite large, possibly almost the whole document. The importance is that with a really big operation, this isn't a very efficient approach. There are other ways of implementing this method, but this is sufficient for our need.

If we use this expression for replacement then, again, we just use the simple replacement expression \1,. When it runs as a "Replace All" operation, it will replace the first space after a comma on every line throughout the document. Each time this expression runs, another column will have commas inserted. This approach has the advantage that if some lines have less cells on them, then they will be skipped, and no commas added. The .csv format we are trying to create treats each line end as a row, so we don't have to worry about cells from other rows appearing on the current one. Since rows with fewer cells will be skipped, then it follows that one simply runs this expression until it makes no more replacements.

The original .pdf file is now in .csv format, suitable for import into most spreadsheets.