home *** CD-ROM | disk | FTP | other *** search
/ Tools / WinSN5.0Ver.iso / NETSCAP.50 / WIN1998.ZIP / ns / lib / libstyle / csstojs.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-04-08  |  26.9 KB  |  967 lines
  1. /* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
  2.  *
  3.  * The contents of this file are subject to the Netscape Public License
  4.  * Version 1.0 (the "NPL"); you may not use this file except in
  5.  * compliance with the NPL.  You may obtain a copy of the NPL at
  6.  * http://www.mozilla.org/NPL/
  7.  *
  8.  * Software distributed under the NPL is distributed on an "AS IS" basis,
  9.  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
  10.  * for the specific language governing rights and limitations under the
  11.  * NPL.
  12.  *
  13.  * The Initial Developer of this code under the NPL is Netscape
  14.  * Communications Corporation.  Portions created by Netscape are
  15.  * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
  16.  * Reserved.
  17.  */
  18.  
  19. /* CSStoJS tranlation code */
  20.  
  21. #include "xp.h"
  22. #include "css.h"
  23. #include "cssI.h"
  24.  
  25. /* ALLOW_IMPORT
  26.  * Switch allows or stops the translation of @import rules.
  27.  */
  28. #define ALLOW_IMPORT 0
  29.  
  30. /* ALLOW_FONTDEF
  31.  * Switch allows or stops the translation of @fontdef rules.
  32.  */
  33. #define ALLOW_FONTDEF 1
  34.  
  35. /* ALLOW_PRIORITY
  36.  * Switch allows or stops the translation of "!important" in the value.
  37.  */
  38. #define ALLOW_PRIORITY 0
  39.  
  40. /* ALLOW_PSEUDO_ELEMENTS
  41.  * Switch allows or prevents the translation of rules with pseudo-elements
  42.  * :first-line and :first-letter in the selector.
  43.  */
  44. #define ALLOW_PSEUDO_ELEMENTS 0
  45.  
  46. /* ALLOW_ACTIVE_PSEUDO_CLASS
  47.  * Switch allows or prevents the translation of rules with pseudo-class
  48.  * :active in the selector.
  49.  */
  50. #define ALLOW_ACTIVE_PSEUDO_CLASS 0
  51.  
  52. #define STYLE_INITIAL_BUFSIZ 1024
  53. #define STYLE_INCR_BUFSIZ    1024
  54.  
  55. /* property type values */
  56. #define CSS_PROPERTY_TYPE_ASSIGNMENT (1)
  57. #define CSS_PROPERTY_TYPE_CALL       (2)
  58. /* pseudo class type values */
  59. #define CSS_PSEUDO_CLASS_NONE        (0)
  60. #define CSS_PSEUDO_CLASS_LINK        (1)
  61. #define CSS_PSEUDO_CLASS_ACTIVE        (2)
  62. #define CSS_PSEUDO_CLASS_VISITED    (3)
  63.  
  64. typedef struct {
  65.     char * buffer;
  66.     int32  buffer_size;   /* size of buffer in bytes */
  67.     int32  buffer_count;  /* bytes used */
  68.     int32  prior_count;   /* buffer_count at beginning of rule */
  69.     int32  pseudo_class_state; /* holds temporary state during translation */
  70.     XP_Bool ignore_rule;  /* during translation, may decide to ignore a rule */
  71. } *StyleBuffer, StyleBufferRec;
  72.  
  73. XP_BEGIN_PROTOS
  74.  
  75. static XP_Bool ConvertStyleSheet(css_node stylesheet, StyleBuffer sb);
  76. static void ConvertRule(css_node rule, StyleBuffer sb);
  77. static void ConvertSelector(css_node selector, css_node pseudo_element,
  78.                             StyleBuffer sb);
  79. static void ConvertContextualSelector(css_node selector, css_node pseudo_element,
  80.                                       StyleBuffer sb);
  81. static void ConvertSingleSelector(css_node simple, css_node pseudo_element,
  82.                                   StyleBuffer sb);
  83. static void ConvertDeclaration(css_node declaration_list, StyleBuffer sb);
  84. static void ConvertProperty(const char * css1_property, StyleBuffer sb,
  85.                             int * property_type_return);
  86. static void ConvertValue(css_node value, StyleBuffer sb, int property_type);
  87. static void ConvertURLValue(char * url_value, StyleBuffer sb);
  88. static void StripURLValue(char ** url_return, int * url_length_return);
  89. static void ConvertStringValue(char * string_value, StyleBuffer sb);
  90. static void StyleBufferWrite(char * str, int len, StyleBuffer sb);
  91. static void AnteRule(StyleBuffer sb);
  92. static void IgnoreRule(StyleBuffer sb);
  93. static void PostRule(StyleBuffer sb);
  94. static void SaltPseudoClass(const char * pseudo_class, StyleBuffer sb);
  95. static int32 GetPseudoClass(StyleBuffer sb);
  96.  
  97. #if (ALLOW_IMPORT || ALLOW_FONTDEF)
  98. static void ConvertToLink(css_node ruleset, int rel_type, StyleBuffer sb);
  99. static void EchoCSS(char * src, int32 src_count, StyleBuffer sb);
  100. #endif
  101.  
  102. XP_END_PROTOS
  103.  
  104. static char * input_buffer;
  105. static int32  input_buffer_count;   /* bytes used, not including NULL */
  106. static int32  input_buffer_index;
  107.  
  108. /* result and max_to_read are created and passed as int, not int32, on Win16. */
  109. void css_GetBuf(char * buf, int *result, int max_to_read)
  110. {
  111.     int i = 0;
  112.  
  113.     if (input_buffer) {
  114.  
  115.         while ((i < max_to_read) && (input_buffer_count > input_buffer_index))
  116.         buf[i++] = input_buffer[input_buffer_index++];
  117.  
  118.     if (0 == i) {
  119.         input_buffer = NULL;
  120.         input_buffer_count = input_buffer_index = 0;
  121.     }
  122.     }
  123.  
  124.     *result = i;
  125.     return;
  126. }
  127.  
  128. /* Java and JavaScript */
  129. static const char * reserved_words[] = {
  130.     "abstract",
  131.     "boolean",
  132.     "break",
  133.     "byte",
  134.     "case",
  135.     "catch",
  136.     "char",
  137.     "class",
  138.     "const",
  139.     "continue",
  140.     "default",
  141.     "delete",
  142.     "do",
  143.     "double",
  144.     "else",
  145.     "extends",
  146.     "false",
  147.     "final",
  148.     "finally",
  149.     "float",
  150.     "for",
  151.     "function",
  152.     "goto",
  153.     "if",
  154.     "implements",
  155.     "import",
  156.     "in",
  157.     "instanceof",
  158.     "int",
  159.     "interface",
  160.     "long",
  161.     "native",
  162.     "new",
  163.     "null",
  164.     "package",
  165.     "private",
  166.     "protected",
  167.     "public",
  168.     "return",
  169.     "short",
  170.     "static",
  171.     "super",
  172.     "switch",
  173.     "synchronized",
  174.     "this",
  175.     "throw",
  176.     "throws",
  177.     "transient",
  178.     "true",
  179.     "try",
  180.     "typeof",
  181.     "var",
  182.     "void",
  183.     "volatile",
  184.     "while",
  185.     "with"
  186. };
  187.  
  188. static XP_Bool IsReservedWord(const char * css_name)
  189. {
  190.     int lower = 0;
  191.     int upper = (sizeof(reserved_words) / sizeof(char *)) - 1;
  192.     int x;
  193.     int32 result;
  194.  
  195.     while (upper >= lower) {
  196.         x = (lower + upper) / 2;
  197.         result = XP_STRCMP(css_name, reserved_words[x]);
  198.         if (result < 0)
  199.             upper = x - 1;
  200.         else if (result > 0)
  201.             lower = x + 1;
  202.         else
  203.             return 1;
  204.     }
  205.     return 0;
  206. }
  207.  
  208. /* CSS_ConvertToJSCompatibleName
  209.  * converts characters which are illegal in JavaScript names.
  210.  *
  211.  *  Anne-Marie ==> Anne_Marie     "-" (dash) always converts to "_"
  212.  *  5NewportRd ==> _5NewportRd    1st character a digit prepend "_"
  213.  *  Convert lower to upper case when second parameter is true.
  214.  *  When second parameter is false, prepend "_" to reserved words.
  215.  * Returns NULL on error.
  216.  */
  217. PUBLIC char *
  218. CSS_ConvertToJSCompatibleName(char *css_name, XP_Bool uppercase_it)
  219. {
  220.     int32 len;
  221.     char *new_name;
  222.     char *cp;
  223.         XP_Bool reserved = 0;
  224.  
  225.     XP_ASSERT(css_name);
  226.  
  227.     if (!css_name)
  228.         return NULL;
  229.  
  230.     len = XP_STRLEN(css_name);
  231.         if (! uppercase_it)
  232.             reserved = IsReservedWord(css_name);
  233.     if (reserved || XP_IS_DIGIT(*css_name))
  234.         len++;
  235.  
  236.     cp = new_name = XP_ALLOC((len+1) * sizeof(char));
  237.     if (!new_name)
  238.         return NULL;
  239.  
  240.     if (reserved || XP_IS_DIGIT(*css_name)) {
  241.         *cp = '_';
  242.         cp++;
  243.     }
  244.  
  245.     for(; *css_name; css_name++, cp++)
  246.         if (*css_name == '-')
  247.             *cp = '_';
  248.         else 
  249.             *cp = uppercase_it ? (XP_TO_UPPER(*css_name)) : *css_name;
  250.  
  251.     *cp = '\0';
  252.  
  253.     return new_name;
  254. }
  255.  
  256.  
  257. PUBLIC
  258. void CSS_ConvertToJS(char * src, int32 src_count, char ** dst, int32 * dst_count)
  259. {
  260.     StyleBuffer sb;
  261.     XP_Bool translated;
  262.  
  263.     *dst = NULL;
  264.     *dst_count = 0;
  265.  
  266.     if (NULL == src || 0 == src_count)
  267.         return;
  268.  
  269.     input_buffer = src;
  270.     input_buffer_count = src_count;
  271.     input_buffer_index = 0;
  272.  
  273.     css_tree_root = NULL;
  274.     if (css_parse() != 0)
  275.         return;
  276.  
  277.     sb = XP_NEW_ZAP(StyleBufferRec);
  278.     if (sb == NULL)
  279.         return;
  280.  
  281.     translated = ConvertStyleSheet(css_tree_root, sb);
  282.     css_FreeNode(css_tree_root);
  283. #if ALLOW_IMPORT
  284.     if (! translated)
  285.         EchoCSS(src, src_count, sb);
  286. #endif
  287.  
  288.     /* The caller should free *dst. */
  289.     *dst = sb->buffer;
  290.     *dst_count = sb->buffer_count;
  291.     XP_DELETE(sb);
  292. }
  293.  
  294.  
  295. /* Release all subtree and the node */
  296. void css_FreeNode(css_node vp)
  297. { 
  298.     if (vp) {
  299.         css_FreeNode(vp->left);
  300.         css_FreeNode(vp->right);
  301.         if (vp->string)
  302.             XP_FREE(vp->string);
  303.         XP_DELETE(vp);
  304.     }
  305. }
  306.  
  307.  
  308. static XP_Bool ConvertStyleSheet(css_node stylesheet, StyleBuffer sb)
  309. {
  310.  
  311. #if (ALLOW_IMPORT || ALLOW_FONTDEF)
  312.     XP_Bool translate_rules = 1;
  313.  
  314.     /* CSS1 requires @import productions occurring after
  315.      * ruleset productions to be ignored.  This is implemented
  316.      * here.  The restriction is not enforced by the parser.
  317.      */
  318.     for (; stylesheet && (stylesheet->node_id != NODE_RULESET_LIST);
  319.          stylesheet = stylesheet->left) {
  320. #if ALLOW_IMPORT
  321.         if (NODE_IMPORT_LIST == stylesheet->node_id) {
  322.             ConvertToLink(stylesheet->right, stylesheet->node_id, sb);
  323.             translate_rules = 0;
  324.         }
  325. #endif
  326. #if ALLOW_FONTDEF
  327.         if (NODE_FONTDEF_LIST == stylesheet->node_id) {
  328.             ConvertToLink(stylesheet->right, stylesheet->node_id, sb);
  329.         }
  330. #endif
  331.     }
  332. #if (ALLOW_IMPORT)
  333.     if (! translate_rules)
  334.         return 0;
  335. #endif
  336. #endif
  337.  
  338.     for (; stylesheet; stylesheet = stylesheet->left) {
  339.         if (stylesheet->node_id == NODE_RULESET_LIST)
  340.             ConvertRule(stylesheet->right, sb);
  341.     }
  342.  
  343.     return 1;
  344. }
  345.  
  346.  
  347. /* Generate the JavaScript corresponding to one CSS1 rule. */
  348. static void ConvertRule(css_node rule, StyleBuffer sb)
  349. {
  350.     css_node selector_list, selector;
  351.     css_node declaration_list;
  352.  
  353.     if (! rule || rule->node_id != NODE_RULESET)
  354.         return;
  355.  
  356.     for (selector_list = rule->left; selector_list; 
  357.          selector_list = selector_list->left) {
  358.  
  359.         selector = selector_list->right;
  360.         if (! selector)
  361.             continue;
  362.  
  363.         for (declaration_list = rule->right; declaration_list;
  364.              declaration_list = declaration_list->left) {
  365.  
  366.             if (declaration_list->right) {
  367.                 AnteRule(sb);
  368.                 ConvertSelector(selector->left, selector->right, sb);
  369.                 ConvertDeclaration(declaration_list->right, sb);
  370.                 PostRule(sb);
  371.             }
  372.         }
  373.     }
  374. }
  375.  
  376. static void AnteRule(StyleBuffer sb)
  377. {
  378.     sb->prior_count = sb->buffer_count;
  379.     sb->pseudo_class_state = CSS_PSEUDO_CLASS_NONE;
  380. }
  381.  
  382. static void PostRule(StyleBuffer sb)
  383. {
  384.     if (sb->ignore_rule) {
  385.         sb->buffer_count = sb->prior_count;
  386.         sb->ignore_rule = 0;
  387.         if (0 == sb->buffer_count)
  388.             sb->buffer_count = 1;
  389.         sb->buffer[sb->buffer_count-1] = '\0';
  390.     }
  391. }
  392.  
  393. static void StyleBufferWrite(char * str, int len, StyleBuffer sb)
  394. {
  395.  
  396.     if (str == NULL)
  397.         return;
  398.  
  399.     if (len <= 0) {
  400.         len = strlen(str);
  401.         if (len <= 0)
  402.             return;
  403.     }
  404.  
  405.     if (sb->buffer == NULL) {
  406.         sb->buffer = (char *) XP_ALLOC(STYLE_INITIAL_BUFSIZ);
  407.         if (sb->buffer) {
  408.             sb->buffer_size = STYLE_INITIAL_BUFSIZ;
  409.             *sb->buffer = '\0';
  410.             sb->buffer_count = 1;
  411.         }
  412.     }
  413.  
  414.     if (sb->buffer_count + len > sb->buffer_size) {
  415.         sb->buffer = (char *)
  416.             XP_REALLOC(sb->buffer, sb->buffer_size + STYLE_INCR_BUFSIZ);
  417.         if (sb->buffer) {
  418.             sb->buffer_size += STYLE_INCR_BUFSIZ;
  419.         } else {
  420.             sb->buffer_size = sb->buffer_count = 0;
  421.         }
  422.     }
  423.  
  424.     if (sb->buffer_count + len <= sb->buffer_size) {
  425.         (void) strncpy(sb->buffer + sb->buffer_count - 1, str, len);
  426.         sb->buffer_count += len;
  427.         sb->buffer[sb->buffer_count-1] = '\0';
  428.     }
  429. }
  430.  
  431.  
  432. static void ConvertSelector(css_node selector, css_node pseudo_element,
  433.                             StyleBuffer sb)
  434. {
  435.     if (selector->node_id == NODE_SELECTOR_CONTEXTUAL) {
  436.         StyleBufferWrite("contextual(", 11, sb);
  437.         ConvertContextualSelector(selector, pseudo_element, sb);
  438.         StyleBufferWrite(")", 1, sb);
  439.     } else {
  440.         ConvertSingleSelector(selector, pseudo_element, sb);
  441.     }
  442. }
  443.  
  444.  
  445. static void ConvertContextualSelector(css_node selector,
  446.                                       css_node pseudo_element, StyleBuffer sb)
  447. {
  448.     if (selector->left) {
  449.         /* pseudo_elements may be present only on the final context object */
  450.         ConvertContextualSelector(selector->left, NULL, sb);
  451.         StyleBufferWrite(", ", 2, sb);
  452.     }
  453.  
  454.     ConvertSingleSelector(selector->right, pseudo_element, sb);
  455. }
  456.  
  457.  
  458. static void ConvertSingleSelector(css_node selector, css_node pseudo_element,
  459.                                   StyleBuffer sb)
  460. {
  461.     char * str1;
  462.     char * str2;
  463.  
  464.     if (! selector)
  465.         return;
  466.  
  467.     if (selector->node_id == NODE_WILD) {
  468.         /* CSS1 Section 7.1 states: "A ruleset that [has] a selector
  469.          * string that is not valid CSS1 is skipped."  (sic)
  470.          */
  471.         IgnoreRule(sb);
  472.     }
  473.  
  474.     if (! selector->left)
  475.         return;
  476.  
  477.     str1 = selector->left->string;
  478.     str2 = selector->right ? selector->right->string : NULL;
  479.  
  480.     switch (selector->node_id) {
  481.  
  482.     case NODE_SIMPLE_SELECTOR_NAME_ONLY:
  483.  
  484.         /* "document.tags.<TAG>" */
  485.         StyleBufferWrite("document.tags.", 14, sb);
  486.         str1 = CSS_ConvertToJSCompatibleName(str1, TRUE);
  487.         StyleBufferWrite(str1, 0, sb);
  488.         XP_FREE(str1);
  489.         break;
  490.  
  491.     case NODE_SIMPLE_SELECTOR_DOT_AND_CLASS:
  492.  
  493.         /* "document.classes.<class>.all" */
  494.         StyleBufferWrite("document.classes.", 17, sb);
  495.         str1 = CSS_ConvertToJSCompatibleName(str1, FALSE);
  496.         StyleBufferWrite(str1, 0, sb);
  497.         XP_FREE(str1);
  498.         StyleBufferWrite(".all", 4, sb);
  499.         break;
  500.  
  501.     case NODE_SIMPLE_SELECTOR_ID_SELECTOR:
  502.  
  503.         /* "document.ids.<id>" */
  504.         StyleBufferWrite("document.ids.", 13, sb);
  505.         str1 = CSS_ConvertToJSCompatibleName(str1, FALSE);
  506.         StyleBufferWrite(str1, 0, sb);
  507.         XP_FREE(str1);
  508.         break;
  509.  
  510.     case NODE_SIMPLE_SELECTOR_NAME_AND_CLASS:
  511.  
  512.         /* "document.classes.<class>.<TAG>" */
  513.         StyleBufferWrite("document.classes.", 17, sb);
  514.         str2 = CSS_ConvertToJSCompatibleName(str2, FALSE);
  515.         StyleBufferWrite(str2, 0, sb);
  516.         XP_FREE(str2);
  517.         StyleBufferWrite(".", 1, sb);
  518.         str1 = CSS_ConvertToJSCompatibleName(str1, TRUE);
  519.         StyleBufferWrite(str1, 0, sb);
  520.         XP_FREE(str1);
  521.         break;
  522.  
  523.     case NODE_SIMPLE_SELECTOR_NAME_PSEUDO_CLASS:
  524.  
  525.         /* "document.tags.<TAG> */
  526.         /* By design, prepend the pseudoclass name to the property
  527.          * name when the property is 'color'; otherwise, ignore the
  528.          * pseudoclass name.
  529.          */
  530.         StyleBufferWrite("document.tags.", 14, sb);
  531.         str1 = CSS_ConvertToJSCompatibleName(str1, TRUE);
  532.         StyleBufferWrite(str1, 0, sb);
  533.         XP_FREE(str1);
  534.         SaltPseudoClass(str2, sb);
  535.         break;
  536.  
  537.     case NODE_SIMPLE_SELECTOR_NAME_CLASS_PSEUDO_CLASS:
  538.  
  539.         /* "document.classes.<class>.<TAG>" */
  540.         /* By design, prepend the pseudoclass name to the property
  541.          * name when the property is 'color'; otherwise, ignore the
  542.          * pseudoclass name.
  543.          */
  544.         StyleBufferWrite("document.classes.", 17, sb);
  545.         str1 = CSS_ConvertToJSCompatibleName(str1, FALSE);
  546.         StyleBufferWrite(str1, 0, sb);
  547.         XP_FREE(str1);
  548.         StyleBufferWrite(".", 1, sb);
  549.         str1 = CSS_ConvertToJSCompatibleName(selector->string, TRUE);
  550.         StyleBufferWrite(str1, 0, sb);
  551.         XP_FREE(str1);
  552.         SaltPseudoClass(str2, sb);
  553.         break;
  554.  
  555.     default:
  556.         break;
  557.     }
  558.  
  559.     if (pseudo_element) {
  560. #if ! ALLOW_PSEUDO_ELEMENTS
  561.         IgnoreRule(sb);
  562. #endif
  563.         StyleBufferWrite(".", 1, sb);
  564.         ConvertProperty(pseudo_element->string, sb, NULL);
  565.     }
  566. }
  567.  
  568. static void IgnoreRule(StyleBuffer sb)
  569. {
  570.     sb->ignore_rule = 1;
  571. }
  572.  
  573. static void SaltPseudoClass(const char * pseudo_class, StyleBuffer sb)
  574. {
  575.     if (! pseudo_class)
  576.         return;
  577.  
  578.     /* The parser always gives these strings in lower case. */
  579.     if (0 == XP_STRCMP(pseudo_class, "link"))
  580.         sb->pseudo_class_state = CSS_PSEUDO_CLASS_LINK;
  581.     else if (0 == XP_STRCMP(pseudo_class, "visited"))
  582.         sb->pseudo_class_state = CSS_PSEUDO_CLASS_VISITED;
  583.     else if (0 == XP_STRCMP(pseudo_class, "active")) {
  584. #if (! ALLOW_ACTIVE_PSEUDO_CLASS)
  585.         IgnoreRule(sb);
  586. #endif
  587.         sb->pseudo_class_state = CSS_PSEUDO_CLASS_ACTIVE;
  588.     }
  589. }
  590.  
  591. static int32 GetPseudoClass(StyleBuffer sb)
  592. {
  593.     return sb->pseudo_class_state;
  594. }
  595.  
  596. /* Pseudo-elements as well as property names are converted by this. */
  597. static void ConvertProperty(const char * css1_property, StyleBuffer sb, 
  598.                             int * property_type_return)
  599. {
  600.     XP_Bool upper;
  601.     char ch[2];
  602.     int32 pseudo_class;
  603.  
  604.     ch[1] = '\0';
  605.  
  606.     if (property_type_return)
  607.         *property_type_return = CSS_PROPERTY_TYPE_ASSIGNMENT;
  608.  
  609.     /* The CSS1 float property is translated to align because float is
  610.      * a reserved word in JavaScript.
  611.      */
  612.     if (0 == XP_STRCASECMP(css1_property, "float"))
  613.         StyleBufferWrite("align", 5, sb);
  614.     else {
  615.         if (property_type_return) {
  616.             if (   (0 == XP_STRCASECMP(css1_property, "margin"))
  617.                 || (0 == XP_STRCASECMP(css1_property, "padding"))
  618.                 || (0 == XP_STRCASECMP(css1_property, "border-width")))
  619.                 *property_type_return = CSS_PROPERTY_TYPE_CALL;
  620.         }
  621.  
  622.         pseudo_class = GetPseudoClass(sb);
  623.  
  624.         if (0 == XP_STRCASECMP(css1_property, "margin"))
  625.             StyleBufferWrite("margins", 7, sb);
  626.         else if (0 == XP_STRCASECMP(css1_property, "padding"))
  627.             StyleBufferWrite("paddings", 8, sb);
  628.         else if (0 == XP_STRCASECMP(css1_property, "border-width"))
  629.             StyleBufferWrite("borderWidths", 12, sb);
  630.         else if ((CSS_PSEUDO_CLASS_NONE != pseudo_class)
  631.                  && (0 == XP_STRCASECMP(css1_property, "color"))) {
  632.             switch (pseudo_class) {
  633.             case CSS_PSEUDO_CLASS_LINK:
  634.             default:
  635.                 StyleBufferWrite("linkColor", 9, sb);
  636.                 break;
  637.             case CSS_PSEUDO_CLASS_ACTIVE:
  638.                 StyleBufferWrite("activeColor", 11, sb);
  639.                 break;
  640.             case CSS_PSEUDO_CLASS_VISITED:
  641.                 StyleBufferWrite("visitedColor", 12, sb);
  642.                 break;
  643.             }
  644.         }
  645.         else {
  646.             for (upper=0; *css1_property; css1_property++) {
  647.  
  648.                 if (*css1_property == '-') {
  649.                     upper = 1;
  650.                     continue;
  651.                 }
  652.        
  653.                 ch[0] = (upper ? toupper(*css1_property)
  654.                          : tolower(*css1_property));
  655.                 upper = 0;
  656.                 StyleBufferWrite(ch, 1, sb);
  657.             }
  658.         }
  659.     }
  660. }
  661.  
  662.  
  663. static void ConvertDeclaration(css_node declaration, StyleBuffer sb)
  664. {
  665.     int property_type;
  666.  
  667.     if (declaration && 
  668.         (declaration->node_id == NODE_DECLARATION_PROPERTY_EXPR ||
  669.          declaration->node_id == NODE_DECLARATION_PROPERTY_EXPR_PRIO)) {
  670.         StyleBufferWrite(".", 1, sb);
  671.         ConvertProperty(declaration->left->string, sb, &property_type);
  672.         ConvertValue(declaration->right, sb, property_type);
  673. #if ALLOW_PRIORITY
  674.         if (declaration->node_id == NODE_DECLARATION_PROPERTY_EXPR_PRIO)
  675.             StyleBufferWrite(" !important", 11, sb);
  676. #endif
  677.         StyleBufferWrite("\n", 1, sb);
  678.     }
  679. }
  680.  
  681.  
  682. static void ConvertValue(css_node value, StyleBuffer sb, int property_type)
  683. {
  684.     css_node term;
  685.     XP_Bool comma;
  686.  
  687.  
  688.     if (CSS_PROPERTY_TYPE_ASSIGNMENT == property_type)
  689.         StyleBufferWrite(" = \"", 4, sb);
  690.     else
  691.         StyleBufferWrite("(", 1, sb);
  692.  
  693.     for (comma=FALSE; value; value=value->left, comma = TRUE) {
  694.  
  695.         if (CSS_PROPERTY_TYPE_CALL == property_type && comma)
  696.             StyleBufferWrite(",", 1, sb);
  697.  
  698.         if (value->node_id == NODE_EMPTY_OP)
  699.             StyleBufferWrite(" ", 1, sb);
  700.  
  701.         if (CSS_PROPERTY_TYPE_CALL == property_type)
  702.             StyleBufferWrite("\"", 1, sb);
  703.  
  704.         if (value->node_id == NODE_EXPR_OP)
  705.             StyleBufferWrite(value->string, 0, sb);
  706.  
  707.         term = value->right;
  708.         if (term) {
  709.             if (term->node_id == NODE_STRING)
  710.                 ConvertStringValue(term->string, sb);
  711.             else if (NODE_URL == term->node_id)
  712.                 ConvertURLValue(term->string, sb);
  713.             else {
  714.                 StyleBufferWrite(term->string, 0, sb);
  715.                 if (term->node_id == NODE_UNARY_OP)
  716.                     StyleBufferWrite(term->left->string, 0, sb);
  717.             }
  718.         }
  719.  
  720.         if (CSS_PROPERTY_TYPE_CALL == property_type)
  721.             StyleBufferWrite("\"", 1, sb);
  722.     }
  723.  
  724.     if (CSS_PROPERTY_TYPE_ASSIGNMENT == property_type)
  725.         StyleBufferWrite("\"", 1, sb);
  726.     else
  727.         StyleBufferWrite(")", 1, sb);
  728. }
  729.  
  730.  
  731. static void ConvertStringValue(char * string_value, StyleBuffer sb)
  732. {
  733.     for (; *string_value; string_value++) {
  734.         if (*string_value == '"')
  735.             StyleBufferWrite("\\", 1, sb);
  736.         StyleBufferWrite(string_value, 1, sb);
  737.     }
  738. }
  739.  
  740. static void StripURLValue(char ** url_return, int * url_length_return)
  741. {
  742.     char * ptr;
  743.     int len;
  744.  
  745.     if (! url_return || ! *url_return ||
  746.         ! url_length_return || ! *url_length_return)
  747.         return;
  748.  
  749.     ptr = *url_return;
  750.     len = *url_length_return;
  751.  
  752.     /* Skip leading whitespace */
  753.     while (len > 0 && isspace(*ptr)) {
  754.         ptr++;
  755.         len--;
  756.     }
  757.  
  758.     /* Skip trailing whitespace */
  759.     while (len > 0 && isspace(*(ptr + len - 1)))
  760.         len--;
  761.  
  762.     /* Skip enclosing quotation marks */
  763.     if (('"' == *ptr || '\'' == *ptr ) &&
  764.         (len > 1) &&
  765.         (*ptr == *(ptr + len - 1))) {
  766.         ptr++;
  767.         len -= 2;
  768.     }
  769.  
  770.     *url_return = ptr;
  771.     *url_length_return = len;
  772. }
  773.  
  774. static void ConvertURLValue(char * url_value, StyleBuffer sb)
  775. {
  776.     char * ptr = url_value;
  777.     int len;
  778.  
  779.     len = strlen(ptr);
  780.     if (len < 6)
  781.         return;
  782.  
  783.     /* Don't count the 5 characters for 'url()' */
  784.     len -= 5;
  785.     StyleBufferWrite("url(", 4, sb);
  786.     ptr += 4;
  787.  
  788.     StripURLValue(&ptr, &len);
  789.  
  790.     if (len > 0)
  791.         StyleBufferWrite(ptr, len, sb);
  792.  
  793.     StyleBufferWrite(")", 1, sb);
  794. }
  795.  
  796. #if (ALLOW_IMPORT || ALLOW_FONTDEF)
  797.  
  798. static char * open_call   = "document.write('";
  799. static char * close_call   = "');\n";
  800.  
  801. static void ConvertToLink(css_node rule, int rel_type, StyleBuffer sb)
  802. {
  803.     int len;
  804.     char * ptr;
  805.     char ch;
  806.     char hexbuf[4];
  807.  
  808.     if (rule && rule->string) {
  809.         if ((NODE_IMPORT_URL == rule->node_id) || 
  810.             (NODE_IMPORT_STRING == rule->node_id)) {
  811.  
  812.             StyleBufferWrite(open_call, 0, sb);
  813.  
  814.             if (NODE_IMPORT_LIST == rel_type)
  815.                 StyleBufferWrite("<LINK REL=stylesheet ", 21, sb);
  816.             else
  817.                 StyleBufferWrite("<LINK REL=fontdef ", 18, sb);
  818.  
  819.             /* Copy the url */
  820.             len = XP_STRLEN(rule->string);
  821.             ptr = NULL;
  822.             if ((NODE_IMPORT_URL == rule->node_id) && (len > 5)) {
  823.                 /* Copy the characters inside the parens */
  824.                 ptr = rule->string + 4;
  825.                 len -= 5;
  826.                 StripURLValue(&ptr, &len);
  827.                 if (len <= 0)
  828.                     ptr = NULL;
  829.             } else {
  830.                 /* Copy the characters inside the quotes */
  831.                 ptr = rule->string + 1;
  832.                 len -= 2;
  833.             }
  834.             if (NULL != ptr) {
  835.                 if (NODE_IMPORT_LIST == rel_type)
  836.                     StyleBufferWrite("HREF=", 5, sb);
  837.                 else
  838.                     StyleBufferWrite("SRC=", 4, sb);
  839.                 StyleBufferWrite(ptr, len, sb);
  840.             }
  841.  
  842.             StyleBufferWrite(">');\n", 5, sb);
  843.         }
  844.     }
  845. }
  846.  
  847. static char * open_style = "<style type=text/css>\\n";
  848. static char * close_style = "</style>";
  849. static char * disable_at_rules = "HI { donna : lou }\\n";
  850.  
  851. static void EchoCSS(char * src, int32 src_count, StyleBuffer sb)
  852. {
  853.     char ch;
  854.     char * start;
  855.     char * end;
  856.     int len;
  857.  
  858.     if (! src || src_count <= 0) return;
  859.  
  860.     StyleBufferWrite(open_call, 0, sb);
  861.     StyleBufferWrite(open_style, 0, sb);
  862.     StyleBufferWrite(close_call, 0, sb);
  863.  
  864.     /* Don't recurse on the @-rules! 
  865.      * Write a harmless rule at the beginning of the style sheet.
  866.      * The lexer, parser, and finally the translator will see it.
  867.      * The translator will skip @ rules which occur after any
  868.      * ordinary rule.  CSS requires that behavior for @import;
  869.      * @fontdef voluntarily observes the same restriction; there
  870.      * are no other recognized @ rules.
  871.      */
  872.     StyleBufferWrite(open_call, 0, sb);
  873.     StyleBufferWrite(disable_at_rules, 0, sb);
  874.     StyleBufferWrite(close_call, 0, sb);
  875.  
  876.     /* Echo the entire CSS buffer, escaping some characters. */
  877.     StyleBufferWrite(open_call, 0, sb);
  878.     start = src;
  879.     for (end = start; --src_count >=0; end++) {
  880.  
  881.         ch = *end;
  882.         if (('\n' == ch) || ('\'' == ch) || ('\f' == ch) ||
  883.             ('\v' == ch) || ('\r' == ch)) {
  884.             len = end - start;
  885.             if (len) {
  886.                 StyleBufferWrite(start, len, sb);
  887.                 start = end;
  888.             }
  889.  
  890.             switch (ch) {
  891.             case '\n': StyleBufferWrite("\\n", 2, sb);    break;
  892.             case '\'': StyleBufferWrite("\\'", 2, sb);    break;
  893.             case '\f': StyleBufferWrite("\\f", 2, sb);    break;
  894.             case '\v': StyleBufferWrite("\\v", 2, sb);    break;
  895.             case '\r': StyleBufferWrite("\\r", 2, sb);    break;
  896.             default  : break;
  897.             }
  898.             
  899.             start = end + 1;
  900.         }
  901.     }
  902.     len = end - start;
  903.     if (len) {
  904.         StyleBufferWrite(start, len, sb);
  905.     }
  906.     StyleBufferWrite(close_call, 0, sb);
  907.  
  908.     StyleBufferWrite(open_call, 0, sb);
  909.     StyleBufferWrite(close_style, 0, sb);
  910.     StyleBufferWrite(close_call, 0, sb);
  911.  
  912. }
  913. #endif
  914.  
  915. #ifdef TEST_CSS_TRANSLATION
  916. #define TEST_CSS_INITIAL_BUFSIZ 4096
  917. #define TEST_CSS_INCR_BUFSIZ    4096
  918.  
  919. void main()
  920. {
  921.     int ch;
  922.     char *b;
  923.     int32 src_count;
  924.     char *dst;
  925.     int32 dst_count;
  926.     char * src;
  927.     int src_size;
  928.     int done;
  929.  
  930.         
  931.     done = ch = 0;
  932.     src_size = src_count = 0;
  933.  
  934.     src = (char *) XP_ALLOC(TEST_CSS_INITIAL_BUFSIZ);
  935.     if (src) src_size = TEST_CSS_INITIAL_BUFSIZ;
  936.  
  937.     while (!done) {
  938.  
  939.         for (b = src + src_count; src_count < src_size; src_count++, b++) {
  940.             *b = ch = getc(stdin);
  941.             /* Either the null character or EOF will serve to terminate. */
  942.             if (ch == EOF || ch == '\0') {
  943.                 done = 1;
  944.                 /* We don't need to add this character to the src_count */
  945.                 break;
  946.             }
  947.         }
  948.  
  949.         if (!done) {
  950.             src_size += TEST_CSS_INCR_BUFSIZ;
  951.             src = (char *) XP_REALLOC(src, src_size);
  952.             if (!src) {
  953.                 src_size = src_count = 0;
  954.                 printf("css test: memory allocation failure\n");
  955.                 done = 1;
  956.             }
  957.         }
  958.     }
  959.  
  960.     /* The src_count need not include the terminating NULL or EOF */
  961.     CSS_ConvertToJS(src, src_count, &dst, &dst_count);
  962.     printf("%s", dst);
  963.     XP_FREE(dst);
  964. }
  965.  
  966. #endif
  967.