From patchwork Mon Feb 3 13:04:07 2025 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Alfie Richards X-Patchwork-Id: 105920 Return-Path: X-Original-To: patchwork@sourceware.org Delivered-To: patchwork@sourceware.org Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 8DAD93858C35 for ; Mon, 3 Feb 2025 13:16:23 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 8DAD93858C35 Authentication-Results: sourceware.org; dkim=pass (1024-bit key, unprotected) header.d=arm.com header.i=@arm.com header.a=rsa-sha256 header.s=selector1 header.b=lymITA56; dkim=pass (1024-bit key) header.d=arm.com header.i=@arm.com header.a=rsa-sha256 header.s=selector1 header.b=lymITA56 X-Original-To: gcc-patches@gcc.gnu.org Delivered-To: gcc-patches@gcc.gnu.org Received: from EUR05-AM6-obe.outbound.protection.outlook.com (mail-am6eur05on2062d.outbound.protection.outlook.com [IPv6:2a01:111:f403:2612::62d]) by sourceware.org (Postfix) with ESMTPS id 08012385841F for ; Mon, 3 Feb 2025 13:04:56 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 08012385841F Authentication-Results: sourceware.org; dmarc=pass (p=none dis=none) header.from=arm.com Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=arm.com ARC-Filter: OpenARC Filter v1.0.0 sourceware.org 08012385841F Authentication-Results: server2.sourceware.org; arc=pass smtp.remote-ip=2a01:111:f403:2612::62d ARC-Seal: i=3; a=rsa-sha256; d=sourceware.org; s=key; t=1738587896; cv=pass; b=OcKSZSIcW/D1xMKnxlThc1eSMrpdBgtSLUEUVvLSD0YYNvO23LLBuU8IP3l05jvw1Zi8XKZ8YjkbndIdtJpUs3YsCS4lRojIxX40BtWkqdURuJwGHNzd76CsuskU6TKWq0KlcM8BKVs8YqjIJCX7XGdkRkC5YcbjZKWNbl5+x28= ARC-Message-Signature: i=3; a=rsa-sha256; d=sourceware.org; s=key; t=1738587896; c=relaxed/simple; bh=p1/MmTEVE1Hk1r8EJnmUQweZrHGBbm3hU8S31nKz3A4=; h=DKIM-Signature:DKIM-Signature:From:To:Subject:Date:Message-ID: MIME-Version; b=Nf0QHvTR/Us8p8QOEKFv6TEkjsINDyPhA+4uw9KRB3CJDkhh2yW9yaKy0Spqk5mGqc7mJLwqHf7hqI3Kp1/MkszyQ+cVeC2awsDeQSxGCYffSGJ4dX8WgUOpAogtktHW/P9cR3zd64Kuh8l82xzk9yqEA31jt4Y2A47EUmNUKd4= ARC-Authentication-Results: i=3; server2.sourceware.org DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 08012385841F ARC-Seal: i=2; a=rsa-sha256; s=arcselector10001; d=microsoft.com; cv=pass; b=ELICMxS7fYdrPr6au0zx4uSX1fpgbvpHiB21Wf5PDOLGurq6u9ad14d0WxXC2adYy4+2JwE5SMZEAKqHr+eXNKCeOA4b9c9lZpWSGiPg1qeXbw8SDVUrmuSrhnzmu0+VIru89oQ+fxVB5yXB+Zr3HOD7oA6yHInUHgjbxH2prlilBOQJMK64qPvmEZ4tG4/YHg8+zSKnm+Rv997mjbPeX9awPbL5j0G1LVkO9x/h7t8aJfCjpwy/9mzGSVkopjVrKwe7KUXXm6lxr/tboSsyTkf9mx5Q7JKy+M9wey/H1qdSsv9HBpI6E+fq8ROKqJs+dtSgy3zeUql80XkJYxCWjA== ARC-Message-Signature: i=2; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=arcselector10001; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-AntiSpam-MessageData-ChunkCount:X-MS-Exchange-AntiSpam-MessageData-0:X-MS-Exchange-AntiSpam-MessageData-1; bh=VaBRfZ40+4F0XgN1CWon2z6ejFtR2+47VYMhltB/XSY=; b=uDf0qHKR4uSEsznfiL8fVnsxKBznhEZdT2VU6zURcYFMx0z3urz8O9VK4B8uSenAZlsmIDleTZHTqFxazOlczAyowGjfZeVpmfLZnh5NDKUK/BU94YNW/nCrcYSpghOxlvjeftxdn970Rp36tl/ZDLif0cnyNJCk0kXSJAMzqMQE2MTEdiPuy4skOWTWEdW0xJa7yb/ziv1foVvaPkNgSUF62nsjBfCjBluOLoV0QBzqQ2x3+36zfrpWoVboANOBj414hC2kUBQ0Gfn9Aie5KDkjx2hOdnJZNR96+ot0M/z+dNrhimOtyCocEGUtbwAY87Np9c4X4USi0A3tT4WYFw== ARC-Authentication-Results: i=2; mx.microsoft.com 1; spf=pass (sender ip is 63.35.35.123) smtp.rcpttodomain=gcc.gnu.org smtp.mailfrom=arm.com; dmarc=pass (p=none sp=none pct=100) action=none header.from=arm.com; dkim=pass (signature was verified) header.d=arm.com; arc=pass (0 oda=0 ltdi=1) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=arm.com; s=selector1; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=VaBRfZ40+4F0XgN1CWon2z6ejFtR2+47VYMhltB/XSY=; b=lymITA5661DD9e7to8qj8o7tIzE3CX8HT82g01q+EzYylzQUT/90xBjGiTp/ojguF4rJ5kvDfgAz9GHYiVb6CPJCuqG3+HpsoAfDxeMsnMZdG8jBIgFvzR4Vwsc9Ra5Hc3M4uQp0ERRL88BPBgaNs8bYjlCAs6bV8JVaFgVPwZM= Received: from DUZPR01CA0018.eurprd01.prod.exchangelabs.com (2603:10a6:10:46b::6) by AM8PR08MB5683.eurprd08.prod.outlook.com (2603:10a6:20b:1d1::19) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.8398.18; Mon, 3 Feb 2025 13:04:52 +0000 Received: from DB1PEPF000509E2.eurprd03.prod.outlook.com (2603:10a6:10:46b:cafe::f4) by DUZPR01CA0018.outlook.office365.com (2603:10a6:10:46b::6) with Microsoft SMTP Server (version=TLS1_3, cipher=TLS_AES_256_GCM_SHA384) id 15.20.8398.23 via Frontend Transport; Mon, 3 Feb 2025 13:04:58 +0000 X-MS-Exchange-Authentication-Results: spf=pass (sender IP is 63.35.35.123) smtp.mailfrom=arm.com; dkim=pass (signature was verified) header.d=arm.com;dmarc=pass action=none header.from=arm.com; Received-SPF: Pass (protection.outlook.com: domain of arm.com designates 63.35.35.123 as permitted sender) receiver=protection.outlook.com; client-ip=63.35.35.123; helo=64aa7808-outbound-1.mta.getcheckrecipient.com; pr=C Received: from 64aa7808-outbound-1.mta.getcheckrecipient.com (63.35.35.123) by DB1PEPF000509E2.mail.protection.outlook.com (10.167.242.52) with Microsoft SMTP Server (version=TLS1_3, cipher=TLS_AES_256_GCM_SHA384) id 15.20.8398.14 via Frontend Transport; Mon, 3 Feb 2025 13:04:52 +0000 Received: ("Tessian outbound 72f36a054dd6:v560"); Mon, 03 Feb 2025 13:04:52 +0000 X-CheckRecipientChecked: true X-CR-MTA-CID: a01c517a460ed52f X-TessianGatewayMetadata: 0gNXvGUNUFn/NDnFpNLRDRW6CK170IpO4sZud1JdXcRCQHM03hw/iP6wU5QdvFiMWk/udkNtb93PkWcZI629pOr85WG6fUbFFIF6cRfCElKtfD/0ERUl7L65kTi2SyVcLZMxAAJAn6YDAkj8i/RL1KWtWmLAkfrcg7MZkg62ThQ= X-CR-MTA-TID: 64aa7808 Received: from L4e2b82b62059.1 by 64aa7808-outbound-1.mta.getcheckrecipient.com id 2BEE5454-E455-498A-A9C4-CADED8488E75.1; Mon, 03 Feb 2025 13:04:45 +0000 Received: from DUZPR83CU001.outbound.protection.outlook.com by 64aa7808-outbound-1.mta.getcheckrecipient.com with ESMTPS id L4e2b82b62059.1 (version=TLSv1.3 cipher=TLS_AES_256_GCM_SHA384); Mon, 03 Feb 2025 13:04:45 +0000 ARC-Seal: i=1; a=rsa-sha256; s=arcselector10001; d=microsoft.com; cv=none; b=ymDCQ1iKfjdidh11/5wAnMb/5ft/2tNrqZB/63NwBkWaIIEMPa2K+m0l4ypKFk0c5cXEohpMDAWhSG1NjiPIA3SPjyRLv807tIojoLWEbRCCLuzX7aQE9X3P9BiTgbJAeMEmo7ShbzUlc45vn9fQxgm27LbRZy+yBH5D7w0eKSYwg9NO4F9Y8Zbw2HhVCD92wpvYhorwUeFNg2S4jqtKmkTgvXS7cDrUKiR2Qy6pp2Ehl9+zR+MuwSCaWNCdwtjvxzYWw3cTZwT+TCxPqrTj852hX15/XYV++n7kg2nWQyuQRh9kBTSRYn2wVGCq9E65Cg/+NvARQtSmaQSfJD7s5g== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=arcselector10001; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-AntiSpam-MessageData-ChunkCount:X-MS-Exchange-AntiSpam-MessageData-0:X-MS-Exchange-AntiSpam-MessageData-1; bh=VaBRfZ40+4F0XgN1CWon2z6ejFtR2+47VYMhltB/XSY=; b=MXFTu9eakLkFYSkEqF0to2NK8ZT8PZYzzhNtWK4bNU4/TA1x4rM9YTlr9TxRWXXOBgzeu/dI3YXMO2E4/ekFW6evNCCmQGyS8WR21vd3OVM5uu3rMtPClrHuVopf0GrT9o2klP9kTkmMbrGYDX99xciAB2ZcZ5wzsE06IQrlHifGQF1l1O7Ztkd0eKDiwjCrwvdbSxFyjtjEYVKw9SexIeXwMJKLFEU0ILDfmsewBZBdKKdNnRsg739qFIr7RonFNdXxFKQGWsaxKSEFQ24RqFLawo444C8fgOEzx77oMEKYQDzMQzXoLPZjAg7i2NQKdSRzbALGnIzrgPlhCcwcdA== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=fail (sender ip is 172.205.89.229) smtp.rcpttodomain=gcc.gnu.org smtp.mailfrom=arm.com; dmarc=fail (p=none sp=none pct=100) action=none header.from=arm.com; dkim=none (message not signed); arc=none (0) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=arm.com; s=selector1; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=VaBRfZ40+4F0XgN1CWon2z6ejFtR2+47VYMhltB/XSY=; b=lymITA5661DD9e7to8qj8o7tIzE3CX8HT82g01q+EzYylzQUT/90xBjGiTp/ojguF4rJ5kvDfgAz9GHYiVb6CPJCuqG3+HpsoAfDxeMsnMZdG8jBIgFvzR4Vwsc9Ra5Hc3M4uQp0ERRL88BPBgaNs8bYjlCAs6bV8JVaFgVPwZM= Received: from DUZPR01CA0078.eurprd01.prod.exchangelabs.com (2603:10a6:10:46a::20) by AS2PR08MB9414.eurprd08.prod.outlook.com (2603:10a6:20b:596::18) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.8398.23; Mon, 3 Feb 2025 13:04:40 +0000 Received: from DU2PEPF00028CFE.eurprd03.prod.outlook.com (2603:10a6:10:46a:cafe::e6) by DUZPR01CA0078.outlook.office365.com (2603:10a6:10:46a::20) with Microsoft SMTP Server (version=TLS1_3, cipher=TLS_AES_256_GCM_SHA384) id 15.20.8398.25 via Frontend Transport; Mon, 3 Feb 2025 13:04:50 +0000 X-MS-Exchange-Authentication-Results: spf=fail (sender IP is 172.205.89.229) smtp.mailfrom=arm.com; dkim=none (message not signed) header.d=none;dmarc=fail action=none header.from=arm.com; Received-SPF: Fail (protection.outlook.com: domain of arm.com does not designate 172.205.89.229 as permitted sender) receiver=protection.outlook.com; client-ip=172.205.89.229; helo=nebula.arm.com; Received: from nebula.arm.com (172.205.89.229) by DU2PEPF00028CFE.mail.protection.outlook.com (10.167.242.182) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256) id 15.20.8398.14 via Frontend Transport; Mon, 3 Feb 2025 13:04:40 +0000 Received: from AZ-NEU-EX04.Arm.com (10.251.24.32) by AZ-NEU-EX05.Arm.com (10.240.25.133) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256) id 15.1.2507.39; Mon, 3 Feb 2025 13:04:26 +0000 Received: from AZ-NEU-EX04.Arm.com (10.251.24.32) by AZ-NEU-EX04.Arm.com (10.251.24.32) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256) id 15.1.2507.39; Mon, 3 Feb 2025 13:04:26 +0000 Received: from ip-10-248-139-135.eu-west-1.compute.internal (10.252.78.54) by AZ-NEU-EX04.Arm.com (10.251.24.32) with Microsoft SMTP Server id 15.1.2507.39 via Frontend Transport; Mon, 3 Feb 2025 13:04:25 +0000 From: Alfie Richards To: CC: , , , , , , , Alfie Richards Subject: [PATCH v1 03/16] Add string_slice class. Date: Mon, 3 Feb 2025 13:04:07 +0000 Message-ID: <20250203130421.2192732-4-alfie.richards@arm.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20250203130421.2192732-1-alfie.richards@arm.com> References: <20250203130421.2192732-1-alfie.richards@arm.com> MIME-Version: 1.0 X-EOPAttributedMessage: 1 X-MS-TrafficTypeDiagnostic: DU2PEPF00028CFE:EE_|AS2PR08MB9414:EE_|DB1PEPF000509E2:EE_|AM8PR08MB5683:EE_ X-MS-Office365-Filtering-Correlation-Id: bba7430a-3b8b-4c11-c9f2-08dd4453590d x-checkrecipientrouted: true NoDisclaimer: true X-MS-Exchange-SenderADCheck: 1 X-MS-Exchange-AntiSpam-Relay: 0 X-Microsoft-Antispam-Untrusted: BCL:0; ARA:13230040|376014|36860700013|82310400026|1800799024; X-Microsoft-Antispam-Message-Info-Original: jx83kCi/he9KQ6Afehr/u6inJ4zlHY2C72X6iHs6biRSIgNUVxdrNpQIPpmtFufOQiyystX6m8sL5RRSXKZqScGjX8yDbmTu+cdt1lzqzwS24/uo4xExNqz2Ce8WDF2w/uACH1pe8cK4me3TysDaJRayco7PYjZKPNtpORSy72aVJWNN1GWH5FBiJbVaQZqcOoNbVzXfoJoOTgUzYQc7PHbr3dJdrctU8ZJETCI7bFoXAdj8M7B6xQUlg1TTwLYuFg+xS9dx87Ua8c1D138hWG1JH7Sg3cOV48W/mNY4CY/P929pn9Vu7sVyIs49b1X5aZWS6MaxAdM3uHELJjDoozQv+ufK0OaPukxVvD/oVYP06pBhjuC30fZ3IPSbhOG3+mLFt/9uX6LuoRcllTsWZyzrQUsqDmm+e9t5/Z5VU4rUPblWsc/gVcdI9sZVa+5kRpOZ+F+EWivFES2YubR6ucuygKW/3Rtx0p30x5dzHDojH6A/EYOThzcbbNrNks4H2h2k7jjxpTg4ag7VLmWrVSs2WNfNVtFNSbL65LI/sTaM/Oz6MecZ/XDTITictIlipEvWjNesvOVXMvddDELkTrokiUCu+wiEPTMMc0peBODt6168tGbdj7vuc35QvoGGI4/uZouypH82RVGLXJmqLJ0hSGluzaZatQnAaRDulBibvaVFyQFvuGVqIXxxXso6/vNjw/755qlI6eZso1ONwGyuESS43Gb5sSVcTRL3/W/3pwHSHA8wzBuuS8XEnMwPMF+5J3N7EJbKvklopWgODBVzXEVgLLyhzSotntJ0yC2RLGF+HgOW5OXAWgdbjKysiRU14cBymTT0vddXw7RLpAweBpBLhvJLqjOKE+p2Y8xxIdF4Y0weAKE1+WpHuCsImd+c3LdWG6988avG9OKpZZqz6MT3uZM3f1dpGSn7sOcAhw4du3su1AczcapCN5A+MHwAg8g4YObovPHxPjpqjFVCiT47VtrX/Tqft4dNAFzIUDs1C3PfA+bfgvrleuFyt5dBd9JMcuGpeOc6WC8FtV/q5gmRRaflbgxpKO06/ipbjqPCVqeSiig58pVjq25nOdFs2BNLIYluNF4ygK4BoQMo96OHTlRqt90bxXbmK6Gf78+LSFXtqSNPi0IA8W5ibC40dc2TQB10Qpq06td5YdTUppdaFXn+95HKszZTWrLgNzqemie81QrAAGk2iydOjjaTYb+jbBiEbku5MVZJs/1p2YJzaNDrWr06H05NTm7l93L62okOjDr18uwMIt2Cblorl8GerI7pd4BUHM5KUjtymoXpf9Bc3edUCO6Uz7mYQtAXM52WFAjFWXmWHrZ62RfFOFsTvA+FprTZN0chjTBbpeYqLbARlArOrhhtr9RNaW/88UpEmnd/h6HVrfiQdp/R2NzYpBaXp6NJUAQ/r2hhVPb48m/p3KYh1j5L7s2xsgAH4oYd9uid8BpfqyO+aXza6Wdch7GsI4onPBW7wojQo9Bi4snBRk3HQ0LWgpI= X-Forefront-Antispam-Report-Untrusted: CIP:172.205.89.229; CTRY:IE; LANG:en; SCL:1; SRV:; IPV:NLI; SFV:NSPM; H:nebula.arm.com; PTR:InfoDomainNonexistent; CAT:NONE; SFS:(13230040)(376014)(36860700013)(82310400026)(1800799024); DIR:OUT; SFP:1101; X-MS-Exchange-Transport-CrossTenantHeadersStamped: AS2PR08MB9414 X-MS-Exchange-SkipListedInternetSender: ip=[2603:10a6:10:46a::20]; domain=DUZPR01CA0078.eurprd01.prod.exchangelabs.com X-MS-Exchange-Transport-CrossTenantHeadersStripped: DB1PEPF000509E2.eurprd03.prod.outlook.com X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-Correlation-Id-Prvs: 62f7f627-8390-4994-a70b-08dd4453521b X-Microsoft-Antispam: BCL:0; ARA:13230040|82310400026|376014|1800799024|35042699022|36860700013|14060799003; X-Microsoft-Antispam-Message-Info: =?utf-8?q?vFPW50aoqF39n170m3ttiwc1Ocx1Y9Z?= =?utf-8?q?bO4GmMivSTa0s0xoJI5nxEIqpF7/qFekqEV0YGvr29wGiV4w6ewSv2DmhQ7DHzOV4?= =?utf-8?q?u3WzlfLCu6IuN8+qcT9f8og2myi3Niqrvj2+svpzuwyu0PugxegOfS6BlQadPZeaN?= =?utf-8?q?ryTe2yKCaWQCrG3yEEQGpb6zRKXeQPaJKvAqjVoI9TWSIa1UnN1GnUXPmuoaa9ss0?= =?utf-8?q?1aUoDA/wTpGn494pWnesAXFeZtdfV6PDH/q7nsSc8Hj5cLdrOg6MELMZwzbHTSd1W?= =?utf-8?q?qgRc64cyFoh6uTyB7ZW8bXXU0wK53cBQJQNn+wR6D09rCMRrGjckBs8mQe0sPZ5bp?= =?utf-8?q?dhGR1bZ7pZCD1/iYgiANZosB+pHdHLDwWpYkqvLrTtSc0EFpXJpedUg92bW2OrXvL?= =?utf-8?q?X2ovwQtQ7a0w5vsoxIvAFintZbRQ1ffAnp7uWiPXtauV2VxBAccX2q71WDwXHXQnB?= =?utf-8?q?LFlsjeoyGSx8uFrXiMGt6lFR1U1fQmHJYao4YfkI+53e9GsYZPwdx3KS3SFA1NPmt?= =?utf-8?q?Jm/TQhtmhMR1PDC9rIxwdnReTo38EYop0U7IxR662PrpqO6Wfqw1lb41KWys+zKsw?= =?utf-8?q?Knuw56yF2u7WTPrWNmWxKxMhVbeyFEZFH7Kbz6mkauj2ofRUcIE4TMk/Q3ETorJ24?= =?utf-8?q?5m3bf8x18dhWeL3/rSdrX7Y3BCUs+POSdOLRrR6ONf8KMUEYh85Zd5wbkRtrcd8GT?= =?utf-8?q?9vN6b4fuPydPS6HuI+L7o4dxvSjU4a4m2uH5ghk7CH/Gmvg1MoHqWHTo3pgl+Yzo+?= =?utf-8?q?Ih278nCQ7nIJQL82lad6rogrby8EhjxpGi2o/hK1lGb7Egnh61Nuze5QH0k5NH/Rw?= =?utf-8?q?h0KfW+fvq4Gugd6kyLb7TMmHPtuvQOnwXcKBmeh/0WI/HyGJMHop5trNtZHEYvAmZ?= =?utf-8?q?j5jmoW3rt81eSRqlc15L1wdmqVLyqKxGrw2kPgUdCDMViiRuri3zcR4KWOGlLNfRM?= =?utf-8?q?axFPGkrhHiwxq1mG59ZguuU2Xb37E9tyuNsrbMY1gNt6zzy5RAINZ3ri/2QrOROnc?= =?utf-8?q?b3q4S4uRWlNtQt+IL792+SMKcP3ELYMrJF1JI5nHPrCMZTR0agBOPgU3TBvqeMqLe?= =?utf-8?q?0ySkeHCv/wEqwNpKzIbTlEvWS6TjiLaB2frftHTERJcx53SaRvfPCuv47QhrZ/fdV?= =?utf-8?q?H8eBcrzGXORSFD6rIOQ+N4PgO1BEbBm1/G4Bh0OTR8+wU2vxKK4c+zDzqRcObUgK5?= =?utf-8?q?gjgEZnze8CNsrCtn/ZpJaxMefdGElgs+/orIy4gngp7+9xpHWyHUSsKqn65S/c64v?= =?utf-8?q?LJF0JS9cltJEcRn+ZCsw/ED70EiWyb1/DCc+HwD8rz7M+nE898M87GibIxIEacia9?= =?utf-8?q?JeZe1l5RBZfQGUL2L8LD6g13J88yL6+av9jNMCI7EltDo7MT01a2ynUHu4SEoAPEI?= =?utf-8?q?F1gyac/8sfepJFr2N/kbi+1UdmAtAy8YTOLHBWiBU5skdk03/8h464=3D?= X-Forefront-Antispam-Report: CIP:63.35.35.123; CTRY:IE; LANG:en; SCL:1; SRV:; IPV:CAL; SFV:NSPM; H:64aa7808-outbound-1.mta.getcheckrecipient.com; PTR:64aa7808-outbound-1.mta.getcheckrecipient.com; CAT:NONE; SFS:(13230040)(82310400026)(376014)(1800799024)(35042699022)(36860700013)(14060799003); DIR:OUT; SFP:1101; X-OriginatorOrg: arm.com X-MS-Exchange-CrossTenant-OriginalArrivalTime: 03 Feb 2025 13:04:52.3372 (UTC) X-MS-Exchange-CrossTenant-Network-Message-Id: bba7430a-3b8b-4c11-c9f2-08dd4453590d X-MS-Exchange-CrossTenant-Id: f34e5979-57d9-4aaa-ad4d-b122a662184d X-MS-Exchange-CrossTenant-OriginalAttributedTenantConnectingIp: TenantId=f34e5979-57d9-4aaa-ad4d-b122a662184d; Ip=[63.35.35.123]; Helo=[64aa7808-outbound-1.mta.getcheckrecipient.com] X-MS-Exchange-CrossTenant-AuthSource: DB1PEPF000509E2.eurprd03.prod.outlook.com X-MS-Exchange-CrossTenant-AuthAs: Anonymous X-MS-Exchange-CrossTenant-FromEntityHeader: HybridOnPrem X-MS-Exchange-Transport-CrossTenantHeadersStamped: AM8PR08MB5683 X-Spam-Status: No, score=-11.4 required=5.0 tests=BAYES_00, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, FORGED_SPF_HELO, GIT_PATCH_0, SPF_HELO_PASS, SPF_NONE, TXREP, UNPARSEABLE_RELAY autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org X-BeenThere: gcc-patches@gcc.gnu.org X-Mailman-Version: 2.1.30 Precedence: list List-Id: Gcc-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: gcc-patches-bounces~patchwork=sourceware.org@gcc.gnu.org The string_slice inherits from array_slice and is used to refer to a substring of an array that is memory managed elsewhere without modifying the underlying array. For example, this is useful in cases such as when needing to refer to a substring of an attribute in the syntax tree. This commit also adds some minimal helper functions for string_slice, such as strtok, strcmp, and a function to strip whitespace from the beginning and end of a slice. gcc/ChangeLog: * vec.cc (string_slice::strtok): New method. (strcmp): Add implementation for string_slice. (string_slice::strip): New method. (test_string_slice_initializers): New test. (test_string_slice_strtok): Ditto. (test_string_slice_strcmp): Ditto. (test_string_slice_equality): Ditto. (test_string_slice_invalid): Ditto. (test_string_slice_strip): Ditto. (vec_cc_tests): Add new tests. * vec.h (class string_slice): New class. (strcmp): Add implementation for string_slice. --- gcc/vec.cc | 157 +++++++++++++++++++++++++++++++++++++++++++++++++++++ gcc/vec.h | 38 +++++++++++++ 2 files changed, 195 insertions(+) diff --git a/gcc/vec.cc b/gcc/vec.cc index 55f5f3dd447..569dbf2a53c 100644 --- a/gcc/vec.cc +++ b/gcc/vec.cc @@ -176,6 +176,67 @@ dump_vec_loc_statistics (void) vec_mem_desc.dump (VEC_ORIGIN); } +string_slice +string_slice::strtok (string_slice *str, string_slice delims) +{ + const char *ptr = str->begin (); + + /* If the input string is empty or invalid, return an invalid slice + as there are no more tokens to return. */ + if (str->empty () || !str->is_valid ()) + { + *str = string_slice::invalid (); + return string_slice::invalid (); + } + + for (; ptr < str->end (); ptr++) + for (const char *c = delims.begin (); c < delims.end(); c++) + if (*ptr == *c) + { + const char *start = str->begin (); + /* Update the input string to be the remaining string. */ + *str = string_slice ((ptr + 1), str->end () - ptr - 1); + return string_slice (start, (size_t) (ptr - start)); + } + + /* If no deliminators between the start and end, return the whole string. */ + string_slice res = *str; + *str = string_slice::invalid (); + return res; +} + +int +strcmp (string_slice str1, string_slice str2) +{ + for (unsigned int i = 0; i < str1.size () && i < str2.size (); i++) + { + if (str1[i] < str2[i]) + return -1; + if (str1[i] > str2[i]) + return 1; + } + + if (str1.size () < str2.size ()) + return -1; + if (str1.size () > str2.size ()) + return 1; + return 0; +} + +string_slice +string_slice::strip () +{ + const char *start = this->begin (); + const char *end = this->end (); + + while (start < end && ISSPACE (*start)) + start++; + while (end > start && ISSPACE (*(end-1))) + end--; + + return string_slice (start, end-start); +} + #if CHECKING_P /* Report qsort comparator CMP consistency check failure with P1, P2, P3 as witness elements. */ @@ -584,6 +645,96 @@ test_auto_alias () ASSERT_EQ (val, 0); } +static void +test_string_slice_initializers () +{ + string_slice str1 = string_slice (); + ASSERT_TRUE (str1.is_valid ()); + ASSERT_EQ (str1.size (), 0); + + string_slice str2 = string_slice ("Test string"); + ASSERT_TRUE (str2.is_valid ()); + ASSERT_EQ (str2.size (), 11); + + string_slice str3 = string_slice ("Test string", 4); + ASSERT_TRUE (str3.is_valid ()); + ASSERT_EQ (str3.size (), 4); +} + +static void +test_string_slice_strtok () +{ + const char *test_string + = "This is the test string, it \0 is for testing, 123 ,,"; + + string_slice test_string_slice = string_slice (test_string, 53); + string_slice test_delims = string_slice (",\0", 2); + + ASSERT_EQ (string_slice::strtok (&test_string_slice, test_delims), + string_slice ("This is the test string")); + ASSERT_EQ (string_slice::strtok (&test_string_slice, test_delims), + string_slice (" it ")); + ASSERT_EQ (string_slice::strtok (&test_string_slice, test_delims), + string_slice (" is for testing")); + ASSERT_EQ (string_slice::strtok (&test_string_slice, test_delims), + string_slice (" 123 ")); + ASSERT_EQ (string_slice::strtok (&test_string_slice, test_delims), + string_slice ("")); + ASSERT_EQ (string_slice::strtok (&test_string_slice, test_delims), + string_slice ("")); + ASSERT_TRUE (test_string_slice.empty ()); + ASSERT_FALSE (string_slice::strtok (&test_string_slice, test_delims) + .is_valid ()); + ASSERT_FALSE (test_string_slice.is_valid ()); +} + +static void +test_string_slice_strcmp () +{ + ASSERT_EQ (strcmp (string_slice (), string_slice ()), 0); + ASSERT_EQ (strcmp (string_slice ("test"), string_slice ()), 1); + ASSERT_EQ (strcmp (string_slice (), string_slice ("test")), -1); + ASSERT_EQ (strcmp (string_slice ("test"), string_slice ("test")), 0); + ASSERT_EQ (strcmp (string_slice ("a"), string_slice ("b")), -1); + ASSERT_EQ (strcmp (string_slice ("b"), string_slice ("a")), 1); + ASSERT_EQ (strcmp (string_slice ("ab", 1), string_slice ("a")), 0); + ASSERT_EQ (strcmp (string_slice ("ab", 2), string_slice ("a")), 1); +} + +static void +test_string_slice_equality () +{ + ASSERT_TRUE (string_slice () == string_slice ()); + ASSERT_FALSE (string_slice ("test") == string_slice ()); + ASSERT_FALSE (string_slice () == string_slice ("test")); + ASSERT_TRUE (string_slice ("test") == string_slice ("test")); + ASSERT_FALSE (string_slice ("a") == string_slice ("b")); + ASSERT_FALSE (string_slice ("b") == string_slice ("a")); + ASSERT_TRUE (string_slice ("ab", 1) == string_slice ("a")); + ASSERT_FALSE (string_slice ("ab", 2) == string_slice ("a")); +} + +static void +test_string_slice_invalid () +{ + ASSERT_FALSE (string_slice::invalid ().is_valid ()); + ASSERT_FALSE (string_slice (NULL, 1).is_valid ()); + ASSERT_TRUE (string_slice (NULL, 0).is_valid ()); + ASSERT_TRUE (string_slice ("Test", 0).is_valid ()); + ASSERT_TRUE (string_slice ().is_valid ()); +} + +static void +test_string_slice_strip () +{ + ASSERT_EQ (string_slice (" test ").strip (), string_slice ("test")); + ASSERT_EQ (string_slice ("\t test string\t \n ").strip (), + string_slice ("test string")); + ASSERT_EQ (string_slice ("test").strip (), string_slice ("test")); + ASSERT_EQ (string_slice ().strip (), string_slice ()); + ASSERT_EQ (string_slice ("\t \n \t ").strip (), string_slice ()); +} + /* Run all of the selftests within this file. */ void @@ -604,6 +755,12 @@ vec_cc_tests () test_reverse (); test_auto_delete_vec (); test_auto_alias (); + test_string_slice_initializers (); + test_string_slice_strtok (); + test_string_slice_strcmp (); + test_string_slice_equality (); + test_string_slice_invalid (); + test_string_slice_strip (); } } // namespace selftest diff --git a/gcc/vec.h b/gcc/vec.h index 915df06f03e..409cdab5bc3 100644 --- a/gcc/vec.h +++ b/gcc/vec.h @@ -2484,4 +2484,42 @@ make_array_slice (T *base, unsigned int size) # pragma GCC poison m_vec m_vecpfx m_vecdata #endif +/* string_slice inherits from array_slice, specifically to refer to a substring + of a character array. + It includes some string like helpers. */ +class string_slice; + +int +strcmp (string_slice str1, string_slice str2); + +class string_slice : public array_slice +{ +public: + explicit string_slice () : array_slice () {} + explicit string_slice (const char *str) : array_slice (str, strlen (str)) {} + explicit string_slice (const char *str, size_t len) : array_slice (str, len) + {} + + bool operator== (string_slice other) const + { + if (!is_valid () || !other.is_valid ()) + return false; + if (size() != other.size()) + return false; + return memcmp (begin (), other.begin (), size()) == 0; + } + + static string_slice invalid () + { + return string_slice (nullptr, ~0U); + } + + /* strtok_slice is used to split a string by some deliminator into + strtok_slice's. Similarly to the posix strtok_r.but without modifying the + input string. */ + static string_slice strtok (string_slice *str, string_slice delims); + /* Removes white space from the front and back of the string_slice. */ + string_slice strip (); +}; + #endif // GCC_VEC_H