Print

Please login or register.
1 Hour 1 Day 1 Week 1 Month Forever
Login with username, password and session length

[Azcatl]

I have an ancient freeware MSDOS program that generates a concordance of reference numerals in an application.  This allows you to check for the same numerals used for different elements, or duplicate numbers.  It was built for Word Perfect, and has its limitations.

Does anyone know of more modern software that does this? I would think any patent drafter would find it very helpful.

The program I have was called "Cataloger."

[JimIvey]

First, sorry, don't know anything about that program.

At the risk of evoking a large, collective sigh from the Windoze community, it's relatively easy to do something that with StarOffice/OpenOffice.org (OOo).  The file format is a zipped collection of XML files, so it's all text-accessible.  A simple unzip/grep combination at the Linux command line and you've got a good first shot at that information.

In addition, the macro language is very similar to Virtual BASIC, so you can cook up your own pretty easily.  Some day, I hope to build a macro to resequence claim numbers in an application.

FWIW, I understand the latest version of MS Office is supposed to also include XML files so you should be able to do the same there as well -- eventually.

Regards.

[Isaac]

At the risk of evoking a large, collective sigh from the Windoze community, it's relatively easy to do something that with StarOffice/OpenOffice.org (OOo).  The file format is a zipped collection of XML files, so it's all text-accessible.  A simple unzip/grep combination at the Linux command line and you've got a good first shot at that information.

I'm not writing applications from scratch much these days, but for a while I was writing 2-3 a week, and when I did, I used to insert merge fields having names that were reminiscent of  the element they represented into my documents instead of adding the reference numbers directly.   Typing <right framastat bracket> was slower than typing "32" but when proof reading I could easily spot when a reference was used incorrectly.   Word also has some facilities that allow inserting field names after you've used them once.

I then used a macro to read tables of assigned field names and corresponding reference numbers to merge the reference numbers into the document before submitting the thing to be reviewed.   The table was also useful for communicating with the draftsperson  (a third column had a description of the element.  My own sketches can be pretty awful) and for reminding me what I was calling stuff while writing the application.   And of course I could easily reassign the reference numbers if necessary or if it improved readability.   I could also grab some stock stuff (like descriptions of a general purpose computer) without worrying about having to change the reference numbers.

I wrote other macros to make sure that my table didn't assign duplicate reference numbers, that all assigned reference numbers were used at least once, and to  check for a few other problems that cropped up.

In fact pretty much every time I ran into or was able to predict a reference number related problem, a few lines of visual basic made sure it never happened again.   It was a type of penance for my transgressions because I loathe programming in visual basic.

I don't think I could find any of that code now.  It's probably on a CD or DVD somewhere, but I don't use it.

[Azcatl]

Thanks to Jim and Isaac for their comments.  I'm pretty familiar with what Word and OO can do, but I don't think they can do this:

Element  Order  Count  Antc.   Description
-----------------------------------------------------------------------
100         1          20       a        transfer capsule
110         2            2       an      airtight casing
120         8            2       a        handle
.
.
.
175        12          3        an     O-ring
                            1        a      switch
.....

Note this reveals 175 is used for two different elements. It also shows 120 appears 8th where logically it should be introduced as the 3rd numeral.


The program to re-order numerals sounds pretty nifty, though.

[Azcatl]

The posting messed up my table formatting, but I think you can see what I mean.  Re-reading Isaac's post, I think his idea is pretty good for doing this in Word or OO.  If I can find the round tuit.

[JimIvey]

Okay, I took it as a challenge (or a puzzle daring me to give it a try), so I came up with this:

#!/bin/sh
#

# function to reverse word order
reverse()
{
awk ' { i=1
      while (i<=NF) {
            j=NF-i+1
            printf "%s ",$j
            i++ }
      printf "\n"
      } ' $*
}

#main()

xmlfile="Application.sxw.d/content.xml"

( \
  egrep -o ' [A-Za-z]+ [A-Za-z]+ [A-Za-z]+ [0-9][0-9]+[ \.\,\-]' "$xmlfile"; \
  egrep -o ' [A-Za-z]+ [A-Za-z]+ [0-9][0-9]+[ \.\,\-]' "$xmlfile"; \
  egrep -o ' [A-Za-z]+ [0-9][0-9]+[ \.\,\-]' "$xmlfile" \
) | \
sed 's/[\.\,\-]$//' | \
reverse | \
sort -n | \
uniq | \
reverse

exit

The result of running it on a simple application of mine gave the following:

under 27
Mail under 27
Express Mail under 27
service under 27
step 102
in step 102
passcode in step 102
step 104
step 106
test step 106
in test step 106
step 110
to step 110
transfers to step 110
step 112
step 114
test step 114
step 116
in step 116
disconnected in step 116
state 118
in state 118
authenticated in state 118
step 202
test step 202
in test step 202
step 204
test step 204
to test step 204
step 206
in step 206
disconnected in step 206
step 208
test step 208
from test step 208
to test step 208
step 210
from step 210
transfers from step 210
step 212
state 214
reauthorization state 214
a reauthorization state 214
state 216
authorized state 216
an authorized state 216
to authorized state 216
in state 216
authorized in state 216
state 218
authorized state 218
to authorized state 218
step 302
step 304
test step 304
step 306
test step 306
to test step 306
step 308
test step 308
to test step 308
state 310
administration state 310
an administration state 310
in administration state 310
step 312
to step 312
transfers to step 312
step 314
test step 314
step 316
to step 316
transfers to step 316
step 320
test step 320
from test step 320
to test step 320
to step 320
transfers to step 320
step 322
to step 322
transfers to step 322
step 324
at step 324
in step 324
selection in step 324
to step 324
transfers to step 324
step 326
in step 326
connected in step 326
state 328
connected state 328
a connected state 328
to connected state 328
step 402
test step 402
in test step 402
with test step 402
step 404
test step 404
to test step 404
step 406
test step 406
in test step 406
to test step 406
step 408
to step 408
transfers to step 408
step 410
test step 410
to test step 410
step 502
steps 502
test step 502
through test step 502
step 504
test step 504
through test step 504
and 506
step 506
test step 506
through test step 506
step 508
step 510
or step 510
step 512
test step 512
from test step 512
step 514
to step 514
step 516
step 518
California 94611

It's far from perfect, but it's not a bad quick peek for QA.  Oh, and it presupposes you've already unzipped the OOo file.

Regards.

[Isaac]

It's far from perfect, but it's not a bad quick peek for QA.  Oh, and it presupposes you've already unzipped the OOo file.

Regards.

Not bad at all for just a few lines of bash script, and I'll bet for an application covering an invention with more structural components the script would be even more revealing.

[JimIvey]

Thanks!  I'll disclaim any copyright interest in that.  

In addition, I absolutely must disclaim any warranty of merchantability or fitness for a particular purpose.  Use at your own risk.

For the Windows community out there, it should run in cygwin under Windows -- without any warranty that it does, however.

Regards.

[Azcatl]

Wow!  Thanks for that neat script!  I can take it from here.

I run Windows XP under VM Ware on a Linux system.  This will involve opening the word file in OO, saving it to the shared folder and running the script.

Since I only need to do this once or twice for an application, though, it's a big help.  Also, I can add bells and whistles...

[JimIvey]

Note that it only looks for referenced things spelled out in letters (case insensitive).  You'd have to modify it slightly to catch things with other characters, e.g., hyphenated words.

Regards.