1 /**

     2  * Copyright (C) 2008 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)

     3  *

     4  * This library is free software; you can redistribute it and/or

     5  * modify it under the terms of the GNU Library General Public

     6  * License as published by the Free Software Foundation; either

     7  * version 2 of the License, or (at your option) any later version.

     8  *

     9  * This library is distributed in the hope that it will be useful,

    10  * but WITHOUT ANY WARRANTY; without even the implied warranty of

    11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    12  * Library General Public License for more details.

    13  *

    14  * You should have received a copy of the GNU Library General Public License

    15  * along with this library; see the file COPYING.LIB.  If not, write to

    16  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,

    17  * Boston, MA 02110-1301, USA.

    18  *

    19  */

    20 

    21 #include "config.h"

    22 

    23 #if ENABLE(WML)

    24 #include "WMLVariables.h"

    25 

    26 #include "WMLDocument.h"

    27 #include <wtf/ASCIICType.h>

    28 

    29 namespace WebCore {

    30 

    31 // WML variables specification, excluding the

    32 // pre-WML 1.0 deprecated variable syntax

    33 //

    34 // varname = ("_" | alpha) ("_" | alpha | digit)* 

    35 // conv = ":" ("e" ("scape")? | "n" ("oesc")? | "u" ("nesc")?)

    36 // var = ("$" varname) | ("$(" varname (conv)? ")")

    37 

    38 static bool isValidFirstVariableNameCharacter(const UChar& character)

    39 {

    40     return WTF::isASCIIAlpha(character)

    41            || character == '_';

    42 }

    43 

    44 static bool isValidVariableNameCharacter(const UChar& character)

    45 {

    46     return WTF::isASCIIAlpha(character)

    47            || WTF::isASCIIDigit(character)

    48            || character == '_';

    49 }

    50 

    51 static bool isValidVariableEscapingModeString(const String& mode, WMLVariableEscapingMode& escapeMode)

    52 {

    53     if (mode == "e" || mode == "escape")

    54         escapeMode = WMLVariableEscapingEscape; 

    55     else if (mode == "u" || mode == "unesc")

    56         escapeMode = WMLVariableEscapingUnescape;

    57     else if (mode == "n" || mode == "noesc")

    58         escapeMode = WMLVariableEscapingNone;

    59     else

    60         return false;

    61 

    62     return true;

    63 }

    64 

    65 bool isValidVariableName(const String& name)

    66 {

    67     if (name.isEmpty())

    68         return false;

    69 

    70     const UChar* characters = name.characters();

    71     if (!isValidFirstVariableNameCharacter(characters[0]))

    72         return false;

    73 

    74     unsigned length = name.length();

    75     for (unsigned i = 1; i < length; ++i) {

    76         if (!isValidVariableNameCharacter(characters[i]))

    77             return false;

    78     }

    79 

    80     return true;

    81 }

    82 

    83 bool containsVariableReference(const String& text, bool& isValid)

    84 {

    85     isValid = true;

    86     bool foundReference = false;

    87     bool finished = false;

    88     int currentPosition = 0;

    89     const UChar* characters = text.characters();

    90 

    91     while (!finished) {

    92         // Find beginning of variable reference

    93         int referenceStartPosition = text.find('$', currentPosition);

    94         if (referenceStartPosition == -1) {

    95             finished = true;

    96             break;

    97         }

    98 

    99         foundReference = true;

   100 

   101         int nameStartPosition = referenceStartPosition + 1;

   102         int nameEndPosition = -1;

   103 

   104         if (characters[nameStartPosition] == '(') {

   105             // If the input string contains an open brace, a close brace must exist as well

   106             nameEndPosition = text.find(')', nameStartPosition + 1);

   107             if (nameEndPosition == -1) {

   108                 finished = true;

   109                 isValid = false;

   110                 break;

   111             }

   112 

   113             ++nameStartPosition;

   114         } else {

   115             int length = text.length();

   116             for (nameEndPosition = nameStartPosition; nameEndPosition < length; ++nameEndPosition) {

   117                 if (!isValidVariableNameCharacter(text[nameEndPosition]))

   118                     break;

   119             }

   120         }

   121 

   122         if (nameEndPosition < nameStartPosition) {

   123             finished = true;

   124             isValid = false;

   125             break;

   126         }

   127     

   128         // Eventually split of conversion string, and check its syntax afterwards

   129         String conversionString;

   130         String variableName = text.substring(nameStartPosition, nameEndPosition - nameStartPosition);

   131 

   132         int conversionStringStart = variableName.find(':');

   133         if (conversionStringStart != -1) {

   134             conversionString = variableName.substring(conversionStringStart + 1, variableName.length() - (conversionStringStart + 1));

   135             variableName = variableName.left(conversionStringStart);

   136         }

   137 

   138         isValid = isValidVariableName(variableName);

   139         if (!isValid) {

   140             finished = true;

   141             break;

   142         }

   143 

   144         if (!conversionString.isEmpty()) {

   145             isValid = isValidVariableName(conversionString);

   146             if (!isValid) {

   147                 finished = true;

   148                 break;

   149             }

   150 

   151             WMLVariableEscapingMode escapeMode = WMLVariableEscapingNone;

   152             isValid = isValidVariableEscapingModeString(conversionString, escapeMode);

   153             if (!isValid) {

   154                 finished = true;

   155                 break;

   156             }

   157         }

   158 

   159         currentPosition = nameEndPosition;

   160     }

   161 

   162     return foundReference;

   163 }

   164 

   165 String substituteVariableReferences(const String& reference, Document* document, WMLVariableEscapingMode escapeMode)

   166 {

   167     ASSERT(document);

   168 

   169     if (reference.isEmpty())

   170         return reference;

   171 

   172     WMLPageState* pageState = wmlPageStateForDocument(document);

   173     if (!pageState)

   174         return reference;

   175 

   176     bool isValid = true; 

   177     String remainingInput = reference;

   178     String result;

   179 

   180     while (!remainingInput.isEmpty()) {

   181         ASSERT(isValid);

   182 

   183         int start = remainingInput.find("$");

   184         if (start == -1) {

   185             // Consume all remaining characters, as there's nothing more to substitute

   186             result += remainingInput;

   187             break;

   188         }

   189 

   190         // Consume all characters until the variable reference beginning

   191         result += remainingInput.left(start);

   192         remainingInput.remove(0, start);

   193 

   194         // Transform adjacent dollar signs into a single dollar sign as string literal

   195         if (remainingInput[1] == '$') {

   196             result += "$";

   197             remainingInput.remove(0, 2);

   198             continue;

   199         }

   200 

   201         String variableName;

   202         String conversionMode;

   203 

   204         if (remainingInput[1] == '(') {

   205             int referenceEndPosition = remainingInput.find(")");

   206             if (referenceEndPosition == -1) {

   207                 isValid = false;

   208                 break;

   209             }

   210 

   211             variableName = remainingInput.substring(2, referenceEndPosition - 2);

   212             remainingInput.remove(0, referenceEndPosition + 1);

   213 

   214             // Determine variable conversion mode string

   215             int pos = variableName.find(':');

   216             if (pos != -1) {

   217                 conversionMode = variableName.substring(pos + 1, variableName.length() - (pos + 1));

   218                 variableName = variableName.left(pos);

   219             }

   220         } else {

   221             int length = remainingInput.length();

   222             int referenceEndPosition = 1;

   223 

   224             for (; referenceEndPosition < length; ++referenceEndPosition) {

   225                 if (!isValidVariableNameCharacter(remainingInput[referenceEndPosition]))

   226                     break;

   227             }

   228 

   229             variableName = remainingInput.substring(1, referenceEndPosition - 1);

   230             remainingInput.remove(0, referenceEndPosition);

   231         }

   232 

   233         isValid = isValidVariableName(variableName);

   234         if (!isValid)

   235             break;

   236 

   237         ASSERT(!variableName.isEmpty());

   238 

   239         String variableValue = pageState->getVariable(variableName);

   240         if (variableValue.isEmpty())

   241             continue;

   242 

   243         if (containsVariableReference(variableValue, isValid)) {

   244             if (!isValid)

   245                 break;

   246 

   247             variableValue = substituteVariableReferences(variableValue, document, escapeMode);

   248             continue;

   249         }

   250 

   251         if (!conversionMode.isEmpty()) {

   252             // Override default escape mode, if desired

   253             WMLVariableEscapingMode specifiedEscapeMode = WMLVariableEscapingNone; 

   254             if ((isValid = isValidVariableEscapingModeString(conversionMode, specifiedEscapeMode)))

   255                 escapeMode = specifiedEscapeMode;

   256 

   257             if (!isValid)

   258                 break;

   259         }

   260 

   261         switch (escapeMode) {

   262         case WMLVariableEscapingNone:

   263             break;

   264         case WMLVariableEscapingEscape:

   265             variableValue = encodeWithURLEscapeSequences(variableValue); 

   266             break;

   267         case WMLVariableEscapingUnescape:

   268             variableValue = decodeURLEscapeSequences(variableValue);

   269             break;

   270         }

   271 

   272         result += variableValue;

   273         ASSERT(isValid);

   274     }

   275 

   276     if (!isValid) {

   277         reportWMLError(document, WMLErrorInvalidVariableReference);

   278         return reference;

   279     }

   280 

   281     return result;

   282 }

   283 

   284 }

   285 

   286 #endif