I think I see how I would do that with a sequential machine. Let me
know if you want a working example.
Briefly, though, you seem to have three kinds of token pairs:
@{ }
{ }
<script> </script>
The ambiguity between the first two is problematic, in the context of
errors, but does not matter in well formed cases. A bigger problem in
the wild might be that you do not allow for attributes on the script
tag.
Also, you care about the number of characters between <script>
</script> so those characters should be saved as "tokens" even if they
are not curly braces. You care about {} between both @{ } and <script>
</script> and outside them, and your implementation allows things like
@{ <script> } </script>.
A full wart-for-wart compatible version would be painful to write. A
version which assumed well-formed cases would be much easier to write.
But before thinking about coding up an implementation it's probably
worth thinking about why you want to do this. The answer to that kind
of question can be really interesting and can help identify which
warts are unnecessary or possibly even detrimental.
So, before I think any more about code, what are your thoughts on what
you want to accomplish?
Thanks,
--
Raul
On Sat, Jan 11, 2014 at 3:40 PM, Joe Bogner <[email protected]> wrote:
> I have about 300 code files (javascript and embedded code) that I want
> to collect some metrics on. I've written the algorithm using an
> imperative style. I actually wrote it first in C# and translated to J
>
> Here is the code (posted a link for brevity):
>
> J version:
> https://gist.github.com/joebo/936ca5e2017c0a3b5c56
>
> C# version:
> https://gist.github.com/joebo/e7f8e3ca7bd21117e58d
>
> This is what it outputs
>
> calc''
> blocks 3
> max depth 2
> max block 113
> scripts 2
> max script 26
>
> Any suggestions on how to do it differently in J? I looked into the
> sequential machine some but couldn't figure out how to make it work
> (if it could) since my approach required knowledge of the brace depth.
>
> In terms of requirements:
> 1. Take a block of text
> 2. Identify the code blocks in the file (start with @{ and end with } )
> 3. Count the code blocks
> 4. Determine the max depth of the code block
> 5. Determine the max size of all the code blocks
> 6. Count the javascript blocks
> 7. Determine the max size of the javascript block
>
> Thanks for any feedback or input!
>
> Joe
> ----------------------------------------------------------------------
> For information about J forums see http://www.jsoftware.com/forums.htm
----------------------------------------------------------------------
For information about J forums see http://www.jsoftware.com/forums.htm
