src/compiler/dmd/aApply.d

   1 /**
   2  * Part of the D programming language runtime library.
   3  */
   4
   5 /*
   6  *  Copyright (C) 2004-2006 by Digital Mars, www.digitalmars.com
   7  *  Written by Walter Bright
   8  *
   9  *  This software is provided 'as-is', without any express or implied
  10  *  warranty. In no event will the authors be held liable for any damages
  11  *  arising from the use of this software.
  12  *
  13  *  Permission is granted to anyone to use this software for any purpose,
  14  *  including commercial applications, and to alter it and redistribute it
  15  *  freely, in both source and binary form, subject to the following
  16  *  restrictions:
  17  *
  18  *  o  The origin of this software must not be misrepresented; you must not
  19  *     claim that you wrote the original software. If you use this software
  20  *     in a product, an acknowledgment in the product documentation would be
  21  *     appreciated but is not required.
  22  *  o  Altered source versions must be plainly marked as such, and must not
  23  *     be misrepresented as being the original software.
  24  *  o  This notice may not be removed or altered from any source
  25  *     distribution.
  26  */
  27
  28 /*
  29  *  Modified by Sean Kelly for use with the D Runtime Project
  30  */
  31
  32 module rt.aApply;
  33
  34 /* This code handles decoding UTF strings for foreach loops.
  35  * There are 6 combinations of conversions between char, wchar,
  36  * and dchar, and 2 of each of those.
  37  */
  38
  39 private import util.utf;
  40
  41 /**********************************************
  42  */
  43
  44 // dg is D, but _aApplycd() is C
  45 extern (D) typedef int delegate(void *) dg_t;
  46
  47 extern (C) int _aApplycd1(char[] aa, dg_t dg)
  48 {   int result;
  49     size_t i;
  50     size_t len = aa.length;
  51
  52     debug(apply) printf("_aApplycd1(), len = %d\n", len);
  53     for (i = 0; i < len; )
  54     {   dchar d;
  55
  56         d = aa[i];
  57         if (d & 0x80)
  58             d = decode(aa, i);
  59         else
  60             i++;
  61         result = dg(cast(void *)&d);
  62         if (result)
  63             break;
  64     }
  65     return result;
  66 }
  67
  68 extern (C) int _aApplywd1(wchar[] aa, dg_t dg)
  69 {   int result;
  70     size_t i;
  71     size_t len = aa.length;
  72
  73     debug(apply) printf("_aApplywd1(), len = %d\n", len);
  74     for (i = 0; i < len; )
  75     {   dchar d;
  76
  77         d = aa[i];
  78         if (d & ~0x7F)
  79             d = decode(aa, i);
  80         else
  81             i++;
  82         result = dg(cast(void *)&d);
  83         if (result)
  84             break;
  85     }
  86     return result;
  87 }
  88
  89 extern (C) int _aApplycw1(char[] aa, dg_t dg)
  90 {   int result;
  91     size_t i;
  92     size_t len = aa.length;
  93
  94     debug(apply) printf("_aApplycw1(), len = %d\n", len);
  95     for (i = 0; i < len; )
  96     {   dchar d;
  97         wchar w;
  98
  99         w = aa[i];
 100         if (w & 0x80)
 101         {   d = decode(aa, i);
 102             if (d <= 0xFFFF)
 103                 w = cast(wchar) d;
 104             else
 105             {
 106                 w = cast(wchar)((((d - 0x10000) >> 10) & 0x3FF) + 0xD800);
 107                 result = dg(cast(void *)&w);
 108                 if (result)
 109                     break;
 110                 w = cast(wchar)(((d - 0x10000) & 0x3FF) + 0xDC00);
 111             }
 112         }
 113         else
 114             i++;
 115         result = dg(cast(void *)&w);
 116         if (result)
 117             break;
 118     }
 119     return result;
 120 }
 121
 122 extern (C) int _aApplywc1(wchar[] aa, dg_t dg)
 123 {   int result;
 124     size_t i;
 125     size_t len = aa.length;
 126
 127     debug(apply) printf("_aApplywc1(), len = %d\n", len);
 128     for (i = 0; i < len; )
 129     {   dchar d;
 130         wchar w;
 131         char c;
 132
 133         w = aa[i];
 134         if (w & ~0x7F)
 135         {
 136             char[4] buf;
 137
 138             d = decode(aa, i);
 139             auto b = toUTF8(buf, d);
 140             foreach (char c2; b)
 141             {
 142                 result = dg(cast(void *)&c2);
 143                 if (result)
 144                     return result;
 145             }
 146             continue;
 147         }
 148         else
 149         {   c = cast(char)w;
 150             i++;
 151         }
 152         result = dg(cast(void *)&c);
 153         if (result)
 154             break;
 155     }
 156     return result;
 157 }
 158
 159 extern (C) int _aApplydc1(dchar[] aa, dg_t dg)
 160 {   int result;
 161
 162     debug(apply) printf("_aApplydc1(), len = %d\n", aa.length);
 163     foreach (dchar d; aa)
 164     {
 165         char c;
 166
 167         if (d & ~0x7F)
 168         {
 169             char[4] buf;
 170
 171             auto b = toUTF8(buf, d);
 172             foreach (char c2; b)
 173             {
 174                 result = dg(cast(void *)&c2);
 175                 if (result)
 176                     return result;
 177             }
 178             continue;
 179         }
 180         else
 181         {
 182             c = cast(char)d;
 183         }
 184         result = dg(cast(void *)&c);
 185         if (result)
 186             break;
 187     }
 188     return result;
 189 }
 190
 191 extern (C) int _aApplydw1(dchar[] aa, dg_t dg)
 192 {   int result;
 193
 194     debug(apply) printf("_aApplydw1(), len = %d\n", aa.length);
 195     foreach (dchar d; aa)
 196     {
 197         wchar w;
 198
 199         if (d <= 0xFFFF)
 200             w = cast(wchar) d;
 201         else
 202         {
 203             w = cast(wchar)((((d - 0x10000) >> 10) & 0x3FF) + 0xD800);
 204             result = dg(cast(void *)&w);
 205             if (result)
 206                 break;
 207             w = cast(wchar)(((d - 0x10000) & 0x3FF) + 0xDC00);
 208         }
 209         result = dg(cast(void *)&w);
 210         if (result)
 211             break;
 212     }
 213     return result;
 214 }
 215
 216
 217 /****************************************************************************/
 218
 219 // dg is D, but _aApplycd2() is C
 220 extern (D) typedef int delegate(void *, void *) dg2_t;
 221
 222 extern (C) int _aApplycd2(char[] aa, dg2_t dg)
 223 {   int result;
 224     size_t i;
 225     size_t n;
 226     size_t len = aa.length;
 227
 228     debug(apply) printf("_aApplycd2(), len = %d\n", len);
 229     for (i = 0; i < len; i += n)
 230     {   dchar d;
 231
 232         d = aa[i];
 233         if (d & 0x80)
 234         {
 235             n = i;
 236             d = decode(aa, n);
 237             n -= i;
 238         }
 239         else
 240             n = 1;
 241         result = dg(&i, cast(void *)&d);
 242         if (result)
 243             break;
 244     }
 245     return result;
 246 }
 247
 248 extern (C) int _aApplywd2(wchar[] aa, dg2_t dg)
 249 {   int result;
 250     size_t i;
 251     size_t n;
 252     size_t len = aa.length;
 253
 254     debug(apply) printf("_aApplywd2(), len = %d\n", len);
 255     for (i = 0; i < len; i += n)
 256     {   dchar d;
 257
 258         d = aa[i];
 259         if (d & ~0x7F)
 260         {
 261             n = i;
 262             d = decode(aa, n);
 263             n -= i;
 264         }
 265         else
 266             n = 1;
 267         result = dg(&i, cast(void *)&d);
 268         if (result)
 269             break;
 270     }
 271     return result;
 272 }
 273
 274 extern (C) int _aApplycw2(char[] aa, dg2_t dg)
 275 {   int result;
 276     size_t i;
 277     size_t n;
 278     size_t len = aa.length;
 279
 280     debug(apply) printf("_aApplycw2(), len = %d\n", len);
 281     for (i = 0; i < len; i += n)
 282     {   dchar d;
 283         wchar w;
 284
 285         w = aa[i];
 286         if (w & 0x80)
 287         {   n = i;
 288             d = decode(aa, n);
 289             n -= i;
 290             if (d <= 0xFFFF)
 291                 w = cast(wchar) d;
 292             else
 293             {
 294                 w = cast(wchar) ((((d - 0x10000) >> 10) & 0x3FF) + 0xD800);
 295                 result = dg(&i, cast(void *)&w);
 296                 if (result)
 297                     break;
 298                 w = cast(wchar) (((d - 0x10000) & 0x3FF) + 0xDC00);
 299             }
 300         }
 301         else
 302             n = 1;
 303         result = dg(&i, cast(void *)&w);
 304         if (result)
 305             break;
 306     }
 307     return result;
 308 }
 309
 310 extern (C) int _aApplywc2(wchar[] aa, dg2_t dg)
 311 {   int result;
 312     size_t i;
 313     size_t n;
 314     size_t len = aa.length;
 315
 316     debug(apply) printf("_aApplywc2(), len = %d\n", len);
 317     for (i = 0; i < len; i += n)
 318     {   dchar d;
 319         wchar w;
 320         char c;
 321
 322         w = aa[i];
 323         if (w & ~0x7F)
 324         {
 325             char[4] buf;
 326
 327             n = i;
 328             d = decode(aa, n);
 329             n -= i;
 330             auto b = toUTF8(buf, d);
 331             foreach (char c2; b)
 332             {
 333                 result = dg(&i, cast(void *)&c2);
 334                 if (result)
 335                     return result;
 336             }
 337             continue;
 338         }
 339         else
 340         {   c = cast(char)w;
 341             n = 1;
 342         }
 343         result = dg(&i, cast(void *)&c);
 344         if (result)
 345             break;
 346     }
 347     return result;
 348 }
 349
 350 extern (C) int _aApplydc2(dchar[] aa, dg2_t dg)
 351 {   int result;
 352     size_t i;
 353     size_t len = aa.length;
 354
 355     debug(apply) printf("_aApplydc2(), len = %d\n", len);
 356     for (i = 0; i < len; i++)
 357     {   dchar d;
 358         char c;
 359
 360         d = aa[i];
 361         if (d & ~0x7F)
 362         {
 363             char[4] buf;
 364
 365             auto b = toUTF8(buf, d);
 366             foreach (char c2; b)
 367             {
 368                 result = dg(&i, cast(void *)&c2);
 369                 if (result)
 370                     return result;
 371             }
 372             continue;
 373         }
 374         else
 375         {   c = cast(char)d;
 376         }
 377         result = dg(&i, cast(void *)&c);
 378         if (result)
 379             break;
 380     }
 381     return result;
 382 }
 383
 384 extern (C) int _aApplydw2(dchar[] aa, dg2_t dg)
 385 {   int result;
 386
 387     debug(apply) printf("_aApplydw2(), len = %d\n", aa.length);
 388     foreach (size_t i, dchar d; aa)
 389     {
 390         wchar w;
 391         auto j = i;
 392
 393         if (d <= 0xFFFF)
 394             w = cast(wchar) d;
 395         else
 396         {
 397             w = cast(wchar) ((((d - 0x10000) >> 10) & 0x3FF) + 0xD800);
 398             result = dg(&j, cast(void *)&w);
 399             if (result)
 400                 break;
 401             w = cast(wchar) (((d - 0x10000) & 0x3FF) + 0xDC00);
 402         }
 403         result = dg(&j, cast(void *)&w);
 404         if (result)
 405             break;
 406     }
 407     return result;
 408 }