Known Issues

Installation Known Issues

  1. SUSE
    Ignore the message "The following packages are not supported by their vendor" when doing an update. The SDK is supported as per your License subscription. SUSE has some extensions that are not part of the original RPM repository specification. This issue will be resolved in a later release of the SDK.

Workbench Known Issues

  1. ANML Format
    The workbench exports ANML using schema version 0.8 but he current version is 1.0. The SDK API's and applications can read both formats however ANML libraries are not supported in 0.8.

Compiler Application Known Issues

  1. Shell pre-processing
    If compiling a single expression make sure shell processing is turned off for the PCRE argument by enclosing it in quotation marks (double on Windows and single on Linux).
  2. Windows command shell parsing

    1. Windows command shell automatically pre-processes '"' characters. To parse an expression containing '"', use hex number 0x22 or place the expression in a file and pass the file to compiler.

    2. If you specify the "con" device as the input file to any AP application, it will appear as though the application has hung. Actually, this is the DOS way to be able to interactively input data from the command line. To terminate processing, press <ctrl-Z><return>.
      This example shows the usage of the "con" device as input for apemulate:
      apcompile -f test.ap "/ab[cde]/"
      apemulate test.ap con
      abc
      abd
      abe
      ^Z
      Match result:
      Offset 3
      Offset 7
      Offset 11
  3. ANML code generation
    Character classes containing \w are incorrectly written to the resulting ANML file.
  4. Linux command shell parsing
    Characters such as "!string" or "$string" have special meaning. If using the bash shell you may delimit the regular expression in single quotation marks to disable shell pre-processing. Additionally when using bash to parse an expression containing ''', use hex number 0x27. For other shells place the expression in a file and pass the file to the compiler.
  5. Unicode file names are supported in UTF-8 only
    This affects Windows which uses UTF-16LE. You should convert filenames to UTF-8 before calling AP API functions.

PCRE API Known Issues

  1. Match of empty string
    Expressions which are nullable on the left of a right anchor should match the empty string. For example /d*$/. The hardware cannot do this since it requires at least one byte to set the input state of the boolean logic handling EODATA.

Emulator Application Known Issues

  1. Match end position accuracy
    The end position of a match may not be accurate or complete for some expressions, specifically those that contain anchors, lookarounds, assertions, and backreferences, all of which are only partially supported (see PCRE Known Issues below).

PCRE Known Issues

By default, support for assertions and back references is disabled. The compiler can support a subset of the PCRE specification by specifying the AP_MOD_PCRE_QUASI_ASSERTION or AP_MOD_PCRE_QUASI_BACKREFS modifiers when building the expression database .

Unsupported PCRE Syntax

The following PCRE features are not supported.

  1. Once only expressions
  2. Capturing
    The compiler will treat PCRE captures as non-captured expressions. The automaton is constructed so as to ensure the position where a match occurs is preserved.
  3. Possessive and greedy quantifiers
  4. Conditional expressions
  5. Recursive expressions
  6. UTF8 and \X
    The Perl escape sequences \p, \P, and \X are supported by PCRE only when the PCRE compilation has UTF8 support enabled. PCRE does not support \X in non-UTF8 mode. The compiler does not support UTF8. Since we have no UTF8 support we do not support \X.

Partially Supported PCRE Syntax

The following PCRE features are supported with exceptions.

  1. delimiters other than '/'
    PCRE supports use of many delimiters; for example /some-regex/, 'some-regex', or "some-regex". The PCRE API supports no delimiters and /some-regex/. Other delimiters are not supported. The command line tool apcompile only supports delimited expressions.
  2. ^ \A $ \Z \z anchors
    The compiler supports ^ or \A anchors at the beginning of an expression and, $ or \Z or \z, anchors at the end of an expression. Any other placement of these anchors are meaningless since the expression would never match. For example, the compiler supports /(^a|b)/ but not /(^a|b){2}/. There are two exceptions that will match in multiline mode, \n^ and $\n, however the compiler still disallows these anchor placements. This behavior differs from PCRE which allows anchors to be placed at any position and does not flag an error when the expression can never match.
  3. U Modifier
    By default the compiler does not support the greedy/ungreedy toggle modifier because it CANNOT support a greedy/ungreedy match concept. All matches are returned by the hardware. The compiler will ignore the U modifier if the AP_MOD_PCRE_IGNORE_GREEDINESS flag is used. This flag is available to the command line compiler application by use of the -U option.
  4. Lookaheads
    1. The compiler does not support all varieties of lookaheads. The following exceptions apply to both negated and non-negated lookaheads.
      Let E be the expression and A be the lookahead assertion. Then lookahead assertions can be handled if:
      1. The assertion is an operand in a top-level right justified union.
        For cases like /...A|E/ and /...E|A/ we can treat the assertion A like a normal expression.
      2. The assertion is right-justified in a top-level concat expression.
        For cases like /...EA/ we can treat the assertion A like a normal expression.
      3. The assertion is an operand in a concat expression.
        For cases like /...AE/ and /...AE|.../ the lookahead can be approximated provided the length of the strings matched by A do not exceed those matched by E. If the provision is not enforced then the lookahead match position will be different to PCRE.
        For example /(?=abcd)ab/ should match "abcd" at character "b" but we match at character "d".
    2. Lookaheads require NFA intersection which has worst case complexity O(n^2) in both edge and state increase. This limitation may impact placement and route feasibility.
    3. Lookahead restrictions:
      1. We don't allow negated lookaheads at the beginning of an expression.
      2. The assertion cannot be right justified in a grouped union. For example expression such as /...(A|F)E/ and /...(F|A)E/ will cause an unsupported error.
      3. We don't allow negation of nullable expressions. For example /(?!.*)ab/ is not supported.
      4. We don't allow nested assertions.
  5. Lookbehinds
    1. Lookbehind assertions have less restrictions and we can handle more expressive syntax than PCRE supports. Unlike lookaheads we can support both negative and positive lookbehinds at the start of a regex.
    2. Lookbehind Restrictions:
      1. The assertion is an operand in a top-level left justified union.
        For cases like /A|E.../ and /E|A.../ we can treat the assertion A like a normal expression.
      2. We don't allow unions with lookbehind assertions but we do allow full regex support including unions within the lookbehind.
      3. We don't allow negation of nullable expressions. For example /(?<!.*)ab/ is not supported.
      4. We don't allow nested assertions.
      5. We don't allow lookbehinds to be concatenated, unless there are 2 lookbehinds at the beginning of an unanchored expression.
  6. \b assertion
    Due to the lookahead and lookbehind restrictions above, we cannot support the \b word boundary. \b is a shortcut for (?<=\W)(?=\w)|(?<=\w)(?=\W).
  7. Empty string
    The compiler cannot match the empty string and will flag a warning. For example /.*/ matches at byte offset zero but the hardware must process at least one byte to return a match.
  8. Back references and named patterns
    The compiler will repeat PCRE back references as if the sub-expression were repeated. For example /(a.*b)\1/ would be converted into /(a.*b)(a.*b)/. The compiler assumes that the original expression is a subset of the converted expression, hence it will match the original but will have some false positives that need to be processed at run time. The compiler does not support the use of back references within a negated lookahead or lookbehind since inclusion would allow false negatives.
  9. Back references of type A(B){0}\1
    The compiler will match AB whereas PCRE matches A. For any other non zero quantification the compiler agrees with PCRE subject to the previously listed back reference constraint.
  10. Empty Character Set
    The compiler does not support the empty character set and will return and error. For example, [^\w\W] and [^\d\D] are not supported since the character sets are empty.
  11. Null Quantifier
    The quantifier {0} will cause the quantifier together with its previous item to be treated as an empty string. Examples such as /(a{0})\1/ and /(a){0}\1/ will be evaluated to the empty string.
  12. Anchored Expressions Beginning With ".*"
    If the input data contains newlines, the expression will not match from the character immediately following them, as is possible in PCRE, unless the multiline mode "/s" is specified.

ANML Known Issues

  1. Exporting Local Nested Macros in ANML Objects
    There is a know issue that prevents an ANML object from being correctly exported to a single file if it contains nested macros. Currently, only the automata network and highest-level macro will be exported. Nested macros, that is, those that are referenced within another macro, will not be exported.
  2. Exporting External Nested Macros in ANML Objects
    The SDK currently does not automatically export nested macros into separate files. Instead, the user must specifically export all macros using AP_ExportAnml() on each macro beginning with the most deeply nested macros and progressing to the highest level macros.
  3. ANML macro input port connections to boolean and non-boolean elements
    There is a known issue that prevents the input port of an ANML macro to be connected to a boolean and non-boolean element at the same time.
  4. Converting regular expressions to ANML using the apcompile command-line application
    Regular expressions created using this method use ANML anchoring rules. PCRE expressions are converted from /E/ to /E/A and then ANML anchoring start-of-data anchoring is applied to the expression.
  5. Regular expressions with right anchors in ANML
    PCRE regular expression converted to ANML using the apcompile command-line application or the ANML API cannot contain right anchors $, \Z, or \z. These are not converted correctly and will result in an expression that will never match.

Licensing and Update Service Known Issues

  1. Licenses are refreshed on a daily basis and upon the startup of the computer where the SDK is installed. If the computer is disconnected from the Internet for a long period of time, the license will expire. To refresh the license, either:
    1. Manually refresh the license by running the apregister command:
      apregister --refresh (requires administrative privelages), or
    2. Restart your computer, or
    3. Wait until the next automatic refresh of the license
  2. If the SDK is to be registered on an access-control network, such as a guest network, the acceptance of usage terms and conditions must be performed before the SDK can be registered.
  3. If the network settings are changed after installation, the license will fail to refresh and the ApUpdate service will fail to download new updates. Linux-based users must modify /etc/apsdk/proxy.conf to reflect new network settings. Windows users must reinstall the APSDK package.
  4. Uninstalling the APSDK on Windows while not connected to the network will fail.
  5. Uninstalling the APSDK on Linux will prevent the license from being returned to the server. For users with limited number of node activations must wait for the license refresh period to expire prior to adding new nodes.

Python Known Issues

  1. Only 2.6 and 2.7 supported. Have not tested on every minor build.
  2. There are some install issues on Windows when using Python 2.7.1. Recommend upgrade of Python.