/programs/develop/libraries/newlib/Makefile |
---|
27,6 → 27,7 |
crt/crt2.c \ |
crt/chkstk.S \ |
crt/exit.S \ |
pe/crtloader.c \ |
crt/setjmp.S |
DLL_SRCS:= \ |
103,7 → 104,6 |
sys/read.c \ |
sys/write.c \ |
sys/fsize.c \ |
sys/fload.c \ |
time/asctime.c \ |
time/asctime_r.c \ |
time/clock.c \ |
242,6 → 242,10 |
tmpfile.c \ |
tmpnam.c \ |
ungetc.c \ |
vasniprintf.c \ |
vasnprintf.c \ |
vdprintf.c \ |
vdiprintf.c \ |
vscanf.c \ |
vsprintf.c \ |
vsnprintf.c \ |
250,6 → 254,7 |
wsetup.c \ |
wbuf.c \ |
sccl.c \ |
siprintf.c \ |
sniprintf.c \ |
snprintf.c \ |
sprintf.c \ |
/programs/develop/libraries/newlib/crt/crtdll.c |
---|
82,7 → 82,7 |
init_reent(); |
__initPOSIXHandles(); |
__appenv = load_file("/sys/system.env", &__appenv_size); |
// __appenv = load_file("/sys/system.env", &__appenv_size); |
init_loader(libc_base); |
/programs/develop/libraries/newlib/crt/dllstart.c |
---|
0,0 → 1,11 |
void _pei386_runtime_relocator (void); |
int DllStartup(void *module, int reason); |
int DllStartup(void *module, int reason) |
{ |
_pei386_runtime_relocator(); |
return 1; |
}; |
/programs/develop/libraries/newlib/include/kos32sys.h |
---|
240,6 → 240,14 |
::"a"(68), "b"(1)); |
}; |
static inline void delay(uint32_t time) |
{ |
__asm__ __volatile__( |
"int $0x40" |
::"a"(5), "b"(time) |
:"memory"); |
}; |
static inline |
void *user_alloc(size_t size) |
{ |
273,6 → 281,30 |
return val; |
} |
typedef union |
{ |
struct |
{ |
void *data; |
size_t size; |
}; |
unsigned long long raw; |
}ufile_t; |
static inline ufile_t load_file(char *path) |
{ |
ufile_t uf; |
__asm__ __volatile__ ( |
"int $0x40" |
:"=A"(uf.raw) |
:"a" (68), "b"(27),"c"(path)); |
return uf; |
}; |
static inline int GetScreenSize() |
{ |
int retval; |
339,7 → 371,6 |
return val; |
} |
void *load_file(const char *path, size_t *len); |
void *get_resource(void *data, uint32_t id); |
/programs/develop/libraries/newlib/libcdll.lds |
---|
11,8 → 11,18 |
.text __image_base__ + . : |
{ |
*(.text) *(.rdata) |
. = ALIGN(16); |
*(.text) |
*(SORT(.text$*)) |
*(.text.*) |
*(.glue_7t) |
*(.glue_7) |
___CTOR_LIST__ = .; __CTOR_LIST__ = . ; |
LONG (-1);*(.ctors); *(.ctor); *(SORT(.ctors.*)); LONG (0); |
___DTOR_LIST__ = .; __DTOR_LIST__ = . ; |
LONG (-1); *(.dtors); *(.dtor); *(SORT(.dtors.*)); LONG (0); |
*(.fini) |
*(.rdata) |
*(SORT(.rdata$*)) |
___RUNTIME_PSEUDO_RELOC_LIST__ = .; |
__RUNTIME_PSEUDO_RELOC_LIST__ = .; |
*(.rdata_runtime_pseudo_reloc) |
28,6 → 38,8 |
*(.data2) |
*(SORT(.data$*)) |
*(.jcr) |
__CRT_MT = .; |
LONG(0); |
PROVIDE ( __data_end__ = .) ; |
*(.data_cygwin_nocopy) |
} |
50,6 → 62,7 |
*(.debug$F) |
*(.drectve) |
*(.note.GNU-stack) |
*(.eh_frame) |
*(.comment) |
*(.debug_abbrev) |
*(.debug_info) |
61,18 → 74,6 |
*(.debug_ranges) |
} |
.idata ALIGN(__section_alignment__): |
{ |
SORT(*)(.idata$2) |
SORT(*)(.idata$3) |
/* These zeroes mark the end of the import list. */ |
LONG (0); LONG (0); LONG (0); LONG (0); LONG (0); |
SORT(*)(.idata$4) |
SORT(*)(.idata$5) |
SORT(*)(.idata$6) |
SORT(*)(.idata$7) |
} |
.reloc ALIGN(__section_alignment__) : |
{ |
*(.reloc) |
/programs/develop/libraries/newlib/pe/crtloader.c |
---|
0,0 → 1,219 |
#include <stdint.h> |
#include <stdio.h> |
#include <string.h> |
#include <alloca.h> |
#include <malloc.h> |
#include <setjmp.h> |
#include <envz.h> |
#include <kos32sys.h> |
#include "list.h" |
#include "pe.h" |
#define unlikely(x) __builtin_expect(!!(x), 0) |
//#define DBG(format,...) printf(format,##__VA_ARGS__) |
#define DBG(format,...) |
static inline void sec_copy(void *dst, void *src, size_t len) |
{ |
__asm__ __volatile__ ( |
"shrl $2, %%ecx \n\t" |
"rep movsl" |
: |
:"c"(len),"S"(src),"D"(dst) |
:"cc"); |
__asm__ __volatile__ ( |
"" |
:::"ecx","esi","edi"); |
}; |
void* load_libc(); |
static inline int IsPowerOf2(uint32_t val) |
{ |
if(val == 0) |
return 0; |
return (val & (val - 1)) == 0; |
} |
int validate_pe(void *raw, size_t raw_size, int is_exec) |
{ |
PIMAGE_DOS_HEADER dos; |
PIMAGE_NT_HEADERS32 nt; |
dos = (PIMAGE_DOS_HEADER)raw; |
if( !raw || raw_size < sizeof(IMAGE_DOS_HEADER) ) |
return 0; |
if( dos->e_magic != IMAGE_DOS_SIGNATURE || dos->e_lfanew <= 0) |
return 0; |
nt = MakePtr( PIMAGE_NT_HEADERS32, dos, dos->e_lfanew); |
if( (uint32_t)nt < (uint32_t)raw) |
return 0; |
if(nt->Signature != IMAGE_NT_SIGNATURE) |
return 0; |
if(nt->FileHeader.Machine != IMAGE_FILE_MACHINE_I386) |
return 0; |
if(is_exec && (nt->FileHeader.Characteristics & IMAGE_FILE_DLL)) |
return 0; |
if(nt->OptionalHeader.Magic != IMAGE_NT_OPTIONAL_HDR32_MAGIC) |
return 0; |
if( is_exec && nt->OptionalHeader.ImageBase != 0) |
return 0; |
if(nt->OptionalHeader.SectionAlignment < 4096) |
{ |
if(nt->OptionalHeader.FileAlignment != nt->OptionalHeader.SectionAlignment) |
return 0; |
} |
else if(nt->OptionalHeader.SectionAlignment < nt->OptionalHeader.FileAlignment) |
return 0; |
if(!IsPowerOf2(nt->OptionalHeader.SectionAlignment) || |
!IsPowerOf2(nt->OptionalHeader.FileAlignment)) |
return 0; |
if(nt->FileHeader.NumberOfSections > 96) |
return 0; |
return 1; |
} |
void* create_image(void *raw) |
{ |
PIMAGE_DOS_HEADER dos; |
PIMAGE_NT_HEADERS32 nt; |
PIMAGE_SECTION_HEADER img_sec; |
void *img_base; |
uint32_t sec_align; |
int i; |
dos = (PIMAGE_DOS_HEADER)raw; |
nt = MakePtr( PIMAGE_NT_HEADERS32, dos, dos->e_lfanew); |
img_base = user_alloc(nt->OptionalHeader.SizeOfImage); |
if(unlikely(img_base == NULL)) |
return 0; |
sec_copy(img_base, raw, nt->OptionalHeader.SizeOfHeaders); |
img_sec = MakePtr(PIMAGE_SECTION_HEADER, nt, sizeof(IMAGE_NT_HEADERS32)); |
sec_align = nt->OptionalHeader.SectionAlignment; |
for(i=0; i< nt->FileHeader.NumberOfSections; i++) |
{ |
void *src_ptr; |
void *dest_ptr; |
size_t sec_size; |
if ( img_sec->SizeOfRawData && img_sec->PointerToRawData ) |
{ |
src_ptr = MakePtr(void*, raw, img_sec->PointerToRawData); |
dest_ptr = MakePtr(void*, img_base, img_sec->VirtualAddress); |
sec_copy(dest_ptr, src_ptr, img_sec->SizeOfRawData); |
}; |
img_sec++; |
}; |
if(nt->OptionalHeader.DataDirectory[5].Size) |
{ |
PIMAGE_BASE_RELOCATION reloc; |
uint32_t delta = (uint32_t)img_base - nt->OptionalHeader.ImageBase; |
reloc = MakePtr(PIMAGE_BASE_RELOCATION, img_base, |
nt->OptionalHeader.DataDirectory[5].VirtualAddress); |
while ( reloc->SizeOfBlock != 0 ) |
{ |
uint32_t cnt; |
uint16_t *entry; |
uint16_t reltype; |
uint32_t offs; |
cnt = (reloc->SizeOfBlock - sizeof(*reloc))/sizeof(uint16_t); |
entry = MakePtr( uint16_t*, reloc, sizeof(*reloc) ); |
for ( i=0; i < cnt; i++ ) |
{ |
uint16_t *p16; |
uint32_t *p32; |
reltype = (*entry & 0xF000) >> 12; |
offs = (*entry & 0x0FFF) + reloc->VirtualAddress; |
switch(reltype) |
{ |
case 1: |
p16 = MakePtr(uint16_t*, img_base, offs); |
*p16+= (uint16_t)(delta>>16); |
break; |
case 2: |
p16 = MakePtr(uint16_t*, img_base, offs); |
*p16+= (uint16_t)delta; |
break; |
case 3: |
p32 = MakePtr(uint32_t*, img_base, offs); |
*p32+= delta; |
} |
entry++; |
} |
reloc = MakePtr(PIMAGE_BASE_RELOCATION, reloc,reloc->SizeOfBlock); |
}; |
printf("unmap base %p offset %x %d page(s)\n", |
img_base, |
nt->OptionalHeader.DataDirectory[5].VirtualAddress, |
(nt->OptionalHeader.DataDirectory[5].Size+4095)>>12); |
user_unmap(img_base,nt->OptionalHeader.DataDirectory[5].VirtualAddress, |
nt->OptionalHeader.DataDirectory[5].Size); |
}; |
return img_base; |
}; |
void* load_libc() |
{ |
void *raw_img; |
size_t raw_size; |
void *img_base = NULL; |
ufile_t uf; |
uf = load_file("/kolibrios/lib/libc.dll"); |
raw_img = uf.data; |
raw_size = uf.size; |
if(raw_img == NULL) |
return NULL; |
printf("libc.dll raw %p, size %d\n", raw_img, raw_size); |
if( validate_pe(raw_img, raw_size, 0) == 0) |
{ |
printf("invalide libc.dll\n"); |
user_free(raw_img); |
}; |
img_base = create_image(raw_img); |
return img_base; |
} |
/programs/develop/libraries/newlib/pe/loader.c |
---|
658,7 → 658,7 |
memcpy(path+dllpath->path_len, name, len); |
path[len+dllpath->path_len]=0; |
raw_img = load_file(path, &raw_size); |
// raw_img = load_file(path, &raw_size); |
if(raw_img == NULL) |
continue; |
/programs/develop/libraries/newlib/static-amz.lds |
---|
0,0 → 1,123 |
/*OUTPUT_FORMAT("binary")*/ |
ENTRY(__start) |
SECTIONS |
{ |
.text 0x000000: |
{ |
LONG(0x554e454D); |
LONG(0x32305445); |
LONG(1); |
LONG(__start); |
LONG(___iend); |
LONG(___memsize); |
LONG(___stacktop); |
LONG(___cmdline); |
LONG(___pgmname); /* full path */ |
LONG(0); /*FIXME tls data */ |
*(.init) |
*(.text) |
*(SORT(.text$*)) |
*(.text.*) |
*(.glue_7t) |
*(.glue_7) |
___CTOR_LIST__ = .; __CTOR_LIST__ = . ; |
LONG (-1);*(.ctors); *(.ctor); *(SORT(.ctors.*)); LONG (0); |
___DTOR_LIST__ = .; __DTOR_LIST__ = . ; |
LONG (-1); *(.dtors); *(.dtor); *(SORT(.dtors.*)); LONG (0); |
*(.fini) |
/* ??? Why is .gcc_exc here? */ |
*(.gcc_exc) |
PROVIDE (etext = .); |
*(.gcc_except_table) |
} |
.rdata ALIGN(64) : |
{ |
*(.rdata) |
*(SORT(.rdata$*)) |
___RUNTIME_PSEUDO_RELOC_LIST__ = .; |
__RUNTIME_PSEUDO_RELOC_LIST__ = .; |
*(.rdata_runtime_pseudo_reloc) |
___RUNTIME_PSEUDO_RELOC_LIST_END__ = .; |
__RUNTIME_PSEUDO_RELOC_LIST_END__ = .; |
} |
.CRT ALIGN(64) : |
{ |
___crt_xc_start__ = . ; |
*(SORT(.CRT$XC*)) /* C initialization */ |
___crt_xc_end__ = . ; |
___crt_xi_start__ = . ; |
*(SORT(.CRT$XI*)) /* C++ initialization */ |
___crt_xi_end__ = . ; |
___crt_xl_start__ = . ; |
*(SORT(.CRT$XL*)) /* TLS callbacks */ |
/* ___crt_xl_end__ is defined in the TLS Directory support code */ |
___crt_xp_start__ = . ; |
*(SORT(.CRT$XP*)) /* Pre-termination */ |
___crt_xp_end__ = . ; |
___crt_xt_start__ = . ; |
*(SORT(.CRT$XT*)) /* Termination */ |
___crt_xt_end__ = . ; |
} |
.data ALIGN(64) : |
{ |
PROVIDE ( __data_start__ = .) ; |
*(.data) |
*(.data2) |
*(SORT(.data$*)) |
*(.jcr) |
__CRT_MT = .; |
LONG(0); |
PROVIDE ( __data_end__ = .) ; |
*(.data_cygwin_nocopy) |
___iend = . ; |
} |
.idata ALIGN(64): |
{ |
SORT(*)(.idata$2) |
SORT(*)(.idata$3) |
/* These zeroes mark the end of the import list. */ |
LONG (0); LONG (0); LONG (0); LONG (0); LONG (0); |
SORT(*)(.idata$4) |
SORT(*)(.idata$5) |
SORT(*)(.idata$6) |
SORT(*)(.idata$7) |
} |
bss ALIGN(64): |
{ |
*(.bss) |
*(COMMON) |
. = ALIGN(16); |
___cmdline = .; |
. = . + 256; |
___pgmname = .; |
. = . + 1024 + 16; |
___stacktop = .; |
___memsize = . ; |
} |
/DISCARD/ : |
{ |
*(.debug$S) |
*(.debug$T) |
*(.debug$F) |
*(.drectve) |
*(.note.GNU-stack) |
*(.eh_frame) |
*(.comment) |
*(.debug_abbrev) |
*(.debug_info) |
*(.debug_line) |
*(.debug_frame) |
*(.debug_loc) |
*(.debug_pubnames) |
*(.debug_aranges) |
*(.debug_ranges) |
} |
} |
/programs/develop/libraries/newlib/static.lds |
---|
64,7 → 64,7 |
.data ALIGN(64) : |
{ |
__data_start__ = . ; |
PROVIDE ( __data_start__ = .) ; |
*(.data) |
*(.data2) |
*(SORT(.data$*)) |
71,7 → 71,7 |
*(.jcr) |
__CRT_MT = .; |
LONG(0); |
__data_end__ = . ; |
PROVIDE ( __data_end__ = .) ; |
*(.data_cygwin_nocopy) |
___iend = . ; |
} |
/programs/develop/libraries/newlib/stdio/siprintf.c |
---|
0,0 → 1,171 |
/* |
* Copyright (c) 1990 The Regents of the University of California. |
* All rights reserved. |
* |
* Redistribution and use in source and binary forms are permitted |
* provided that the above copyright notice and this paragraph are |
* duplicated in all such forms and that any documentation, |
* advertising materials, and other materials related to such |
* distribution and use acknowledge that the software was developed |
* by the University of California, Berkeley. The name of the |
* University may not be used to endorse or promote products derived |
* from this software without specific prior written permission. |
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR |
* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED |
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. |
*/ |
/* |
FUNCTION |
<<siprintf>>, <<fiprintf>>, <<iprintf>>, <<sniprintf>>, <<asiprintf>>, <<asniprintf>>---format output (integer only) |
INDEX |
fiprintf |
INDEX |
_fiprintf_r |
INDEX |
iprintf |
INDEX |
_iprintf_r |
INDEX |
siprintf |
INDEX |
_siprintf_r |
INDEX |
sniprintf |
INDEX |
_sniprintf_r |
INDEX |
asiprintf |
INDEX |
_asiprintf_r |
INDEX |
asniprintf |
INDEX |
_asniprintf_r |
ANSI_SYNOPSIS |
#include <stdio.h> |
int iprintf(const char *<[format]>, ...); |
int fiprintf(FILE *<[fd]>, const char *<[format]> , ...); |
int siprintf(char *<[str]>, const char *<[format]>, ...); |
int sniprintf(char *<[str]>, size_t <[size]>, const char *<[format]>, |
...); |
int asiprintf(char **<[strp]>, const char *<[format]>, ...); |
char *asniprintf(char *<[str]>, size_t *<[size]>, |
const char *<[format]>, ...); |
int _iprintf_r(struct _reent *<[ptr]>, const char *<[format]>, ...); |
int _fiprintf_r(struct _reent *<[ptr]>, FILE *<[fd]>, |
const char *<[format]>, ...); |
int _siprintf_r(struct _reent *<[ptr]>, char *<[str]>, |
const char *<[format]>, ...); |
int _sniprintf_r(struct _reent *<[ptr]>, char *<[str]>, size_t <[size]>, |
const char *<[format]>, ...); |
int _asiprintf_r(struct _reent *<[ptr]>, char **<[strp]>, |
const char *<[format]>, ...); |
char *_asniprintf_r(struct _reent *<[ptr]>, char *<[str]>, |
size_t *<[size]>, const char *<[format]>, ...); |
DESCRIPTION |
<<iprintf>>, <<fiprintf>>, <<siprintf>>, <<sniprintf>>, |
<<asiprintf>>, and <<asniprintf>> are the same as <<printf>>, |
<<fprintf>>, <<sprintf>>, <<snprintf>>, <<asprintf>>, and |
<<asnprintf>>, respectively, except that they restrict usage |
to non-floating-point format specifiers. |
<<_iprintf_r>>, <<_fiprintf_r>>, <<_asiprintf_r>>, |
<<_siprintf_r>>, <<_sniprintf_r>>, <<_asniprintf_r>> are |
simply reentrant versions of the functions above. |
RETURNS |
Similar to <<printf>>, <<fprintf>>, <<sprintf>>, <<snprintf>>, <<asprintf>>, |
and <<asnprintf>>. |
PORTABILITY |
<<iprintf>>, <<fiprintf>>, <<siprintf>>, <<sniprintf>>, <<asiprintf>>, |
and <<asniprintf>> are newlib extensions. |
Supporting OS subroutines required: <<close>>, <<fstat>>, <<isatty>>, |
<<lseek>>, <<read>>, <<sbrk>>, <<write>>. |
*/ |
#include <_ansi.h> |
#include <reent.h> |
#include <stdio.h> |
#ifdef _HAVE_STDC |
#include <stdarg.h> |
#else |
#include <varargs.h> |
#endif |
#include <limits.h> |
#include "local.h" |
int |
#ifdef _HAVE_STDC |
_DEFUN(_siprintf_r, (ptr, str, fmt), |
struct _reent *ptr _AND |
char *str _AND |
_CONST char *fmt _DOTS) |
#else |
_siprintf_r(ptr, str, fmt, va_alist) |
struct _reent *ptr; |
char *str; |
_CONST char *fmt; |
va_dcl |
#endif |
{ |
int ret; |
va_list ap; |
FILE f; |
f._flags = __SWR | __SSTR; |
f._bf._base = f._p = (unsigned char *) str; |
f._bf._size = f._w = INT_MAX; |
f._file = -1; /* No file. */ |
#ifdef _HAVE_STDC |
va_start (ap, fmt); |
#else |
va_start (ap); |
#endif |
ret = _svfiprintf_r (ptr, &f, fmt, ap); |
va_end (ap); |
*f._p = 0; |
return (ret); |
} |
#ifndef _REENT_ONLY |
int |
#ifdef _HAVE_STDC |
_DEFUN(siprintf, (str, fmt), |
char *str _AND |
_CONST char *fmt _DOTS) |
#else |
siprintf(str, fmt, va_alist) |
char *str; |
_CONST char *fmt; |
va_dcl |
#endif |
{ |
int ret; |
va_list ap; |
FILE f; |
f._flags = __SWR | __SSTR; |
f._bf._base = f._p = (unsigned char *) str; |
f._bf._size = f._w = INT_MAX; |
f._file = -1; /* No file. */ |
#ifdef _HAVE_STDC |
va_start (ap, fmt); |
#else |
va_start (ap); |
#endif |
ret = _svfiprintf_r (_REENT, &f, fmt, ap); |
va_end (ap); |
*f._p = 0; |
return (ret); |
} |
#endif |
/programs/develop/libraries/newlib/stdio/vasniprintf.c |
---|
0,0 → 1,71 |
/* Copyright (C) 2007, 2008 Eric Blake |
* Permission to use, copy, modify, and distribute this software |
* is freely granted, provided that this notice is preserved. |
*/ |
/* This code was derived from asprintf.c */ |
/* doc in viprintf.c */ |
#include <_ansi.h> |
#include <reent.h> |
#include <stdio.h> |
#include <stdarg.h> |
#include <limits.h> |
#include <errno.h> |
#include "local.h" |
char * |
_DEFUN(_vasniprintf_r, (ptr, buf, lenp, fmt, ap), |
struct _reent *ptr _AND |
char *buf _AND |
size_t *lenp _AND |
const char *fmt _AND |
va_list ap) |
{ |
int ret; |
FILE f; |
size_t len = *lenp; |
if (buf && len) |
{ |
/* mark an existing buffer, but allow allocation of larger string */ |
f._flags = __SWR | __SSTR | __SOPT; |
} |
else |
{ |
/* mark a zero-length reallocatable buffer */ |
f._flags = __SWR | __SSTR | __SMBF; |
len = 0; |
buf = NULL; |
} |
f._bf._base = f._p = (unsigned char *) buf; |
/* For now, inherit the 32-bit signed limit of FILE._bf._size. |
FIXME - it would be nice to rewrite sys/reent.h to support size_t |
for _size. */ |
if (len > INT_MAX) |
{ |
ptr->_errno = EOVERFLOW; |
return NULL; |
} |
f._bf._size = f._w = len; |
f._file = -1; /* No file. */ |
ret = _svfiprintf_r (ptr, &f, fmt, ap); |
if (ret < 0) |
return NULL; |
*lenp = ret; |
*f._p = '\0'; |
return (char *) f._bf._base; |
} |
#ifndef _REENT_ONLY |
char * |
_DEFUN(vasniprintf, (buf, lenp, fmt, ap), |
char *buf _AND |
size_t *lenp _AND |
const char *fmt _AND |
va_list ap) |
{ |
return _vasniprintf_r (_REENT, buf, lenp, fmt, ap); |
} |
#endif /* ! _REENT_ONLY */ |
/programs/develop/libraries/newlib/stdio/vasnprintf.c |
---|
0,0 → 1,71 |
/* Copyright (C) 2007 Eric Blake |
* Permission to use, copy, modify, and distribute this software |
* is freely granted, provided that this notice is preserved. |
*/ |
/* This code was derived from asprintf.c */ |
/* doc in vfprintf.c */ |
#include <_ansi.h> |
#include <reent.h> |
#include <stdio.h> |
#include <stdarg.h> |
#include <limits.h> |
#include <errno.h> |
#include "local.h" |
char * |
_DEFUN(_vasnprintf_r, (ptr, buf, lenp, fmt, ap), |
struct _reent *ptr _AND |
char *buf _AND |
size_t *lenp _AND |
const char *fmt _AND |
va_list ap) |
{ |
int ret; |
FILE f; |
size_t len = *lenp; |
if (buf && len) |
{ |
/* mark an existing buffer, but allow allocation of larger string */ |
f._flags = __SWR | __SSTR | __SOPT; |
} |
else |
{ |
/* mark a zero-length reallocatable buffer */ |
f._flags = __SWR | __SSTR | __SMBF; |
len = 0; |
buf = NULL; |
} |
f._bf._base = f._p = (unsigned char *) buf; |
/* For now, inherit the 32-bit signed limit of FILE._bf._size. |
FIXME - it would be nice to rewrite sys/reent.h to support size_t |
for _size. */ |
if (len > INT_MAX) |
{ |
ptr->_errno = EOVERFLOW; |
return NULL; |
} |
f._bf._size = f._w = len; |
f._file = -1; /* No file. */ |
ret = _svfprintf_r (ptr, &f, fmt, ap); |
if (ret < 0) |
return NULL; |
*lenp = ret; |
*f._p = '\0'; |
return (char *) f._bf._base; |
} |
#ifndef _REENT_ONLY |
char * |
_DEFUN(vasnprintf, (buf, lenp, fmt, ap), |
char *buf _AND |
size_t *lenp _AND |
const char *fmt _AND |
va_list ap) |
{ |
return _vasnprintf_r (_REENT, buf, lenp, fmt, ap); |
} |
#endif /* ! _REENT_ONLY */ |
/programs/develop/libraries/newlib/stdio/vdiprintf.c |
---|
0,0 → 1,47 |
/* Copyright 2005, 2007 Shaun Jackman |
* Permission to use, copy, modify, and distribute this software |
* is freely granted, provided that this notice is preserved. |
*/ |
/* doc in diprintf.c */ |
#include <_ansi.h> |
#include <reent.h> |
#include <stdio.h> |
#include <stdlib.h> |
#include <unistd.h> |
#include <stdarg.h> |
#include "local.h" |
int |
_DEFUN(_vdiprintf_r, (ptr, fd, format, ap), |
struct _reent *ptr _AND |
int fd _AND |
const char *format _AND |
va_list ap) |
{ |
char *p; |
char buf[512]; |
size_t n = sizeof buf; |
_REENT_SMALL_CHECK_INIT (ptr); |
p = _vasniprintf_r (ptr, buf, &n, format, ap); |
if (!p) |
return -1; |
n = _write_r (ptr, fd, p, n); |
if (p != buf) |
_free_r (ptr, p); |
return n; |
} |
#ifndef _REENT_ONLY |
int |
_DEFUN(vdiprintf, (fd, format, ap), |
int fd _AND |
const char *format _AND |
va_list ap) |
{ |
return _vdiprintf_r (_REENT, fd, format, ap); |
} |
#endif /* ! _REENT_ONLY */ |
/programs/develop/libraries/newlib/stdio/vdprintf.c |
---|
0,0 → 1,47 |
/* Copyright 2005, 2007 Shaun Jackman |
* Permission to use, copy, modify, and distribute this software |
* is freely granted, provided that this notice is preserved. |
*/ |
/* doc in dprintf.c */ |
#include <_ansi.h> |
#include <reent.h> |
#include <stdio.h> |
#include <stdlib.h> |
#include <unistd.h> |
#include <stdarg.h> |
#include "local.h" |
int |
_DEFUN(_vdprintf_r, (ptr, fd, format, ap), |
struct _reent *ptr _AND |
int fd _AND |
const char *format _AND |
va_list ap) |
{ |
char *p; |
char buf[512]; |
size_t n = sizeof buf; |
_REENT_SMALL_CHECK_INIT (ptr); |
p = _vasnprintf_r (ptr, buf, &n, format, ap); |
if (!p) |
return -1; |
n = _write_r (ptr, fd, p, n); |
if (p != buf) |
_free_r (ptr, p); |
return n; |
} |
#ifndef _REENT_ONLY |
int |
_DEFUN(vdprintf, (fd, format, ap), |
int fd _AND |
const char *format _AND |
va_list ap) |
{ |
return _vdprintf_r (_REENT, fd, format, ap); |
} |
#endif /* ! _REENT_ONLY */ |