List-of-lists data structure

[Jacob Gerlach <jacobgerlach@gmail.com>]

I'm working on implementing fontification in a major mode for an in
house scripting language. The scripts configure any of about 50 different
apps, each of which has different keywords. This looks something like:

--------------------------------
processConfig = pFoo
{
  foo = 1
  bar = true
  baz = normal
}

processConfig = pBar
{
  apples  = foo
  pears   = bar
  oranges = false
}
---------------------------------

Only the names on the left of the equals are keywords, so foo and bar
should receive the appropriate font lock face in the pFoo block, but
not in the pBar block (where apples, pears, and oranges would be
font-locked).

I have managed to make fontification app specific using multiline font
lock matching and regexp's anchored to "processConfig = pFoo" (for
example).

In the interest of long term maintainability, I want to create a data
structure to store all of the app names and associated keywords, which
I then iterate through to generate the entries for the fontification
keyword list.

For one app, I can use:

(setq name-and-keyword-list
      '("pFoo" ("foo" "bar" "baz")))

This gives me the ability to do something like:

(while foo
  (add-to-list 'my-app-names (car foo))
  (add-to-list 'my-keywords (make-font-lock-cons (car foo) (cdr foo)))
  (setq foo (cdr foo)))

Where make-font-lock-cons is a hypothetical function that returns the
appropriate cons cell for my keyword list, which uses the app name
(the car) as the anchor, and uses regexp-opt to generate a regexp for
actually matching using the list of keywords (the cdr).

This works for my one entry list - at least, (car name-and-keyword-list)
and (cdr name-and-keyword-list) give me what I would expect.

However, if I try to expand the list:

(setq name-and-keyword-list
      '("pFoo" ("foo" "bar" "baz"))
      '("pBar" ("apples" "pears" "orange")))

Building the list gives:
Wrong type argument: symbolp, (quote ("pBar" ("apples" "pears"
"orange")))

Is this a simple syntax error, or am I approaching this data structure
in the wrong way?

Any other recommendations on my approach to this problem would be very
welcome.

Thanks,
Jake