Option sets: a .o target for shared parameters

A named group of optional parameters, declared once and used by several
klammers, so a writer learns one vocabulary instead of a spelling per
klammer.  The "o" target is a pseudo-target beside "k": "k" declares a
klammer's interface and documents it, "o" declares an option interface and
documents it, and neither produces output for any target.

    @@caption_args.o :caption :number.bool true :caption_side.side
    : Arguments that define a caption for a block element @@

    @@code.k :filename @hpos_args :hpos left @ @caption_args :caption_side top @
    | text.literal : A source file displayed verbatim @@

A set is used only in the parameter list of a ".k" declaration -- the one
place a klammer's interface is declared once for all of its targets -- and
is resolved as that list is read.  Names and types come from the set; a
default may be overridden where it is used.  A klammer application in a
parameter list is now a definition-time error.

The SKS gains the sets caption_args and hpos_args (:hpos and :offset), and
@table, @image, @image_grid, @reference and @show gain .k declarations.  A
distance is no longer written as a position: :hpos 4em is rejected, and the
same layout is :hpos left :offset 4em.  Code listings are numbered by
default, like tables and figures.

New engine sources mac/option_set{,_registry}.{h,cpp}; tst/ ships two more
suites, option_set_test.sh and signature_test.sh (twelve in all).

 (from dev 34e536cb0329)

sks/code/code_format.py

@@ -1,3 +1,5 @@
+print("DEPRECATED")
+
 if __name__ == "__main__":
     import sys
     sys.path.append("../kutil")
@@ -22,6 +24,49 @@ def escape_newlines(s):
 #     backslash_pat = re.compile(r'(".*?)\n(.*?")', re.S)
 #     return backslash_pat.sub(replace, s)    
 
+def is_comment(s):
+    return s.strip().startswith("//")
+
+def split_blocks(s):
+    print('-'*40)
+    print(s)
+    print('-'*40)
+    blocks = []
+    in_code = True
+    block = ""
+    for line in s.rstrip().split("\n"):
+        if is_comment(line):
+            if in_code:
+                blocks.append(block)
+                block = line + "\n"
+                in_code = False
+            else:
+                block += line + "\n"
+        else:
+            if not in_code:
+                blocks.append(block)
+                block = line + "\n"
+                in_code = True
+            else:
+                block += line + "\n"
+    if block:
+        blocks.append(block)
+    for block in blocks:
+        print("B:")
+        print(block)
+    return blocks
+
+def parse_blocks(blocks):
+    box_comment_rgx = re.compile("\s*//(\d+)\s+.*", re.S)
+    i = 0
+    while i < len(blocks):
+        match = box_comment_rgx.match(blocks[i])
+        if match:
+            print(match.group(1))
+        i += 1
+
+
+
 def get_blocks(s):
     comment_pat = re.compile(r"(\s*)//(\d+)\s+(.*)", re.S)
     blocks = []
@@ -134,7 +179,27 @@ class Code(klammer_base.Klammer_base):
         s = s.replace(">", "\\textgreater{}")
         return s
 
+    def code_box(self, text):
+        kutil.msg(text)
+        result = ""
+        for line in text.rstrip().split("\n"):
+            indent = len(line) - len(line.lstrip())
+            eline = ("~" * indent) + line[indent:]
+            print(indent, line)
+            print(eline)
+            result += eline + "\\\\\n"
+        result = result[:-3]
+        print("RESULT:")
+        print(result)
+        return result
+
     def tex(self):
+        parse_blocks(split_blocks(self.text))
+        return ""
+
+
+
+
         # Escape Klammertext special characters
         self.text = self.text.replace("^", "^^")
         self.text = self.text.replace("#", "^#")
@@ -153,6 +218,14 @@ class Code(klammer_base.Klammer_base):
         result = ""
         count = len(self.blocks)
         for text, comment in self.blocks:
+            print("TEXT:")
+            print(text)
+            print("COMMENT:")
+            print(comment)
+
+
+
+
             text = " " + re.sub("\n", " \n ", text) + " "
             longest = longest_line(text)
             text = latex_spaces(text)
@@ -160,11 +233,23 @@ class Code(klammer_base.Klammer_base):
             text = f"{start_strut}\\ttfamily {text}{end_strut}"
             width = f"\\widthof{{\\ttfamily {longest}}}"
             code = L.environment("minipage", text, width) + "\\\\\n"
+            print(code)
+
+            #code = "\\asymbox{" + self.code_box(text) + "}"
+            #print(code)
+
+            code = text
+
             if comment:
-                width = f"\\linewidth - {width} - {indent} - {comment_sep}"
+                #width = f"\\linewidth - {width} - {indent} - {comment_sep}"
+                """
+                width = f"\\linewidth - \widestline - {indent} - {comment_sep}"
                 code =  f"\\fcolorbox{{Gray}}{{LightGray}}{{{code}}}"
                 code += f"\\rule{{{comment_sep}}}{{{strutvis}}}" \
                     + L.environment("minipage", "\\sffamily\\small\\raggedright " + comment, width)
+                """
+                code = "\\asymbox{" + self.code_box(text) + "}" + comment
+
             result += f"\\rule{{{indent}}}{{{strutvis}}}{code}"
             if comment:
                 if i < count - 1 and self.blocks[i+1][1]: