+ * Mirrors the original Parser.xs which contains both PACKAGE = HTML::Parser + * and PACKAGE = HTML::Entities in a single file, loaded via + * XSLoader::load('HTML::Parser'). + *
+ * Phase 1: Full HTML::Entities support (decode_entities, _decode_entities) + * plus HTML::Parser stubs for construction and configuration. + */ +public class HTMLParser extends PerlModuleBase { + + public static final String XS_VERSION = "3.83"; + + public HTMLParser() { + super("HTML::Parser", false); + } + + public static void initialize() { + HTMLParser module = new HTMLParser(); + + try { + // ============================================================ + // PACKAGE = HTML::Parser + // ============================================================ + module.registerMethod("_alloc_pstate", null); + module.registerMethod("parse", null); + module.registerMethod("eof", "parserEof", null); + + // 13 boolean attribute accessors (aliased in XS via strict_comment) + module.registerMethod("strict_comment", null); + module.registerMethod("strict_names", null); + module.registerMethod("xml_mode", null); + module.registerMethod("unbroken_text", null); + module.registerMethod("marked_sections", null); + module.registerMethod("attr_encoded", null); + module.registerMethod("case_sensitive", null); + module.registerMethod("strict_end", null); + module.registerMethod("closing_plaintext", null); + module.registerMethod("utf8_mode", null); + module.registerMethod("empty_element_tags", null); + module.registerMethod("xml_pic", null); + module.registerMethod("backquote", null); + + module.registerMethod("boolean_attribute_value", null); + module.registerMethod("handler", null); + module.registerMethod("report_tags", "tagListAccessor", null); + module.registerMethod("ignore_tags", "tagListAccessor", null); + module.registerMethod("ignore_elements", "tagListAccessor", null); + + } catch (NoSuchMethodException e) { + System.err.println("Warning: Missing HTMLParser method: " + e.getMessage()); + } + + // ============================================================ + // PACKAGE = HTML::Entities + // Cross-package registration: these functions go into the + // HTML::Entities:: namespace but are loaded by HTML::Parser's XS. + // ============================================================ + try { + java.lang.invoke.MethodHandle mh; + RuntimeCode code; + + mh = RuntimeCode.lookup.findStatic(HTMLParser.class, "decode_entities", RuntimeCode.methodType); + code = new RuntimeCode(mh, null, null); + code.isStatic = true; + GlobalVariable.getGlobalCodeRef("HTML::Entities::decode_entities").set(new RuntimeScalar(code)); + + mh = RuntimeCode.lookup.findStatic(HTMLParser.class, "_decode_entities", RuntimeCode.methodType); + code = new RuntimeCode(mh, null, null); + code.isStatic = true; + GlobalVariable.getGlobalCodeRef("HTML::Entities::_decode_entities").set(new RuntimeScalar(code)); + + mh = RuntimeCode.lookup.findStatic(HTMLParser.class, "UNICODE_SUPPORT", RuntimeCode.methodType); + code = new RuntimeCode(mh, null, null); + code.isStatic = true; + GlobalVariable.getGlobalCodeRef("HTML::Entities::UNICODE_SUPPORT").set(new RuntimeScalar(code)); + + mh = RuntimeCode.lookup.findStatic(HTMLParser.class, "_probably_utf8_chunk", RuntimeCode.methodType); + code = new RuntimeCode(mh, null, null); + code.isStatic = true; + GlobalVariable.getGlobalCodeRef("HTML::Entities::_probably_utf8_chunk").set(new RuntimeScalar(code)); + + } catch (NoSuchMethodException | IllegalAccessException e) { + System.err.println("Warning: Missing HTMLEntities method: " + e.getMessage()); + } + } + + // ================================================================ + // HTML::Parser methods + // ================================================================ + + /** + * _alloc_pstate($self) + * Allocates parser state and stores it in $self->{_hparser_xs_state}. + * We use a RuntimeHash to hold the parser configuration. + */ + public static RuntimeList _alloc_pstate(RuntimeArray args, int ctx) { + RuntimeScalar self = args.get(0); + RuntimeHash selfHash = self.hashDeref(); + + // Create parser state as a hash holding boolean flags, handlers, etc. + RuntimeHash pstate = new RuntimeHash(); + + // Initialize boolean flags to false + String[] boolFlags = { + "strict_comment", "strict_names", "xml_mode", "unbroken_text", + "marked_sections", "attr_encoded", "case_sensitive", "strict_end", + "closing_plaintext", "utf8_mode", "empty_element_tags", "xml_pic", + "backquote" + }; + for (String flag : boolFlags) { + pstate.put(flag, scalarFalse); + } + + // Initialize handler slots + String[] events = { + "declaration", "comment", "start", "end", "text", + "process", "start_document", "end_document", "default" + }; + RuntimeHash handlers = new RuntimeHash(); + for (String event : events) { + handlers.put(event + "_cb", scalarUndef); + handlers.put(event + "_argspec", scalarUndef); + } + pstate.put("_handlers", handlers.createReference()); + + // State tracking + pstate.put("_parsing", scalarFalse); + pstate.put("_eof", scalarFalse); + pstate.put("_buf", new RuntimeScalar("")); + pstate.put("_bool_attr_val", scalarUndef); + + // Store in self + selfHash.put("_hparser_xs_state", pstate.createReference()); + + return new RuntimeList(); + } + + /** + * parse($self, $chunk) + * Feeds HTML to the parser. Phase 1: basic event-driven parsing. + */ + public static RuntimeList parse(RuntimeArray args, int ctx) { + RuntimeScalar self = args.get(0); + RuntimeHash selfHash = self.hashDeref(); + RuntimeHash pstate = getPstate(selfHash); + + if (pstate.get("_parsing").getBoolean()) { + throw new RuntimeException("Parse loop not allowed"); + } + + pstate.put("_parsing", scalarTrue); + + try { + if (args.size() > 1) { + RuntimeScalar chunk = args.get(1); + if (chunk.getDefinedBoolean()) { + String html = pstate.get("_buf").toString() + chunk.toString(); + pstate.put("_buf", new RuntimeScalar("")); + parseHtml(selfHash, pstate, html); + } + } + } finally { + pstate.put("_parsing", scalarFalse); + } + + if (pstate.get("_eof").getBoolean()) { + pstate.put("_eof", scalarFalse); + return scalarUndef.getList(); + } + return self.getList(); + } + + /** + * eof($self) + * Signals end-of-document, flushes buffered text. + */ + public static RuntimeList parserEof(RuntimeArray args, int ctx) { + RuntimeScalar self = args.get(0); + RuntimeHash selfHash = self.hashDeref(); + RuntimeHash pstate = getPstate(selfHash); + + if (pstate.get("_parsing").getBoolean()) { + pstate.put("_eof", scalarTrue); + } else { + pstate.put("_parsing", scalarTrue); + try { + // Flush any remaining buffered text + String remaining = pstate.get("_buf").toString(); + if (!remaining.isEmpty()) { + pstate.put("_buf", new RuntimeScalar("")); + parseHtml(selfHash, pstate, remaining); + } + // Fire end_document event + fireEvent(selfHash, pstate, "end_document"); + } finally { + pstate.put("_parsing", scalarFalse); + } + } + return self.getList(); + } + + // 13 boolean attribute getter/setters - each delegates to booleanAccessorHelper + public static RuntimeList strict_comment(RuntimeArray args, int ctx) { return booleanAccessorHelper(args, "strict_comment"); } + public static RuntimeList strict_names(RuntimeArray args, int ctx) { return booleanAccessorHelper(args, "strict_names"); } + public static RuntimeList xml_mode(RuntimeArray args, int ctx) { return booleanAccessorHelper(args, "xml_mode"); } + public static RuntimeList unbroken_text(RuntimeArray args, int ctx) { return booleanAccessorHelper(args, "unbroken_text"); } + public static RuntimeList marked_sections(RuntimeArray args, int ctx) { return booleanAccessorHelper(args, "marked_sections"); } + public static RuntimeList attr_encoded(RuntimeArray args, int ctx) { return booleanAccessorHelper(args, "attr_encoded"); } + public static RuntimeList case_sensitive(RuntimeArray args, int ctx) { return booleanAccessorHelper(args, "case_sensitive"); } + public static RuntimeList strict_end(RuntimeArray args, int ctx) { return booleanAccessorHelper(args, "strict_end"); } + public static RuntimeList closing_plaintext(RuntimeArray args, int ctx) { return booleanAccessorHelper(args, "closing_plaintext"); } + public static RuntimeList utf8_mode(RuntimeArray args, int ctx) { return booleanAccessorHelper(args, "utf8_mode"); } + public static RuntimeList empty_element_tags(RuntimeArray args, int ctx) { return booleanAccessorHelper(args, "empty_element_tags"); } + public static RuntimeList xml_pic(RuntimeArray args, int ctx) { return booleanAccessorHelper(args, "xml_pic"); } + public static RuntimeList backquote(RuntimeArray args, int ctx) { return booleanAccessorHelper(args, "backquote"); } + + private static RuntimeList booleanAccessorHelper(RuntimeArray args, String attrName) { + RuntimeScalar self = args.get(0); + RuntimeHash selfHash = self.hashDeref(); + RuntimeHash pstate = getPstate(selfHash); + + RuntimeScalar old = pstate.get(attrName); + RuntimeScalar retval = (old != null && old.getBoolean()) ? scalarTrue : scalarFalse; + if (args.size() > 1) { + pstate.put(attrName, args.get(1).getBoolean() ? scalarTrue : scalarFalse); + } + return retval.getList(); + } + + /** + * boolean_attribute_value($pstate, [$new_value]) + */ + public static RuntimeList boolean_attribute_value(RuntimeArray args, int ctx) { + RuntimeScalar self = args.get(0); + RuntimeHash selfHash = self.hashDeref(); + RuntimeHash pstate = getPstate(selfHash); + + RuntimeScalar old = pstate.get("_bool_attr_val"); + if (args.size() > 1) { + pstate.put("_bool_attr_val", args.get(1)); + } + return old.getList(); + } + + /** + * handler($pstate, $eventname, [$callback, $argspec]) + */ + public static RuntimeList handler(RuntimeArray args, int ctx) { + RuntimeScalar self = args.get(0); + RuntimeHash selfHash = self.hashDeref(); + RuntimeHash pstate = getPstate(selfHash); + + if (args.size() < 2) { + throw new RuntimeException("Usage: $p->handler(event => cb, argspec)"); + } + + String eventName = args.get(1).toString(); + RuntimeHash handlers = pstate.get("_handlers").hashDeref(); + + // Return old handler + RuntimeScalar oldCb = handlers.get(eventName + "_cb"); + + // Update handler if new callback provided + if (args.size() > 2) { + RuntimeScalar newCb = args.get(2); + handlers.put(eventName + "_cb", newCb); + } + if (args.size() > 3) { + RuntimeScalar argspec = args.get(3); + handlers.put(eventName + "_argspec", argspec); + } + + return (oldCb != null) ? oldCb.getList() : scalarUndef.getList(); + } + + /** + * Tag list accessor (report_tags, ignore_tags, ignore_elements). + */ + public static RuntimeList tagListAccessor(RuntimeArray args, int ctx) { + // Phase 1 stub - tag filtering not yet implemented + return new RuntimeList(); + } + + // ================================================================ + // HTML::Entities methods (PACKAGE = HTML::Entities in Parser.xs) + // ================================================================ + + /** + * decode_entities(...) + *
+ * In void context: decodes entities in-place in the arguments. + * In scalar context with multiple args: only processes first argument, returns copy. + * In list context: returns decoded copies of all arguments. + */ + public static RuntimeList decode_entities(RuntimeArray args, int ctx) { + RuntimeHash entity2char = GlobalVariable.getGlobalHash("HTML::Entities::entity2char"); + + int items = args.size(); + if (ctx == RuntimeContextType.SCALAR && items > 1) { + items = 1; + } + + if (ctx == RuntimeContextType.VOID) { + // Void context: modify in-place + for (int i = 0; i < items; i++) { + RuntimeScalar sv = args.get(i); + String decoded = decodeEntitiesString(sv.toString(), entity2char, false); + sv.set(decoded); + } + return new RuntimeList(); + } else { + // Scalar/list context: return decoded copies + RuntimeList result = new RuntimeList(); + for (int i = 0; i < items; i++) { + String decoded = decodeEntitiesString(args.get(i).toString(), entity2char, false); + result.add(new RuntimeScalar(decoded)); + } + return result; + } + } + + /** + * _decode_entities($string, \%entity2char, $expand_prefix) + * In-place decode with explicit entity hash and optional prefix expansion. + */ + public static RuntimeList _decode_entities(RuntimeArray args, int ctx) { + if (args.size() < 2) { + throw new RuntimeException("Usage: _decode_entities(string, entity2char_hash, [expand_prefix])"); + } + + RuntimeScalar stringSv = args.get(0); + RuntimeScalar entitiesSv = args.get(1); + boolean expandPrefix = args.size() > 2 && args.get(2).getBoolean(); + + RuntimeHash entityHash = null; + if (entitiesSv.getDefinedBoolean()) { + if (RuntimeScalarType.isReference(entitiesSv)) { + try { + entityHash = entitiesSv.hashDeref(); + } catch (Exception e) { + // Not a hash reference + } + } + if (entityHash == null) { + throw new RuntimeException("2nd argument must be hash reference"); + } + } + + String decoded = decodeEntitiesString(stringSv.toString(), entityHash, expandPrefix); + stringSv.set(decoded); + + return new RuntimeList(); + } + + /** + * UNICODE_SUPPORT() - always returns 1 + */ + public static RuntimeList UNICODE_SUPPORT(RuntimeArray args, int ctx) { + return new RuntimeScalar(1).getList(); + } + + /** + * _probably_utf8_chunk($string) - checks if string looks like valid UTF-8 + */ + public static RuntimeList _probably_utf8_chunk(RuntimeArray args, int ctx) { + if (args.isEmpty()) { + return scalarFalse.getList(); + } + String s = args.get(0).toString(); + for (int i = 0; i < s.length(); i++) { + if (s.charAt(i) > 0x7F) { + return scalarTrue.getList(); + } + } + return scalarFalse.getList(); + } + + // ================================================================ + // Internal helpers + // ================================================================ + + /** + * Retrieve the parser state hash from $self->{_hparser_xs_state}. + */ + private static RuntimeHash getPstate(RuntimeHash selfHash) { + RuntimeScalar ref = selfHash.get("_hparser_xs_state"); + if (ref == null || !ref.getDefinedBoolean()) { + throw new RuntimeException("HTML::Parser not initialized (missing _hparser_xs_state)"); + } + return ref.hashDeref(); + } + + /** + * Fire a parser event by calling the registered handler. + */ + private static void fireEvent(RuntimeHash selfHash, RuntimeHash pstate, String eventName, RuntimeScalar... eventArgs) { + RuntimeHash handlers = pstate.get("_handlers").hashDeref(); + RuntimeScalar cb = handlers.get(eventName + "_cb"); + + if (cb == null || !cb.getDefinedBoolean()) { + return; + } + + RuntimeArray callArgs = new RuntimeArray(); + + // Parse argspec to determine what arguments to pass + RuntimeScalar argspecSv = handlers.get(eventName + "_argspec"); + String argspec = (argspecSv != null && argspecSv.getDefinedBoolean()) ? + argspecSv.toString() : ""; + + if (cb.type == RuntimeScalarType.STRING) { + // Method name - call as $self->method(...) + String methodName = cb.toString(); + RuntimeScalar selfRef = selfHash.createReference(); + RuntimeArray.push(callArgs, selfRef); + for (RuntimeScalar arg : eventArgs) { + RuntimeArray.push(callArgs, arg); + } + // Look up method in the object's class hierarchy + int blessId = RuntimeScalarType.blessedId(selfRef); + String className = (blessId != 0) ? + NameNormalizer.getBlessStr(blessId) : "HTML::Parser"; + RuntimeScalar method = InheritanceResolver.findMethodInHierarchy( + methodName, className, null, 0); + if (method != null) { + RuntimeCode.apply(method, callArgs, RuntimeContextType.VOID); + } + } else if (cb.type == RuntimeScalarType.REFERENCE || cb.type == RuntimeScalarType.CODE) { + // Code reference - call directly + for (RuntimeScalar arg : eventArgs) { + RuntimeArray.push(callArgs, arg); + } + RuntimeCode.apply(cb, callArgs, RuntimeContextType.VOID); + } + } + + /** + * Basic HTML parser - fires text, start, end events. + * This is a simplified version; Phase 2 will port the full hparser.c logic. + */ + private static void parseHtml(RuntimeHash selfHash, RuntimeHash pstate, String html) { + int len = html.length(); + int i = 0; + int textStart = 0; + + while (i < len) { + if (html.charAt(i) == '<') { + // Flush pending text + if (i > textStart) { + fireEvent(selfHash, pstate, "text", + new RuntimeScalar(html.substring(textStart, i))); + } + + int tagStart = i; + i++; // skip '<' + + if (i < len && html.charAt(i) == '/') { + // End tag + i++; + int nameStart = i; + while (i < len && html.charAt(i) != '>' && !Character.isWhitespace(html.charAt(i))) { + i++; + } + String tagName = html.substring(nameStart, i).toLowerCase(); + while (i < len && html.charAt(i) != '>') i++; + if (i < len) i++; // skip '>' + + fireEvent(selfHash, pstate, "end", + new RuntimeScalar(tagName), + new RuntimeScalar(html.substring(tagStart, i))); + textStart = i; + } else if (i < len && html.charAt(i) == '!') { + // Comment or declaration + i++; + if (i + 1 < len && html.charAt(i) == '-' && html.charAt(i + 1) == '-') { + // Comment + i += 2; + int commentStart = i; + int endIdx = html.indexOf("-->", i); + if (endIdx >= 0) { + String comment = html.substring(commentStart, endIdx); + i = endIdx + 3; + fireEvent(selfHash, pstate, "comment", + new RuntimeScalar(comment)); + } else { + // Unterminated comment - buffer it + pstate.put("_buf", new RuntimeScalar(html.substring(tagStart))); + return; + } + } else { + // Declaration + int endIdx = html.indexOf('>', i); + if (endIdx >= 0) { + String decl = html.substring(tagStart, endIdx + 1); + i = endIdx + 1; + fireEvent(selfHash, pstate, "declaration", + new RuntimeScalar(decl)); + } else { + pstate.put("_buf", new RuntimeScalar(html.substring(tagStart))); + return; + } + } + textStart = i; + } else if (i < len && html.charAt(i) == '?') { + // Processing instruction + int endIdx = html.indexOf("?>", i); + if (endIdx >= 0) { + String pi = html.substring(tagStart, endIdx + 2); + i = endIdx + 2; + fireEvent(selfHash, pstate, "process", + new RuntimeScalar(pi)); + } else { + pstate.put("_buf", new RuntimeScalar(html.substring(tagStart))); + return; + } + textStart = i; + } else { + // Start tag + int nameStart = i; + while (i < len && html.charAt(i) != '>' && html.charAt(i) != '/' + && !Character.isWhitespace(html.charAt(i))) { + i++; + } + String tagName = html.substring(nameStart, i).toLowerCase(); + + // Parse attributes + RuntimeHash attrs = new RuntimeHash(); + RuntimeArray attrSeq = new RuntimeArray(); + + while (i < len && html.charAt(i) != '>' && html.charAt(i) != '/') { + // Skip whitespace + while (i < len && Character.isWhitespace(html.charAt(i))) i++; + if (i >= len || html.charAt(i) == '>' || html.charAt(i) == '/') break; + + // Attribute name + int attrNameStart = i; + while (i < len && html.charAt(i) != '=' && html.charAt(i) != '>' + && html.charAt(i) != '/' && !Character.isWhitespace(html.charAt(i))) { + i++; + } + String attrName = html.substring(attrNameStart, i).toLowerCase(); + RuntimeArray.push(attrSeq, new RuntimeScalar(attrName)); + + // Skip whitespace + while (i < len && Character.isWhitespace(html.charAt(i))) i++; + + String attrValue = attrName; // boolean attribute default + if (i < len && html.charAt(i) == '=') { + i++; // skip '=' + while (i < len && Character.isWhitespace(html.charAt(i))) i++; + + if (i < len) { + if (html.charAt(i) == '"' || html.charAt(i) == '\'') { + char quote = html.charAt(i); + i++; + int valStart = i; + while (i < len && html.charAt(i) != quote) i++; + attrValue = html.substring(valStart, i); + if (i < len) i++; // skip closing quote + } else { + int valStart = i; + while (i < len && html.charAt(i) != '>' + && !Character.isWhitespace(html.charAt(i))) { + i++; + } + attrValue = html.substring(valStart, i); + } + } + } + attrs.put(attrName, new RuntimeScalar(attrValue)); + } + + // Handle self-closing /> + boolean selfClosing = false; + if (i < len && html.charAt(i) == '/') { + selfClosing = true; + i++; + } + if (i < len && html.charAt(i) == '>') i++; + + String origText = html.substring(tagStart, i); + + fireEvent(selfHash, pstate, "start", + new RuntimeScalar(tagName), + attrs.createReference(), + attrSeq.createReference(), + new RuntimeScalar(origText)); + + if (selfClosing) { + fireEvent(selfHash, pstate, "end", + new RuntimeScalar(tagName), + new RuntimeScalar("")); + } + textStart = i; + } + } else { + i++; + } + } + + // Flush remaining text + if (textStart < len) { + fireEvent(selfHash, pstate, "text", + new RuntimeScalar(html.substring(textStart))); + } + } + + // ================================================================ + // Entity decoding core (ported from util.c decode_entities) + // ================================================================ + + /** + * Core entity decoding algorithm, ported from util.c decode_entities(). + * Handles numeric entities (decimal/hex), named entities, surrogate pairs, + * and prefix expansion mode. + */ + private static String decodeEntitiesString(String input, RuntimeHash entity2char, boolean expandPrefix) { + if (input == null || input.isEmpty()) { + return input; + } + + StringBuilder result = new StringBuilder(input.length()); + int len = input.length(); + int i = 0; + int highSurrogate = 0; + + while (i < len) { + char ch = input.charAt(i); + if (ch != '&') { + result.append(ch); + i++; + continue; + } + + int entStart = i; + i++; // skip '&' + + if (i >= len) { + result.append('&'); + continue; + } + + String replacement = null; + + if (input.charAt(i) == '#') { + // Numeric entity + i++; // skip '#' + long num = 0; + boolean ok = false; + + if (i < len && (input.charAt(i) == 'x' || input.charAt(i) == 'X')) { + // Hex: &#xHH; + i++; + while (i < len) { + int digit = hexDigit(input.charAt(i)); + if (digit < 0) break; + num = (num << 4) | digit; + if (num > 0x10FFFF) { ok = false; break; } + i++; + ok = true; + } + } else { + // Decimal: &#NNN; + while (i < len && input.charAt(i) >= '0' && input.charAt(i) <= '9') { + num = num * 10 + (input.charAt(i) - '0'); + if (num > 0x10FFFF) { ok = false; break; } + i++; + ok = true; + } + } + + if (num > 0 && ok) { + // Handle surrogates (matching C code logic) + if ((num & 0xFFFFFC00L) == 0xDC00L) { + // Low surrogate + if (highSurrogate != 0) { + // Combine with previous high surrogate + num = ((long) (highSurrogate - 0xD800) << 10) + + (num - 0xDC00) + 0x10000; + highSurrogate = 0; + // Remove previously appended U+FFFD + if (result.length() > 0 && result.charAt(result.length() - 1) == '\uFFFD') { + result.setLength(result.length() - 1); + } + } else { + num = 0xFFFD; + } + } else if ((num & 0xFFFFFC00L) == 0xD800L) { + // High surrogate + highSurrogate = (int) num; + num = 0xFFFD; + } else { + highSurrogate = 0; + if (num == 0xFFFE || num == 0xFFFF) { + // Illegal + ok = false; + } else if ((num >= 0xFDD0 && num <= 0xFDEF) || + ((num & 0xFFFE) == 0xFFFE) || + num > 0x10FFFF) { + num = 0xFFFD; + } + } + + if (ok && num > 0) { + replacement = new String(Character.toChars((int) num)); + } + } + + if (replacement == null) { + highSurrogate = 0; + } + } else { + // Named entity + int nameStart = i; + while (i < len && isAlnum(input.charAt(i))) { + i++; + } + + if (i > nameStart && entity2char != null) { + String entityName = input.substring(nameStart, i); + + // Try exact match without semicolon + RuntimeScalar val = entity2char.get(entityName); + if (val != null && val.getDefinedBoolean()) { + replacement = val.toString(); + } + + // Try with semicolon appended (for entities keyed with trailing ";") + if (replacement == null && i < len && input.charAt(i) == ';') { + val = entity2char.get(entityName + ";"); + if (val != null && val.getDefinedBoolean()) { + replacement = val.toString(); + } + } + + // Prefix expansion mode + if (replacement == null && expandPrefix) { + for (int end = i - 1; end > nameStart; end--) { + String prefix = input.substring(nameStart, end); + val = entity2char.get(prefix); + if (val != null && val.getDefinedBoolean()) { + replacement = val.toString(); + i = end; + break; + } + } + } + } + highSurrogate = 0; + } + + if (replacement != null) { + // Consume trailing semicolon if present + if (i < len && input.charAt(i) == ';') { + i++; + } + result.append(replacement); + + if (i >= len || input.charAt(i) != '&') { + highSurrogate = 0; + } + } else { + // No match - output original text + result.append(input, entStart, i); + } + } + + return result.toString(); + } + + private static int hexDigit(char c) { + if (c >= '0' && c <= '9') return c - '0'; + if (c >= 'a' && c <= 'f') return c - 'a' + 10; + if (c >= 'A' && c <= 'F') return c - 'A' + 10; + return -1; + } + + private static boolean isAlnum(char c) { + return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || + (c >= '0' && c <= '9') || c == '_'; + } +} diff --git a/src/main/java/org/perlonjava/runtime/perlmodule/MIMEBase64.java b/src/main/java/org/perlonjava/runtime/perlmodule/MIMEBase64.java index 8e102f090..d218eb383 100644 --- a/src/main/java/org/perlonjava/runtime/perlmodule/MIMEBase64.java +++ b/src/main/java/org/perlonjava/runtime/perlmodule/MIMEBase64.java @@ -5,6 +5,7 @@ import org.perlonjava.runtime.runtimetypes.RuntimeList; import org.perlonjava.runtime.runtimetypes.RuntimeScalar; import org.perlonjava.runtime.util.Base64Util; +import org.perlonjava.runtime.runtimetypes.GlobalVariable; import java.nio.charset.StandardCharsets; @@ -18,6 +19,7 @@ public static void initialize() { MIMEBase64 base64 = new MIMEBase64(); base64.initializeExporter(); base64.defineExport("EXPORT", "encode_base64", "decode_base64"); + GlobalVariable.getGlobalVariable("MIME::Base64::VERSION").set(new RuntimeScalar("3.16")); try { base64.registerMethod("encode_base64", null); base64.registerMethod("decode_base64", null); diff --git a/src/main/java/org/perlonjava/runtime/regex/RegexPreprocessor.java b/src/main/java/org/perlonjava/runtime/regex/RegexPreprocessor.java index 737b8179c..1244badf4 100644 --- a/src/main/java/org/perlonjava/runtime/regex/RegexPreprocessor.java +++ b/src/main/java/org/perlonjava/runtime/regex/RegexPreprocessor.java @@ -741,6 +741,14 @@ static int handleRegex(String s, int offset, StringBuilder sb, RegexFlags regexF // Remove \G from the pattern string for Java compilation if (s.startsWith("\\G", offset)) { offset += 2; + // Also strip any quantifier that followed \G (e.g. \G? in (\G?[ac])?) + // Since \G is a zero-width assertion, \G? is effectively nothing + if (offset < length) { + char next = s.charAt(offset); + if (next == '?' || next == '*' || next == '+') { + offset++; + } + } } while (offset < length) { @@ -751,18 +759,18 @@ static int handleRegex(String s, int offset, StringBuilder sb, RegexFlags regexF case '*': case '+': case '?': - // Check if this is at the start or after certain characters - if (offset == 0 || sb.length() == 0) { - regexError(s, offset + 1, "Quantifier follows nothing"); - } - - // Check what the last character was - if (sb.length() > 0) { - char lastChar = sb.charAt(sb.length() - 1); - // Check if quantifier follows | - if (lastChar == '|') { - regexError(s, offset + 1, "Quantifier follows nothing"); + // Check if the previous item can be quantified + if (!lastWasQuantifiable) { + // Distinguish "Nested quantifiers" from "Quantifier follows nothing": + // If the last char in sb is a quantifier, this is a nested quantifier + if (sb.length() > 0) { + char lc = sb.charAt(sb.length() - 1); + boolean esc = sb.length() >= 2 && sb.charAt(sb.length() - 2) == '\\'; + if (!esc && (lc == '*' || lc == '+' || lc == '?' || lc == '}')) { + regexError(s, offset + 1, "Nested quantifiers"); + } } + regexError(s, offset + 1, "Quantifier follows nothing"); } // Check if this might be a possessive quantifier @@ -771,15 +779,6 @@ static int handleRegex(String s, int offset, StringBuilder sb, RegexFlags regexF // Check if this might be a non-greedy quantifier boolean isNonGreedy = offset + 1 < length && s.charAt(offset + 1) == '?'; - // Check what the last character was - if (sb.length() > 0) { - char lastChar = sb.charAt(sb.length() - 1); - // Check if quantifier follows | - if (lastChar == '|') { - regexError(s, offset + 1, "Quantifier follows nothing"); - } - } - // Check for nested quantifiers (but not possessive or non-greedy) if (!isPossessive && !isNonGreedy && sb.length() > 0) { char lastChar = sb.charAt(sb.length() - 1); @@ -1036,11 +1035,13 @@ private static int handleParentheses(String s, int offset, int length, StringBui } else if (c3 == '<' && c4 == '=') { // Positive lookbehind (?<=...) validateLookbehindLength(s, offset); - offset = handleRegularParentheses(s, offset, length, sb, regexFlags); + sb.append("(?<="); + offset = handleRegex(s, offset + 4, sb, regexFlags, true); } else if (c3 == '<' && c4 == '!') { // Negative lookbehind (? ... ) offset = handleNamedCapture(c3, s, offset, length, sb, regexFlags); @@ -1064,16 +1065,20 @@ private static int handleParentheses(String s, int offset, int length, StringBui return RegexPreprocessorHelper.handleFlagModifiers(s, offset, sb, regexFlags); } else if (c3 == ':') { // Handle non-capturing group (?:...) - offset = handleRegularParentheses(s, offset, length, sb, regexFlags); + sb.append("(?:"); + offset = handleRegex(s, offset + 3, sb, regexFlags, true); } else if (c3 == '=') { // Positive lookahead (?=...) - offset = handleRegularParentheses(s, offset, length, sb, regexFlags); + sb.append("(?="); + offset = handleRegex(s, offset + 3, sb, regexFlags, true); } else if (c3 == '!') { // Negative lookahead (?!...) - offset = handleRegularParentheses(s, offset, length, sb, regexFlags); + sb.append("(?!"); + offset = handleRegex(s, offset + 3, sb, regexFlags, true); } else if (c3 == '>') { // Atomic group (?>...) - non-backtracking group - offset = handleRegularParentheses(s, offset, length, sb, regexFlags); + sb.append("(?>"); + offset = handleRegex(s, offset + 3, sb, regexFlags, true); } else if (c3 == '|') { // Handle (?|...) branch reset groups offset = handleBranchReset(s, offset, length, sb, regexFlags); diff --git a/src/main/java/org/perlonjava/runtime/runtimetypes/GlobalContext.java b/src/main/java/org/perlonjava/runtime/runtimetypes/GlobalContext.java index b3a5659d9..52f97f42b 100644 --- a/src/main/java/org/perlonjava/runtime/runtimetypes/GlobalContext.java +++ b/src/main/java/org/perlonjava/runtime/runtimetypes/GlobalContext.java @@ -248,11 +248,11 @@ public static void initializeGlobals(CompilerOptions compilerOptions) { // Deferred to XSLoader::load() for faster startup - only loaded when actually used: // UnicodeNormalize.initialize(); // Has XSLoader in Perl file // TimeHiRes.initialize(); // Has XSLoader in Perl file + // Encode.initialize(); // Has XSLoader in Perl file - deferred for Encode::Alias support UnicodeUCD.initialize(); // No XSLoader in Perl file - needed at startup TermReadLine.initialize(); // No Perl file - needed at startup TermReadKey.initialize(); // No Perl file - needed at startup FileTemp.initialize(); // Perl uses eval require - keep for cleanup hooks - Encode.initialize(); // Common enough to keep // JavaSystem.initialize(); // Only for java:: integration PerlIO.initialize(); IOHandle.initialize(); // IO::Handle methods (_sync, _error, etc.) diff --git a/src/main/perl/lib/Clone/PP.pm b/src/main/perl/lib/Clone/PP.pm new file mode 100644 index 000000000..c65179205 --- /dev/null +++ b/src/main/perl/lib/Clone/PP.pm @@ -0,0 +1,77 @@ +package Clone::PP; + +use strict; +use warnings; + +our $VERSION = '1.09'; + +use Scalar::Util qw(reftype blessed refaddr); +use Exporter 'import'; +our @EXPORT_OK = qw(clone); + +sub clone { + return _clone_data($_[0], {}); +} + +sub _clone_data { + my ($data, $seen) = @_; + + return $data unless ref($data); + + # Handle circular references + my $addr = refaddr($data); + return $seen->{$addr} if exists $seen->{$addr}; + + my $rtype = reftype($data); + my $class = blessed($data); + + if ($rtype eq 'HASH') { + my $clone = {}; + $seen->{$addr} = $clone; + for my $key (keys %$data) { + $clone->{$key} = _clone_data($data->{$key}, $seen); + } + bless $clone, $class if defined $class; + return $clone; + } + + if ($rtype eq 'ARRAY') { + my $clone = []; + $seen->{$addr} = $clone; + for my $item (@$data) { + push @$clone, _clone_data($item, $seen); + } + bless $clone, $class if defined $class; + return $clone; + } + + if ($rtype eq 'SCALAR' || $rtype eq 'REF') { + my $clone = \(my $copy = $$data); + $seen->{$addr} = $clone; + bless $clone, $class if defined $class; + return $clone; + } + + # CODE, GLOB, IO, Regexp - return as-is (immutable or not deep-cloneable) + return $data; +} + +1; +__END__ + +=head1 NAME + +Clone::PP - Recursively copy Perl datatypes (pure Perl) + +=head1 SYNOPSIS + + use Clone::PP 'clone'; + my $copy = clone($data); + +=head1 DESCRIPTION + +Pure Perl deep clone implementation. Handles hashes, arrays, scalar refs, +and circular references. Code refs, globs, and regexps are returned as-is +(shared, not copied) since they are immutable or not safely cloneable. + +=cut diff --git a/src/main/perl/lib/Encode.pm b/src/main/perl/lib/Encode.pm index 491604a8f..730177b1f 100644 --- a/src/main/perl/lib/Encode.pm +++ b/src/main/perl/lib/Encode.pm @@ -17,4 +17,44 @@ our @EXPORT_OK = qw( use XSLoader; XSLoader::load('Encode', $VERSION); +# Save reference to the Java-backed find_encoding before overriding. +# The Java method handles known charsets (UTF-8, latin1, ascii, etc.) directly. +my $_java_find_encoding = \&find_encoding; + +# Override find_encoding to add Encode::Alias support. +# The Java backend only recognises hardcoded charset names. This wrapper +# consults Encode::Alias (loaded by modules like Encode::Locale) to resolve +# custom aliases (coderef, regex, string) before delegating to Java. +{ + no warnings 'redefine'; + my %_resolving; # per-name recursion guard + *find_encoding = sub { + my ($name, $skip_external) = @_; + return undef unless defined $name; + + # Fast path: try the Java charset lookup first + my $enc = eval { $_java_find_encoding->($name) }; + return $enc if defined $enc; + + # Guard against circular alias chains for the same name + return undef if $_resolving{$name}; + local $_resolving{$name} = 1; + + # Consult Encode::Alias if it has been loaded + if (defined &Encode::Alias::find_alias) { + my $resolved = eval { Encode::Alias::find_alias("Encode", $name) }; + return $resolved if defined $resolved; + } + + return undef; + }; +} + +sub resolve_alias { + my ($name) = @_; + my $enc = find_encoding($name); + return unless defined $enc; + return ref($enc) ? $enc->{Name} : $enc; +} + 1; diff --git a/src/main/perl/lib/ExtUtils/MakeMaker.pm b/src/main/perl/lib/ExtUtils/MakeMaker.pm index f7bc8dc7e..7b964f2b6 100644 --- a/src/main/perl/lib/ExtUtils/MakeMaker.pm +++ b/src/main/perl/lib/ExtUtils/MakeMaker.pm @@ -252,74 +252,71 @@ sub _install_pure_perl { if (!%pm) { print "Warning: No installable files found (no .pm, .pl, .dat, etc.).\n"; print "Expected structure: lib/Your/Module.pm\n\n"; - return PerlOnJava::MM::Installed->new($args); + my $mm = PerlOnJava::MM::Installed->new($args); + _create_mymeta($name, $version, $args); + _create_install_makefile($name, $version, $args, {}, {}, $mm); + return $mm; } - print "\nInstalling to: $INSTALL_BASE\n\n"; + print "\nWill install to: $INSTALL_BASE\n\n"; - # Install .pm files - my $installed = 0; + # List files to be installed (deferred to 'make' for proper CPAN.pm dep resolution) for my $src (sort keys %pm) { - my $dest = $pm{$src}; - my $dir = dirname($dest); - - if (!-d $dir) { - make_path($dir) or warn "Failed to create $dir: $!\n"; - } - - print " $src -> $dest\n"; - if (copy($src, $dest)) { - $installed++; - } else { - warn " Failed to copy: $!\n"; + print " $src -> $pm{$src}\n"; + } + + # Collect share directory files (don't copy yet) + my %share_files = _build_share_file_mapping($name, $args); + if (%share_files) { + print "\nShare files:\n"; + for my $src (sort keys %share_files) { + print " $src -> $share_files{$src}\n"; } + %pm = (%pm, %share_files); } - # Install scripts + # Collect script files + my %scripts; if ($args->{EXE_FILES} && @{$args->{EXE_FILES}}) { - print "\nInstalling scripts:\n"; my $bin_dir = File::Spec->catdir($INSTALL_BASE, '..', 'bin'); - make_path($bin_dir) unless -d $bin_dir; - for my $script (@{$args->{EXE_FILES}}) { - my $dest = File::Spec->catfile($bin_dir, basename($script)); - print " $script -> $dest\n"; - copy($script, $dest) or warn " Failed to copy: $!\n"; + $scripts{$script} = File::Spec->catfile($bin_dir, basename($script)); + } + print "\nScripts:\n"; + for my $src (sort keys %scripts) { + print " $src -> $scripts{$src}\n"; } } - # Install share directories (File::ShareDir::Install support) - $installed += _install_share_dirs($name, $args); - print "\n"; - print "=" x 60, "\n"; - print "Installation complete! ($installed files installed)\n"; - print "=" x 60, "\n\n"; # Create MM object first (needed by postamble) my $mm = PerlOnJava::MM::Installed->new($args); - # Create a stub Makefile to satisfy CPAN.pm's check - _create_stub_makefile($name, $version, $args, $mm); - # Create MYMETA.yml for CPAN.pm dependency resolution _create_mymeta($name, $version, $args); + # Create Makefile with install commands (actual install deferred to 'make') + _create_install_makefile($name, $version, $args, \%pm, \%scripts, $mm); + + my $total = scalar(keys %pm) + scalar(keys %scripts); + print "=" x 60, "\n"; + print "Configured! $total files will be installed when 'make' runs.\n"; + print "=" x 60, "\n\n"; + return $mm; } -sub _install_share_dirs { +sub _build_share_file_mapping { my ($name, $args) = @_; - my $installed = 0; + my %files; # Check if File::ShareDir::Install was used - return 0 unless @File::ShareDir::Install::DIRS; + return %files unless eval { @File::ShareDir::Install::DIRS }; # Convert module name to dist name (My::Module -> My-Module) (my $dist_name = $name) =~ s/::/-/g; - print "\nInstalling share directories:\n"; - for my $def (@File::ShareDir::Install::DIRS) { my $type = $def->{type} || 'dist'; next if $type =~ /^delete/; # Skip delete directives @@ -332,7 +329,7 @@ sub _install_share_dirs { @src_dirs = ($def->{dir}); } - # Handle directory specification (scan and copy all files) + # Scan files (don't copy yet - deferred to 'make') for my $src_dir (@src_dirs) { next unless -d $src_dir; @@ -354,23 +351,14 @@ sub _install_share_dirs { my $src = $File::Find::name; (my $rel = $src) =~ s{^\Q$src_dir\E/?}{}; - my $dest = File::Spec->catfile($dest_base, $rel); - my $dest_dir = dirname($dest); - make_path($dest_dir) unless -d $dest_dir; - - if (copy($src, $dest)) { - $installed++; - } else { - warn " Failed to copy $src: $!\n"; - } + $files{$src} = File::Spec->catfile($dest_base, $rel); }, no_chdir => 1, }, $src_dir); } } - print " Installed $installed share files\n" if $installed; - return $installed; + return %files; } sub _extract_version { @@ -393,16 +381,17 @@ sub _extract_version { return '0'; } -sub _create_stub_makefile { - my ($name, $version, $args, $mm) = @_; +sub _create_install_makefile { + my ($name, $version, $args, $pm, $scripts, $mm) = @_; - # Create a minimal Makefile that CPAN.pm can parse - # This allows CPAN.pm to proceed through its make/test/install workflow + # Create a Makefile that actually installs files when 'make' runs. + # This defers installation to after CPAN.pm has resolved and installed + # dependencies, enabling proper dependency resolution for any CPAN module. # Respect custom MAKEFILE name if provided my $makefile = $args->{MAKEFILE} || 'Makefile'; open my $fh, '>', $makefile or do { - warn "Note: Could not create stub Makefile: $!\n"; + warn "Note: Could not create Makefile: $!\n"; return; }; @@ -427,10 +416,40 @@ sub _create_stub_makefile { my $inst_lib = $args->{INST_LIB} || 'blib/lib'; my $installsitelib = $args->{INSTALLSITELIB} || $INSTALL_BASE; - # Minimal Makefile that works with CPAN.pm + # Build install commands for module/data/share files + my @install_cmds; + my %dirs_seen; + for my $src (sort keys %$pm) { + my $dest = $pm->{$src}; + my $dir = dirname($dest); + unless ($dirs_seen{$dir}++) { + push @install_cmds, _shell_mkdir($dir); + } + push @install_cmds, _shell_cp($src, $dest); + } + + # Build install commands for scripts + my @script_cmds; + if ($scripts && %$scripts) { + my %sdirs; + for my $src (sort keys %$scripts) { + my $dest = $scripts->{$src}; + my $dir = dirname($dest); + unless ($sdirs{$dir}++) { + push @script_cmds, _shell_mkdir($dir); + } + push @script_cmds, _shell_cp($src, $dest); + } + } + + my $install_cmds_str = join("\n", @install_cmds) || "\t\@true"; + my $script_cmds_str = join("\n", @script_cmds) || "\t\@true"; + my $file_count = scalar(keys %$pm) + scalar(keys %$scripts); + print $fh <<"MAKEFILE"; -# Stub Makefile for PerlOnJava -# This module was installed directly without 'make' +# Makefile generated by PerlOnJava MakeMaker +# Files are installed during 'make' (not during Makefile.PL) +# This enables CPAN.pm to resolve dependencies before installation NAME = $name DISTNAME = $distname @@ -442,9 +461,16 @@ INSTALLSITELIB = $installsitelib NOECHO = \@ RM_RF = rm -rf -# PerlOnJava installs modules directly - 'all' runs config for share directories -all: config -\t\@echo "PerlOnJava: Module already installed" +all: pm_to_blib config +\t\@echo "PerlOnJava: $name v$version installed ($file_count files)" + +# Copy module and data files to installation directory +pm_to_blib: +$install_cmds_str + +# Install executable scripts +install_scripts: +$script_cmds_str # Use double-colon for config to allow postamble to add rules config:: @@ -452,10 +478,8 @@ config:: test: \t$test_cmd -install: all -\t\@echo "PerlOnJava: Installing to \$(INSTALLSITELIB)" -\t\@mkdir -p \$(INSTALLSITELIB)/auto -\t-\@cp -r \$(INST_LIB)/auto/share \$(INSTALLSITELIB)/auto/ 2>/dev/null || true +install: all install_scripts +\t\@echo "PerlOnJava: $name installed to \$(INSTALLSITELIB)" clean: \t\@echo "PerlOnJava: Nothing to clean" @@ -464,7 +488,7 @@ realclean: clean distclean: clean -.PHONY: all config test install clean realclean distclean +.PHONY: all pm_to_blib config test install clean realclean distclean install_scripts MAKEFILE # Call MY::postamble if it exists (File::ShareDir::Install uses this) @@ -480,6 +504,21 @@ MAKEFILE close $fh; } +# Helper: generate a shell mkdir -p command for Makefile +sub _shell_mkdir { + my ($dir) = @_; + $dir =~ s/'/'\\''/g; # escape single quotes + return "\t\@mkdir -p '$dir'"; +} + +# Helper: generate a shell cp command for Makefile +sub _shell_cp { + my ($src, $dest) = @_; + $src =~ s/'/'\\''/g; + $dest =~ s/'/'\\''/g; + return "\t\@cp '$src' '$dest'"; +} + sub _create_mymeta { my ($name, $version, $args) = @_; diff --git a/src/main/perl/lib/IO/Socket/INET.pm b/src/main/perl/lib/IO/Socket/INET.pm index 45fd139d9..527d6a95b 100644 --- a/src/main/perl/lib/IO/Socket/INET.pm +++ b/src/main/perl/lib/IO/Socket/INET.pm @@ -16,7 +16,7 @@ use Errno; our @ISA = qw(IO::Socket); our $VERSION = "1.56"; -my $EINVAL = exists(&Errno::EINVAL) ? Errno::EINVAL() : 1; +my $EINVAL = eval { Errno::EINVAL() } || 1; IO::Socket::INET->register_domain( AF_INET ); diff --git a/src/main/perl/lib/JSON.pm b/src/main/perl/lib/JSON.pm index 4df7fa8d6..2baa3cf13 100644 --- a/src/main/perl/lib/JSON.pm +++ b/src/main/perl/lib/JSON.pm @@ -1,5 +1,7 @@ package JSON; +our $VERSION = '4.11'; + use Exporter "import"; use warnings; use strict; diff --git a/src/main/perl/lib/MIME/Base64.pm b/src/main/perl/lib/MIME/Base64.pm index 031566a90..c4956d0e4 100644 --- a/src/main/perl/lib/MIME/Base64.pm +++ b/src/main/perl/lib/MIME/Base64.pm @@ -11,6 +11,8 @@ package MIME::Base64; # The implementation is in: src/main/java/org/perlonjava/perlmodule/MimeBase64.java # +our $VERSION = '3.16'; + use XSLoader; XSLoader::load( 'MIME::Base64' ); diff --git a/src/main/perl/lib/PerlIO/encoding.pm b/src/main/perl/lib/PerlIO/encoding.pm new file mode 100644 index 000000000..4998fee3d --- /dev/null +++ b/src/main/perl/lib/PerlIO/encoding.pm @@ -0,0 +1,29 @@ +package PerlIO::encoding; + +use strict; +use warnings; + +our $VERSION = '0.30'; + +# Fallback flags for encoding error handling. +# Modules check this variable to decide how to handle encoding errors. +our $fallback = 0; # Encode::FB_QUIET equivalent + +# In standard Perl, PerlIO::encoding is an XS module that provides +# the :encoding() PerlIO layer. In PerlOnJava, IO layers are handled +# by the Java LayeredIOHandle implementation. This stub provides the +# package variables that other modules (IO::HTML, etc.) expect. + +1; +__END__ + +=head1 NAME + +PerlIO::encoding - encoding layer stub for PerlOnJava + +=head1 DESCRIPTION + +Stub module providing the C<$PerlIO::encoding::fallback> variable. +The actual encoding layer functionality is implemented in the Java backend. + +=cut diff --git a/src/main/perl/lib/Template/Stash/XS.pm b/src/main/perl/lib/Template/Stash/XS.pm new file mode 100644 index 000000000..e3a5ff5c6 --- /dev/null +++ b/src/main/perl/lib/Template/Stash/XS.pm @@ -0,0 +1,12 @@ +package Template::Stash::XS; + +# PerlOnJava: XS Stash is not available. Fall back to the pure Perl +# Template::Stash which provides identical functionality. + +use strict; +use warnings; +use Template::Stash; + +our @ISA = ('Template::Stash'); + +1;