Lines Matching defs:self
2183 TRIO_ARGS6((self, number, flags, width, precision, base),
2184 trio_class_t *self,
2204 assert(VALID(self));
2205 assert(VALID(self->OutStream));
2309 self->OutStream(self, CHAR_ADJUST);
2314 self->OutStream(self, '-');
2316 self->OutStream(self, '+');
2318 self->OutStream(self, ' ');
2326 self->OutStream(self, '0');
2327 self->OutStream(self, (flags & FLAGS_UPPER) ? 'B' : 'b');
2332 self->OutStream(self, '0');
2336 self->OutStream(self, '0');
2337 self->OutStream(self, (flags & FLAGS_UPPER) ? 'X' : 'x');
2352 self->OutStream(self, '0');
2362 self->OutStream(self, *pointer);
2370 self->OutStream(self, CHAR_ADJUST);
2382 TRIO_ARGS3((self, ch, flags),
2383 trio_class_t *self,
2395 self->OutStream(self, CHAR_BACKSLASH);
2398 case '\007': self->OutStream(self, 'a'); break;
2399 case '\b': self->OutStream(self, 'b'); break;
2400 case '\f': self->OutStream(self, 'f'); break;
2401 case '\n': self->OutStream(self, 'n'); break;
2402 case '\r': self->OutStream(self, 'r'); break;
2403 case '\t': self->OutStream(self, 't'); break;
2404 case '\v': self->OutStream(self, 'v'); break;
2405 case '\\': self->OutStream(self, '\\'); break;
2407 self->OutStream(self, 'x');
2408 TrioWriteNumber(self, (trio_uintmax_t)ch,
2416 self->OutStream(self, CHAR_BACKSLASH);
2417 self->OutStream(self, CHAR_BACKSLASH);
2421 self->OutStream(self, ch);
2426 self->OutStream(self, ch);
2438 TRIO_ARGS5((self, string, flags, width, precision),
2439 trio_class_t *self,
2448 assert(VALID(self));
2449 assert(VALID(self->OutStream));
2471 self->OutStream(self, CHAR_QUOTE);
2476 self->OutStream(self, CHAR_ADJUST);
2483 TrioWriteStringCharacter(self, ch, flags);
2489 self->OutStream(self, CHAR_ADJUST);
2492 self->OutStream(self, CHAR_QUOTE);
2504 TRIO_ARGS4((self, wch, flags, width),
2505 trio_class_t *self,
2529 TrioWriteStringCharacter(self, ch, flags);
2544 TRIO_ARGS5((self, wstring, flags, width, precision),
2545 trio_class_t *self,
2554 assert(VALID(self));
2555 assert(VALID(self->OutStream));
2563 TrioWriteString(self, NULL, flags, width, precision);
2578 self->OutStream(self, CHAR_QUOTE);
2583 self->OutStream(self, CHAR_ADJUST);
2588 size = TrioWriteWideStringCharacter(self, *wstring++, flags, length);
2597 self->OutStream(self, CHAR_ADJUST);
2600 self->OutStream(self, CHAR_QUOTE);
2621 TRIO_ARGS6((self, number, flags, width, precision, base),
2622 trio_class_t *self,
2662 assert(VALID(self));
2663 assert(VALID(self->OutStream));
2670 TrioWriteString(self,
2681 TrioWriteString(self,
2691 TrioWriteString(self,
2920 self->OutStream(self, '-');
2922 self->OutStream(self, '+');
2924 self->OutStream(self, ' ');
2927 self->OutStream(self, '0');
2928 self->OutStream(self, (flags & FLAGS_UPPER) ? 'X' : 'x');
2934 self->OutStream(self, '0');
2945 self->OutStream(self, CHAR_ADJUST);
2949 self->OutStream(self, '-');
2951 self->OutStream(self, '+');
2953 self->OutStream(self, ' ');
2956 self->OutStream(self, '0');
2957 self->OutStream(self, (flags & FLAGS_UPPER) ? 'X' : 'x');
2969 self->OutStream(self, digits[0]);
2973 self->OutStream(self, digits[(int)fmodl(workNumber, dblBase)]);
2984 self->OutStream(self, *groupingPointer);
2996 self->OutStream(self, internalDecimalPoint);
3002 self->OutStream(self, internalDecimalPointString[i]);
3030 self->OutStream(self, digits[0]);
3033 self->OutStream(self, digits[index]);
3042 self->OutStream(self, digits[0]);
3050 self->OutStream(self,
3054 self->OutStream(self, (isExponentNegative) ? '-' : '+');
3058 self->OutStream(self, '0');
3065 self->OutStream(self, digits[(uExponent / exponentBase) % base]);
3074 self->OutStream(self, CHAR_ADJUST);
3471 TRIO_ARGS2((self, output),
3472 trio_class_t *self,
3477 assert(VALID(self));
3478 assert(VALID(self->location));
3480 file = (FILE *)self->location;
3481 self->processed++;
3484 self->error = TRIO_ERROR_RETURN(TRIO_EOF, 0);
3488 self->committed++;
3497 TRIO_ARGS2((self, output),
3498 trio_class_t *self,
3504 assert(VALID(self));
3506 fd = *((int *)self->location);
3508 self->processed++;
3511 self->error = TRIO_ERROR_RETURN(TRIO_ERRNO, 0);
3515 self->committed++;
3524 TRIO_ARGS2((self, output),
3525 trio_class_t *self,
3531 assert(VALID(self));
3532 assert(VALID(self->location));
3534 data = (trio_custom_t *)self->location;
3540 self->committed++;
3544 if (self->error == 0)
3546 self->error = TRIO_ERROR_RETURN(TRIO_ECUSTOM, -status);
3550 self->processed++;
3558 TRIO_ARGS2((self, output),
3559 trio_class_t *self,
3564 assert(VALID(self));
3565 assert(VALID(self->location));
3567 buffer = (char **)self->location;
3570 self->processed++;
3571 self->committed++;
3579 TRIO_ARGS2((self, output),
3580 trio_class_t *self,
3585 assert(VALID(self));
3586 assert(VALID(self->location));
3588 buffer = (char **)self->location;
3590 if (self->processed < self->max)
3594 self->committed++;
3596 self->processed++;
3604 TRIO_ARGS2((self, output),
3605 trio_class_t *self,
3608 assert(VALID(self));
3609 assert(VALID(self->location));
3611 if (self->error == 0)
3613 trio_xstring_append_char((trio_string_t *)self->location,
3615 self->committed++;
3618 self->processed++;
4362 trio_userdef_t *self = (trio_userdef_t *)handle;
4366 assert(VALID(self));
4368 if (self->name)
4370 def = TrioFindNamespace(self->name, &prev);
4384 trio_destroy(self->name);
4386 TRIO_FREE(self);
4867 trio_reference_t *self = (trio_reference_t *)ref;
4869 TrioWriteNumber(self->data,
4871 self->parameter->flags,
4872 self->parameter->width,
4873 self->parameter->precision,
4874 self->parameter->base);
4886 trio_reference_t *self = (trio_reference_t *)ref;
4888 TrioWriteNumber(self->data,
4890 self->parameter->flags | FLAGS_UNSIGNED,
4891 self->parameter->width,
4892 self->parameter->precision,
4893 self->parameter->base);
4905 trio_reference_t *self = (trio_reference_t *)ref;
4907 TrioWriteDouble(self->data,
4909 self->parameter->flags,
4910 self->parameter->width,
4911 self->parameter->precision,
4912 self->parameter->base);
4924 trio_reference_t *self = (trio_reference_t *)ref;
4926 TrioWriteString(self->data,
4928 self->parameter->flags,
4929 self->parameter->width,
4930 self->parameter->precision);
4995 trio_reference_t *self = (trio_reference_t *)ref;
5003 self->data->OutStream(self->data, *string++);
5017 flags = self->parameter->flags;
5020 TrioWriteNumber(self->data,
5131 TRIO_ARGS1((self),
5132 trio_class_t *self)
5136 ch = self->current;
5139 self->InStream(self, &ch);
5442 TRIO_ARGS5((self, target, flags, width, base),
5443 trio_class_t *self,
5456 assert(VALID(self));
5457 assert(VALID(self->InStream));
5472 TrioSkipWhitespaces(self);
5477 if (self->current == '+')
5479 self->InStream(self, NULL);
5481 else if (self->current == '-')
5483 self->InStream(self, NULL);
5488 count = self->processed;
5498 if (self->current == '0')
5500 self->InStream(self, NULL);
5501 if (self->current)
5504 (trio_to_upper(self->current) == 'X'))
5506 self->InStream(self, NULL);
5509 (trio_to_upper(self->current) == 'B'))
5511 self->InStream(self, NULL);
5523 while (((width == NO_WIDTH) || (self->processed - count < width)) &&
5524 (! ((self->current == EOF) || isspace(self->current))))
5526 if (isascii(self->current))
5528 digit = internalDigitArray[self->current];
5536 for (j = 0; internalThousandSeparator[j] && self->current; j++)
5538 if (internalThousandSeparator[j] != self->current)
5541 self->InStream(self, NULL);
5555 self->InStream(self, NULL);
5572 TRIO_ARGS4((self, target, flags, width),
5573 trio_class_t *self,
5582 assert(VALID(self));
5583 assert(VALID(self->InStream));
5586 (self->current != EOF) && (i < width);
5589 ch = (char)self->current;
5590 self->InStream(self, NULL);
5593 switch (self->current)
5604 if (isdigit(self->current))
5607 if (!TrioReadNumber(self, &number, 0, 3, BASE_OCTAL))
5611 else if (trio_to_upper(self->current) == 'X')
5614 self->InStream(self, NULL);
5615 if (!TrioReadNumber(self, &number, 0, 2, BASE_HEX))
5621 ch = (char)self->current;
5638 TRIO_ARGS4((self, target, flags, width),
5639 trio_class_t *self,
5646 assert(VALID(self));
5647 assert(VALID(self->InStream));
5649 TrioSkipWhitespaces(self);
5657 (! ((self->current == EOF) || isspace(self->current)));
5660 if (TrioReadChar(self, (target ? &target[i] : 0), flags, 1) == 0)
5674 TRIO_ARGS4((self, target, flags, width),
5675 trio_class_t *self,
5687 assert(VALID(self));
5688 assert(VALID(self->InStream));
5691 (self->current != EOF) && (i < width);
5694 if (isascii(self->current))
5696 if (TrioReadChar(self, buffer, flags, 1) == 0)
5710 buffer[j++] = (char)self->current;
5712 self->InStream(self, NULL);
5723 self->InStream(self, NULL);
5735 TRIO_ARGS4((self, target, flags, width),
5736 trio_class_t *self,
5744 assert(VALID(self));
5745 assert(VALID(self->InStream));
5747 TrioSkipWhitespaces(self);
5759 (! ((self->current == EOF) || isspace(self->current)));
5762 size = TrioReadWideChar(self, &target[i], flags, 1);
5781 TRIO_ARGS5((self, target, characterclass, flags, width),
5782 trio_class_t *self,
5791 assert(VALID(self));
5792 assert(VALID(self->InStream));
5794 ch = self->current;
5803 self->InStream(self, &ch);
5820 TRIO_ARGS4((self, target, flags, width),
5821 trio_class_t *self,
5838 TrioSkipWhitespaces(self);
5845 ch = self->current;
5849 self->InStream(self, &ch);
5868 self->InStream(self, &ch);
5917 self->InStream(self, &ch);
5922 self->InStream(self, &ch);
5936 self->InStream(self, &ch);
5941 for (j = 0; internalThousandSeparator[j] && self->current; j++)
5943 if (internalThousandSeparator[j] != self->current)
5946 self->InStream(self, &ch);
5960 self->InStream(self, &ch);
5965 self->InStream(self, &ch);
5971 self->InStream(self, &ch);
5975 self->InStream(self, &ch);
5980 self->InStream(self, &ch);
6006 TRIO_ARGS3((self, target, flags),
6007 trio_class_t *self,
6016 if (TrioReadNumber(self,
6030 else if (TrioReadString(self,
6433 TRIO_ARGS2((self, intPointer),
6434 trio_class_t *self,
6439 assert(VALID(self));
6440 assert(VALID(self->location));
6443 file = (FILE *)self->location;
6445 self->current = fgetc(file);
6446 if (self->current == EOF)
6448 self->error = (ferror(file))
6454 self->processed++;
6455 self->committed++;
6460 *intPointer = self->current;
6469 TRIO_ARGS2((self, intPointer),
6470 trio_class_t *self,
6477 assert(VALID(self));
6478 assert(VALID(self->location));
6480 fd = *((int *)self->location);
6485 self->error = TRIO_ERROR_RETURN(TRIO_ERRNO, 0);
6486 self->current = EOF;
6490 self->current = (size == 0) ? EOF : input;
6492 if (self->current != EOF)
6494 self->committed++;
6495 self->processed++;
6500 *intPointer = self->current;
6509 TRIO_ARGS2((self, intPointer),
6510 trio_class_t *self,
6515 assert(VALID(self));
6516 assert(VALID(self->location));
6518 data = (trio_custom_t *)self->location;
6520 self->current = (data->stream.in == NULL)
6524 if (self->current == NIL)
6526 self->current = EOF;
6530 self->processed++;
6531 self->committed++;
6536 *intPointer = self->current;
6545 TRIO_ARGS2((self, intPointer),
6546 trio_class_t *self,
6551 assert(VALID(self));
6552 assert(VALID(self->location));
6554 buffer = (unsigned char **)self->location;
6555 self->current = (*buffer)[0];
6556 if (self->current == NIL)
6558 self->current = EOF;
6563 self->processed++;
6564 self->committed++;
6569 *intPointer = self->current;
