Thanks for the heads up. Alas, the cleanup process isn’t as simple as one would hope. Wordpress seems to have incorrectly interpreted UTF-8 data as Latin-1, then re-transcoded it to UTF-8. This happened with our last upgrade (using their built in import/export functions). The end result is we have valid UTF-8 content, properly encoded and displayed, which contains wacky characters.

Fixing it requires correcting each problem case. Some day I’ll get a script written to do this for me.

Thanks,

Geoff

I appreciate the posts, the mistakes, and the humor. I see that your blog renders some characters in the FileMaker syntax as different entities and wonder if perhaps the pages need re-saved with a BOM as UTF 8 to parse and display correctly.

While it’s easy enough to read, and experienced developers know what is missing it might frustrate people newer to FileMaker who might actually cut and paste code from the browser.

-Brian Loomis

GetParamValue ( “City==Antwerp|Country==Belgium|TelNo==0485638536″ )

The paramters can be in any order and text constants (like “Antwerp”) don’t have to be between “”. It’s very easy and fast to use.
The only minus is that I can’t use == nor | nor ” in my parameters, but till now that has never been a problem.

Evaluate ( “Let ( [∏” & Substitute ( Get ( ScriptParameter ) ; [”==” ; “=\””] ; [”|” ; “\”;∏”] ) & “\”] ; ∏” & ParName & “)” )

I use the ∏ to avoid a problem I had in teh past with certain parameter names, but I can’t remember which (!)

I will write up a post for that by the end of next week. I was planning about doing it a lot earlier but became quite lazy :-).

I appreciate your interest.

Thanks for posting this code.

You mentioned that you have a “whole suite of custom functions that expand upon this idea” (DictFirst, DictRemove, DictAdd, DictToString, DictList and my personal favorite DictToXML).

Would you be willing to post that code? I’ve been looking into building my own dictionary functionality, but I’d like to avoid reinventing the wheel.

Thanks,

Chris

The CF, which I call GSP, has a single function parameter (number) and looks like this:

Let (
  [x = MiddleValues (Substitute (Get (ScriptParameter); "|"; "¶"); Number; 1);
  y = Left (x; Length (x)-1)];

  Case (
    PatternCount (Get (ScriptParameter); "|" ); y;
    Get (ScriptParameter)
  )
)

When I want to pass multiple parameters to the script I separate each value with the verical pipe character “|”.

So if I wanted to pass apple, banana and orange the paramter would look like “apple|banana|orange”. The passed parameter could obviously be a calculated set of values or field names, etc. They just have to be separated with a |.

If I wanted to use the second parameter I would call GSP (2) and return “banana”.

It has worked very well for me and it can take an unlimited set of parameters so that it can easily be used with 1 parameter or 100 without having to modify the code.

Also, we actually have a whole suite of custom functions that expand upon this idea. It’s awesome that you had the same first impression of where to go once one starts using the Dictionary concept. We have implemented DictFirst, DictRemove, DictAdd, DictToString, DictList and my personal favorite DictToXML. There are a couple of others that we use as well but those are the ones I believe you mentioned in your post.

The one think I don’t think we agree on is the need for local variables in the script that house the same data as in the dictionary. Why not access the data directly??? The dictionary data is just as transient as the data in the variables. I also don’t like that you lose the transparency of where the data came from because they are in a let function buried in a recursive custom function that is solely used to place data you already have access to into variables.

I think at this point though, we both are agreeing on the idea that this type of construct is beneficial but don’t agree on it’s exact implementation. Please feel free to modify our code in any way you see fit to meet your own specifications for it’s functionality. I really appreciate the critique and hope you continue to provide comments on our methods in the future.

in itself, though, it isn’t especially convenient for passing parameters, which deserve to become local variables as soon as they reach the called procedure, as in almost all general programming languages; sure, a group of Set Variable steps could “fix” this, but that’s tedious and a potential source of error, so i suggest using a helper script to do that part, and keeping it apart from the general dictionary functions by packaging one use of the dictionary object as a local-variable factory; this would make parameter passing more convenient and support defining default values for optional parameters (another common feature of programming languages)

i would thus see your dictionary as an opportunity to refine my local -setting technique (http://www.briandunning.com/cf/453) by decoupling the dictionary from the parameter handling

so what i’d want to do with it first is to make a full set of dictionary functions:

dict_set (dict; itemname; value) –> dict

dict_get (dict; itemname) –> item or null

dict_delete (dict; itemname) –> dict

dict_names (dict) –> names valuelist

this would create a dictionary type for any of several purposes — these dictionaries can be stored in the database and reloaded at startup, for example; and this is how i’d use such a dictionary for parameter passing in FileMaker; i’d define a local variable factory (untested off the cuff definition):

Let (a_name = trim_val (dict_names (dict); 1);

   Case (

       is_empty (a_name);


        1;
        (
        Evaluate ("Let ($" & a_name & "=\"" &
         dict_get (dict; a_name) & "\"; 1) "
        );
        dict_to_locals (dict_delete_item (dict; a_name));


       0

   )

)

the convenience function, trim_val (dict; n) simply removes returns and trims the result of MilddleValues (list; n; 1)

another convenience function, param_dict() would simply do

dicttolocals (Get (ScriptParameter))

then you could pass params with e.g.


Perform Script ["myscript"; Parameter: set_dict_item (set_dict_item (""; "var1"; val1); "var2"; val2)


and the called script would start like this (except for any default values for parameters):

If [not param_dict())]

// handle parameter error

Else

// do things with the local script vars created

End If