---

zclassmap.vtc

Go to the documentation of this file.

/* -*- C -*- */
func cmp2(a, b) [t] {
    t = stricmp(a[0], b[0]);
    return (t != 0) ? t : stricmp(a[1], b[1]);
}

class_map ?:= bimap_make(.stricmp, .stricmp);
instance_map ?:= bimap_make(.cmp2, .stricmp);

func Class(class, abbrev) {
    bimap_insert(class_map, class, abbrev);
}

func Instance(class, instance, abbrev) {
    bimap_insert(instance_map, table(class, instance), abbrev);
}

/* Returns abbrev name for a class */
func mapped_class(class) 
{
  return bimap_find_left(class_map, class);
}

/* Returns class name for an abbrev */
func unmapped_class(abbrev)
{
  return bimap_find_right(class_map, abbrev);
}

/* Returns abbrev name for a class and instance */
func mapped_instance(class, instance)
{
  return bimap_find_left(instance_map, table(class, instance));
}

/* Returns a 2-element array with (class, instance) for an abbrev */
func unmapped_instance(abbrev)
{
  return bimap_find_right(instance_map, abbrev);
}

func save_maps(fp) [i] {
    for (i = 0; i < class_map->num; i++) {
        fprintf(fp, "Class(%s, %s);\n",
                stringconst(class_map->left[i]),
                stringconst(class_map->right[i]));
    }
    for (i = 0; i < instance_map->num; i++) {
        fprintf(fp, "Instance(%s, %s, %s);\n",
                stringconst(instance_map->left[i][0]),
                stringconst(instance_map->left[i][1]),
                stringconst(instance_map->right[i]));
    }
}
add_to_hook(save_hook, .save_maps);

add_cmd("class", 2, .Class, "/class <class> <abbrev>");
add_cmd("instance", 3, .Instance, "/instance <class> <instance> <abbrev>");

/* style maps */

class_style_map ?:= make_tree(.stricmp);
instance_style_map ?:= make_tree(.cmp2);

func name_to_style(name) {
    if (strcmp(name, "S_NORM") == 0) return S_NORM;
    if (strcmp(name, "S_HILITE") == 0) return S_HILITE;
    return find_style(name);
}

func style_to_name(style) {
    if (style == S_NORM) return "S_NORM";
    if (style == S_HILITE) return "S_HILITE";
    return get_style_name(style);
}

func Class_style(class, style) {
    insert_tree(class_style_map, class, name_to_style(style));
}

func Instance_style(class, instance, style) {
    insert_tree(instance_style_map, table(class, instance),
                name_to_style(style));
}

func save_class_style(class, style, fp) {
    fprintf(fp, "Class_style(%s, %s);\n",
            stringconst(class),
            stringconst(style_to_name(style)));
}

func save_instance_style(ci, style, fp) {
    fprintf(fp, "Instance_style(%s, %s, %s);\n",
            stringconst(ci[0]),
            stringconst(ci[1]),
            stringconst(style_to_name(style)));
}

func save_style_maps(fp) [i] {
    traverse_tree(class_style_map, .save_class_style, fp);
    traverse_tree(instance_style_map, .save_instance_style, fp);
}

func style_of_zephyr(z) [style]
{
    style ?:= find_tree(instance_style_map, table(z->class, z->instance));
    style ?:= find_tree(class_style_map, z->class) ?: S_NORM;
    return style;
}

add_to_hook(save_hook, .save_style_maps);

add_cmd("class_style", 2, .Class_style, "/class_style <class> <style>");
add_cmd("instance_style", 3, .Instance_style, "/instance_style <class> <instance> <style>");

---