Make defn of UTF8_IS_START common

[perl5.git] / regcomp.h

diff --git a/regcomp.h b/regcomp.h
index d9f2cbe..520e60e 100644 (file)
--- a/regcomp.h
+++ b/regcomp.h
@@ -156,6 +156,14 @@ struct regnode_string {
     char string[1];
 };
 
+struct regnode_lstring { /* Constructed this way to keep the string aligned. */
+    U8 flags;
+    U8  type;
+    U16 next_off;
+    U32 str_len;    /* Only 16 bits allowed before would overflow 'next_off' */
+    char string[1];
+};
+
 /* Argument bearing node - workhorse, 
    arg1 is often for the data field */
 struct regnode_1 {
@@ -324,20 +332,57 @@ struct regnode_ssc {
 
 #undef OP
 #undef OPERAND
-#undef MASK
 #undef STRING
 
 #define        OP(p)           ((p)->type)
 #define FLAGS(p)       ((p)->flags)    /* Caution: Doesn't apply to all      \
                                           regnode types.  For some, it's the \
                                           character set of the regnode */
+#define        STR_LENs(p)     (__ASSERT_(OP(p) != LEXACT && OP(p) != LEXACT_ONLY8)  \
+                                    ((struct regnode_string *)p)->str_len)
+#define        STRINGs(p)      (__ASSERT_(OP(p) != LEXACT && OP(p) != LEXACT_ONLY8)  \
+                                    ((struct regnode_string *)p)->string)
+#define        OPERANDs(p)     STRINGs(p)
+
+/* Long strings.  Currently limited to length 18 bits, which handles a 262000
+ * byte string.  The limiting factor is the 16 bit 'next_off' field, which
+ * points to the next regnode, so the furthest away it can be is 2**16.  On
+ * most architectures, regnodes are 2**2 bytes long, so that yields 2**18
+ * bytes.  Should a longer string be desired, we could increase it to 26 bits
+ * fairly easily, by changing this node to have longj type which causes the ARG
+ * field to be used for the link to the next regnode (although code would have
+ * to be changed to account for this), and then use a combination of the flags
+ * and next_off fields for the length.  To get 34 bit length, also change the
+ * node to be an ARG2L, using the second 32 bit field for the length, and not
+ * using the flags nor next_off fields at all.  One could have an llstring node
+ * and even an lllstring type. */
+#define        STR_LENl(p)     (__ASSERT_(OP(p) == LEXACT || OP(p) == LEXACT_ONLY8)  \
+                                    (((struct regnode_lstring *)p)->str_len))
+#define        STRINGl(p)      (__ASSERT_(OP(p) == LEXACT || OP(p) == LEXACT_ONLY8)  \
+                                    (((struct regnode_lstring *)p)->string))
+#define        OPERANDl(p)     STRINGl(p)
+
+#define        STR_LEN(p)      ((OP(p) == LEXACT || OP(p) == LEXACT_ONLY8)           \
+                                               ? STR_LENl(p) : STR_LENs(p))
+#define        STRING(p)       ((OP(p) == LEXACT || OP(p) == LEXACT_ONLY8)           \
+                                               ? STRINGl(p)  : STRINGs(p))
 #define        OPERAND(p)      STRING(p)
 
-#define MASK(p)                ((char*)OPERAND(p))
-#define        STR_LEN(p)      (((struct regnode_string *)p)->str_len)
-#define        STRING(p)       (((struct regnode_string *)p)->string)
+/* The number of (smallest) regnode equivalents that a string of length l bytes
+ * occupies */
 #define STR_SZ(l)      (((l) + sizeof(regnode) - 1) / sizeof(regnode))
-#define NODE_SZ_STR(p) (STR_SZ(STR_LEN(p))+1)
+
+/* The number of (smallest) regnode equivalents that the EXACTISH node 'p'
+ * occupies */
+#define NODE_SZ_STR(p) (STR_SZ(STR_LEN(p)) + 1 + regarglen[(p)->type])
+
+#define setSTR_LEN(p,v)                                                     \
+    STMT_START{                                                             \
+        if (OP(p) == LEXACT || OP(p) == LEXACT_ONLY8)                       \
+            ((struct regnode_lstring *)(p))->str_len = (v);                 \
+        else                                                                \
+            ((struct regnode_string *)(p))->str_len = (v);                  \
+    } STMT_END
 
 #undef NODE_ALIGN
 #undef ARG_LOC
@@ -716,6 +761,8 @@ struct regnode_ssc {
 #  define UCHARAT(p)   ((int)*(p)&CHARMASK)
 #endif
 
+/* Number of regnode equivalents that 'guy' occupies beyond the size of the
+ * smallest regnode. */
 #define EXTRA_SIZE(guy) ((sizeof(guy)-1)/sizeof(struct regnode))
 
 #define REG_ZERO_LEN_SEEN                   0x00000001