bool trie_save(trie_tree *tree, FILE* stream)
{
assert(tree != NULL);
if(tree->root == NULL)
return putwc(EMPTY_TREE, stream) != WEOF;
if(putwc(NOT_EMPTY_TREE, stream) == WEOF)
return false;
if(!node_save(tree->root, stream))
return false;
return putwc(END_OF_TRIE_FILE, stream) != WEOF;
}
void print_uuid(uint8_t *uuid)
{
printhex(stdout, uuid, 4);
putwc('-', stdout);
printhex(stdout, uuid + 4, 2);
putwc('-', stdout);
printhex(stdout, uuid + 6, 2);
putwc('-', stdout);
printhex(stdout, uuid + 8, 2);
putwc('-', stdout);
printhex(stdout, uuid + 10, 6);
}
/**
Zapisuje do pliku dany węzęł
@param[in] node Węzeł
@param[out] stream Plik
@return Czy się udało
*/
static bool node_save(trie_node *node, FILE *stream)
{
for(int i = 0; i < vector_size(node->sons); i++)
{
if(putwc(NTH_SON_CHAR(node, i), stream) == WEOF)
return false;
if(!node_save(NTH_SON(node, i), stream))
return false;
}
if(putwc(node->end_of_word ? END_OF_WORD : NOT_END_OF_WORD, stream) == WEOF)
return false;
return true;
}
/*
* This is the same as __cputchar but the extra argument holds the file
* descriptor to write the output to. This function can only be used with
* the "new" libterm interface.
*/
int
__cputwchar_args(wchar_t wch, void *args)
{
FILE *outfd = (FILE *) args;
return putwc(wch, outfd);
}
static void
tabulate(wchar_t line[])
{
wchar_t *cp;
int b, t;
/* Toss trailing blanks in the output line */
cp = line + wslen(line) - 1;
while (cp >= line && *cp == L' ')
cp--;
*++cp = L'\0';
/* Count the leading blank space and tabulate */
for (cp = line; *cp == L' '; cp++);
b = cp - line;
t = b >> 3;
b &= 07;
if (t > 0)
do
putc('\t', stdout);
while (--t);
if (b > 0)
do
putc(' ', stdout);
while (--b);
while (*cp)
putwc(*cp++, stdout);
putc('\n', stdout);
}
static void good1()
{
/* FIX: check for the correct return value */
if (putwc((wchar_t)L'A', stdout) == WEOF)
{
printLine("putwc failed!");
}
}
void CWE252_Unchecked_Return_Value__wchar_t_putc_09_bad()
{
if(GLOBAL_CONST_TRUE)
{
/* FLAW: Do not check the return value */
putwc((wchar_t)L'A', stdout);
}
}
void CWE252_Unchecked_Return_Value__wchar_t_putc_07_bad()
{
if(staticFive==5)
{
/* FLAW: Do not check the return value */
putwc((wchar_t)L'A', stdout);
}
}
void CWE253_Incorrect_Check_of_Function_Return_Value__wchar_t_putc_01_bad()
{
/* FLAW: putwc() might fail, in which case the return value will be EOF (-1), but
* we are checking to see if the return value is 0 */
if (putwc((wchar_t)L'A', stdout) == 0)
{
printLine("putwc failed!");
}
}
//##############################################################################
//# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
//##############################################################################
//##############################################################################
//# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
//##############################################################################
void xSystem::xSTDWriter::writeChar(xchar c) throw(xIOException)
{
#ifndef XTK_UNICODE
if(putchar(c) == EOF)
throw xIOException(_T("Error writing to stdout"));
#else
if(putwc(c,stdout) == WEOF)
throw xIOException(_T("Error writing to stdout"));
#endif
}
/* good2() reverses the bodies in the if statement */
static void good2()
{
if(staticFive==5)
{
/* FIX: check the return value */
if (putwc((wchar_t)L'A', stdout) == WEOF)
{
printLine("putwc failed!");
}
}
}
/* good2() reverses the bodies in the if statement */
static void good2()
{
if(GLOBAL_CONST_TRUE)
{
/* FIX: check the return value */
if (putwc((wchar_t)L'A', stdout) == WEOF)
{
printLine("putwc failed!");
}
}
}
static int
wpadn (FILE *fp, wint_t pad, int count)
{
int i;
int written = 0;
for (i=0;i<count;i++)
if(putwc(pad,fp) != WEOF)
written++;
return written;
}
static void
sbcl_putwc(wchar_t c, FILE *file)
{
#ifdef LISP_FEATURE_OS_PROVIDES_PUTWC
putwc(c, file);
#else
if (c < 256) {
fputc(c, file);
} else {
fputc('?', file);
}
#endif
}
bool FileStdStream::PutC(int nChar)
{
#ifdef WIN32
// Write character
if (IsWritable())
return ((m_nStringFormat == String::ASCII) ? putc(nChar, m_pFile) : putwc(static_cast<wchar_t>(nChar), m_pFile)) != 0;
// Error!
return false;
#else
// Write character
return (m_pFile && IsWritable() && putc(nChar, m_pFile) != EOF);
#endif
}
void CWE252_Unchecked_Return_Value__wchar_t_putc_15_bad()
{
switch(6)
{
case 6:
/* FLAW: Do not check the return value */
putwc((wchar_t)L'A', stdout);
break;
default:
/* INCIDENTAL: CWE 561 Dead Code, the code below will never run */
printLine("Benign, fixed string");
break;
}
}
void ntfsStrDump(const uint16_t* bytes, uint8_t length)
{
uint8_t i;
for (i=0; i<length; i++)
{
if (bytes[i] > 255)
{
ntfsDebug(L"\nWarning: non printable character: 0x%04x \n",bytes[i]);
continue;
}
putwc(bytes[i], stdout);
}
}
/* good1() uses if(GLOBAL_CONST_FALSE) instead of if(GLOBAL_CONST_TRUE) */
static void good1()
{
if(GLOBAL_CONST_FALSE)
{
/* INCIDENTAL: CWE 561 Dead Code, the code below will never run */
printLine("Benign, fixed string");
}
else
{
/* FIX: check the return value */
if (putwc((wchar_t)L'A', stdout) == WEOF)
{
printLine("putwc failed!");
}
}
}
/* good2() reverses the blocks in the switch */
static void good2()
{
switch(6)
{
case 6:
/* FIX: check the return value */
if (putwc((wchar_t)L'A', stdout) == WEOF)
{
printLine("putwc failed!");
}
break;
default:
/* INCIDENTAL: CWE 561 Dead Code, the code below will never run */
printLine("Benign, fixed string");
break;
}
}
void config_loader( void ) {
size_t readed, offset = 0;
FILE * f;
f = fopen( "../config.cfg", "rb" );
if ( f == NULL ) {
perror( "fopen" );
exit( 0 );
}
memset( &lang, 0, sizeof( lang_t ) );
fread( &config, sizeof( config_t ), 1, f );
filename = (char *) calloc( config.name_size + 1, sizeof( char ) );
fread( filename, config.name_size, 1, f );
fprintf( stderr, "filename = %s (%d)\n", filename, config.name_size );
fprintf( stderr, "WxH = %dx%d", config.img_width, config.img_height );
offset += 3 * sizeof( u32 ) + config.name_size;
do {
fseek( f, offset, SEEK_SET );
fprintf( stderr, "\n\noffset = %d\n", offset );
readed = fread( &lang, sizeof( lang_t ), 1, f );
fprintf( stderr, "readed = %d\n", readed );
fprintf( stderr, "unicode = %d\n", lang.unicode );
fprintf( stderr, "abc_size = %d\n", lang.size );
if ( lang.unicode > 1 ) {
break;
}
size_t read_size = lang.unicode ? 2 : 1;
fprintf( stderr, "read_size = %d\n", read_size );
// 5 -- header sizem
for ( size_t i = lang.size - 5; i; i-- ) {
wchar_t tmp = 0;
fread( &tmp, read_size, 1, f );
if ( lang.unicode ) {
tmp = swap16( tmp );
}
putwc( tmp, stderr ); // ?
stack_push( tmp );
}
offset += lang.size;
} while ( readed != 0 || !feof( f ) );
fclose( f );
}
int main()
{
mbstate_t mb = {0};
size_t s = 0;
tm tm = {0};
wint_t w = 0;
::FILE* fp = 0;
__darwin_va_list va;
char* ns = 0;
wchar_t* ws = 0;
static_assert((std::is_same<decltype(fwprintf(fp, L"")), int>::value), "");
static_assert((std::is_same<decltype(fwscanf(fp, L"")), int>::value), "");
static_assert((std::is_same<decltype(swprintf(ws, s, L"")), int>::value), "");
static_assert((std::is_same<decltype(swscanf(L"", L"")), int>::value), "");
static_assert((std::is_same<decltype(vfwprintf(fp, L"", va)), int>::value), "");
static_assert((std::is_same<decltype(vfwscanf(fp, L"", va)), int>::value), "");
static_assert((std::is_same<decltype(vswprintf(ws, s, L"", va)), int>::value), "");
static_assert((std::is_same<decltype(vswscanf(L"", L"", va)), int>::value), "");
static_assert((std::is_same<decltype(vwprintf(L"", va)), int>::value), "");
static_assert((std::is_same<decltype(vwscanf(L"", va)), int>::value), "");
static_assert((std::is_same<decltype(wprintf(L"")), int>::value), "");
static_assert((std::is_same<decltype(wscanf(L"")), int>::value), "");
static_assert((std::is_same<decltype(fgetwc(fp)), wint_t>::value), "");
static_assert((std::is_same<decltype(fgetws(ws, 0, fp)), wchar_t*>::value), "");
static_assert((std::is_same<decltype(fputwc(L' ', fp)), wint_t>::value), "");
static_assert((std::is_same<decltype(fputws(L"", fp)), int>::value), "");
static_assert((std::is_same<decltype(fwide(fp, 0)), int>::value), "");
static_assert((std::is_same<decltype(getwc(fp)), wint_t>::value), "");
static_assert((std::is_same<decltype(getwchar()), wint_t>::value), "");
static_assert((std::is_same<decltype(putwc(L' ', fp)), wint_t>::value), "");
static_assert((std::is_same<decltype(putwchar(L' ')), wint_t>::value), "");
static_assert((std::is_same<decltype(ungetwc(L' ', fp)), wint_t>::value), "");
static_assert((std::is_same<decltype(wcstod(L"", (wchar_t**)0)), double>::value), "");
static_assert((std::is_same<decltype(wcstof(L"", (wchar_t**)0)), float>::value), "");
static_assert((std::is_same<decltype(wcstold(L"", (wchar_t**)0)), long double>::value), "");
static_assert((std::is_same<decltype(wcstol(L"", (wchar_t**)0, 0)), long>::value), "");
static_assert((std::is_same<decltype(wcstoll(L"", (wchar_t**)0, 0)), long long>::value), "");
static_assert((std::is_same<decltype(wcstoul(L"", (wchar_t**)0, 0)), unsigned long>::value), "");
static_assert((std::is_same<decltype(wcstoull(L"", (wchar_t**)0, 0)), unsigned long long>::value), "");
static_assert((std::is_same<decltype(wcscpy(ws, L"")), wchar_t*>::value), "");
static_assert((std::is_same<decltype(wcsncpy(ws, L"", s)), wchar_t*>::value), "");
static_assert((std::is_same<decltype(wcscat(ws, L"")), wchar_t*>::value), "");
static_assert((std::is_same<decltype(wcsncat(ws, L"", s)), wchar_t*>::value), "");
static_assert((std::is_same<decltype(wcscmp(L"", L"")), int>::value), "");
static_assert((std::is_same<decltype(wcscoll(L"", L"")), int>::value), "");
static_assert((std::is_same<decltype(wcsncmp(L"", L"", s)), int>::value), "");
static_assert((std::is_same<decltype(wcsxfrm(ws, L"", s)), size_t>::value), "");
static_assert((std::is_same<decltype(wcschr((wchar_t*)0, L' ')), wchar_t*>::value), "");
static_assert((std::is_same<decltype(wcscspn(L"", L"")), size_t>::value), "");
static_assert((std::is_same<decltype(wcslen(L"")), size_t>::value), "");
static_assert((std::is_same<decltype(wcspbrk((wchar_t*)0, L"")), wchar_t*>::value), "");
static_assert((std::is_same<decltype(wcsrchr((wchar_t*)0, L' ')), wchar_t*>::value), "");
static_assert((std::is_same<decltype(wcsspn(L"", L"")), size_t>::value), "");
static_assert((std::is_same<decltype(wcsstr((wchar_t*)0, L"")), wchar_t*>::value), "");
static_assert((std::is_same<decltype(wcstok(ws, L"", (wchar_t**)0)), wchar_t*>::value), "");
static_assert((std::is_same<decltype(wmemchr((wchar_t*)0, L' ', s)), wchar_t*>::value), "");
static_assert((std::is_same<decltype(wmemcmp(L"", L"", s)), int>::value), "");
static_assert((std::is_same<decltype(wmemcpy(ws, L"", s)), wchar_t*>::value), "");
static_assert((std::is_same<decltype(wmemmove(ws, L"", s)), wchar_t*>::value), "");
static_assert((std::is_same<decltype(wmemset(ws, L' ', s)), wchar_t*>::value), "");
static_assert((std::is_same<decltype(wcsftime(ws, s, L"", &tm)), size_t>::value), "");
static_assert((std::is_same<decltype(btowc(0)), wint_t>::value), "");
static_assert((std::is_same<decltype(wctob(w)), int>::value), "");
static_assert((std::is_same<decltype(mbsinit(&mb)), int>::value), "");
static_assert((std::is_same<decltype(mbrlen("", s, &mb)), size_t>::value), "");
static_assert((std::is_same<decltype(mbrtowc(ws, "", s, &mb)), size_t>::value), "");
static_assert((std::is_same<decltype(wcrtomb(ns, L' ', &mb)), size_t>::value), "");
static_assert((std::is_same<decltype(mbsrtowcs(ws, (const char**)0, s, &mb)), size_t>::value), "");
static_assert((std::is_same<decltype(wcsrtombs(ns, (const wchar_t**)0, s, &mb)), size_t>::value), "");
}
int
main(int argc, char **argv)
{
register int ct, first, last;
register wint_t c;
int i, w;
int padding;
setlocale(LC_ALL, "");
first = 0;
last = 0;
if (argc > 1)
first = atoi(*++argv);
if (argc > 2)
last = atoi(*++argv);
start:
ct = 0;
loop1:
c = getwc(stdin);
if (c == WEOF)
goto fin;
if (c == '\t')
w = ((ct + 8) & ~7) - ct;
else if (c == '\b')
w = (ct ? ct - 1 : 0) - ct;
else {
w = wcwidth(c);
if (w < 0)
w = 0;
}
ct += w;
if (c == '\n') {
putwc(c, stdout);
goto start;
}
if (!first || ct < first) {
putwc(c, stdout);
goto loop1;
}
for (i = ct-w+1; i < first; i++)
putwc(' ', stdout);
/* Loop getting rid of characters */
while (!last || ct < last) {
c = getwc(stdin);
if (c == WEOF)
goto fin;
if (c == '\n') {
putwc(c, stdout);
goto start;
}
if (c == '\t')
ct = (ct + 8) & ~7;
else if (c == '\b')
ct = ct ? ct - 1 : 0;
else {
w = wcwidth(c);
if (w < 0)
w = 0;
ct += w;
}
}
padding = 0;
/* Output last of the line */
for (;;) {
c = getwc(stdin);
if (c == WEOF)
break;
if (c == '\n') {
putwc(c, stdout);
goto start;
}
if (padding == 0 && last < ct) {
for (i = last; i <ct; i++)
putwc(' ', stdout);
padding = 1;
}
putwc(c, stdout);
}
fin:
fflush(stdout);
if (ferror(stdout) || fclose(stdout))
return 1;
return 0;
}
void
makemsg(char *fname)
{
int cnt;
wchar_t ch;
struct tm *lt;
struct passwd *pw;
struct stat sbuf;
time_t now;
FILE *fp;
int fd;
char hostname[MAXHOSTNAMELEN], tmpname[64];
wchar_t *p, *tmp, lbuf[256], codebuf[13];
const char *tty;
const char *whom;
gid_t egid;
(void)snprintf(tmpname, sizeof(tmpname), "%s/wall.XXXXXX", _PATH_TMP);
if ((fd = mkstemp(tmpname)) == -1 || !(fp = fdopen(fd, "r+")))
err(1, "can't open temporary file");
(void)unlink(tmpname);
if (!nobanner) {
tty = ttyname(STDERR_FILENO);
if (tty == NULL)
tty = "no tty";
if (!(whom = getlogin()))
whom = (pw = getpwuid(getuid())) ? pw->pw_name : "???";
(void)gethostname(hostname, sizeof(hostname));
(void)time(&now);
lt = localtime(&now);
/*
* all this stuff is to blank out a square for the message;
* we wrap message lines at column 79, not 80, because some
* terminals wrap after 79, some do not, and we can't tell.
* Which means that we may leave a non-blank character
* in column 80, but that can't be helped.
*/
(void)fwprintf(fp, L"\r%79s\r\n", " ");
(void)swprintf(lbuf, sizeof(lbuf)/sizeof(wchar_t),
L"Broadcast Message from %s@%s",
whom, hostname);
(void)fwprintf(fp, L"%-79.79S\007\007\r\n", lbuf);
(void)swprintf(lbuf, sizeof(lbuf)/sizeof(wchar_t),
L" (%s) at %d:%02d %s...", tty,
lt->tm_hour, lt->tm_min, lt->tm_zone);
(void)fwprintf(fp, L"%-79.79S\r\n", lbuf);
}
(void)fwprintf(fp, L"%79s\r\n", " ");
if (fname) {
egid = getegid();
setegid(getgid());
if (freopen(fname, "r", stdin) == NULL)
err(1, "can't read %s", fname);
if (setegid(egid) != 0)
err(1, "setegid failed");
}
cnt = 0;
while (fgetws(lbuf, sizeof(lbuf)/sizeof(wchar_t), stdin)) {
for (p = lbuf; (ch = *p) != L'\0'; ++p, ++cnt) {
if (ch == L'\r') {
putwc(L'\r', fp);
cnt = 0;
continue;
} else if (ch == L'\n') {
for (; cnt < 79; ++cnt)
putwc(L' ', fp);
putwc(L'\r', fp);
putwc(L'\n', fp);
break;
}
if (cnt == 79) {
putwc(L'\r', fp);
putwc(L'\n', fp);
cnt = 0;
}
if (iswprint(ch) || iswspace(ch) || ch == L'\a' || ch == L'\b') {
putwc(ch, fp);
} else {
(void)swprintf(codebuf, sizeof(codebuf)/sizeof(wchar_t), L"<0x%X>", ch);
for (tmp = codebuf; *tmp != L'\0'; ++tmp) {
putwc(*tmp, fp);
if (++cnt == 79) {
putwc(L'\r', fp);
putwc(L'\n', fp);
cnt = 0;
}
}
--cnt;
}
}
}
(void)fwprintf(fp, L"%79s\r\n", " ");
rewind(fp);
if (fstat(fd, &sbuf))
err(1, "can't stat temporary file");
mbufsize = sbuf.st_size;
if (!(mbuf = malloc((u_int)mbufsize)))
err(1, "out of memory");
if ((int)fread(mbuf, sizeof(*mbuf), mbufsize, fp) != mbufsize)
err(1, "can't read temporary file");
(void)close(fd);
}
/*
* @implemented
*/
wint_t
fputwc(wchar_t c, FILE *fp)
{
return putwc(c,fp);
}
int process_input(unsigned long first, unsigned long last)
{
unsigned long ct = 0;
wint_t c;
unsigned long i;
int w;
int padding;
for (;;) {
c = getwc(stdin);
if (c == WEOF)
return 0;
if (c == '\t')
w = ((ct + 8) & ~7) - ct;
else if (c == '\b')
w = (ct ? ct - 1 : 0) - ct;
else {
w = wcwidth(c);
if (w < 0)
w = 0;
}
ct += w;
if (c == '\n') {
putwc(c, stdout);
ct = 0;
continue;
}
if (!first || ct < first) {
putwc(c, stdout);
continue;
}
break;
}
for (i = ct - w + 1; i < first; i++)
putwc(' ', stdout);
/* Loop getting rid of characters */
while (!last || ct < last) {
c = getwc(stdin);
if (c == WEOF)
return 0;
if (c == '\n') {
putwc(c, stdout);
return 1;
}
if (c == '\t')
ct = (ct + 8) & ~7;
else if (c == '\b')
ct = ct ? ct - 1 : 0;
else {
w = wcwidth(c);
if (w < 0)
w = 0;
ct += w;
}
}
padding = 0;
/* Output last of the line */
for (;;) {
c = getwc(stdin);
if (c == WEOF)
break;
if (c == '\n') {
putwc(c, stdout);
return 1;
}
if (padding == 0 && last < ct) {
for (i = last; i < ct; i++)
putwc(' ', stdout);
padding = 1;
}
putwc(c, stdout);
}
return 0;
}
int
__cputwchar(wchar_t wch)
{
return (putwc(wch, _cursesi_screen->outfd));
}
int main(int argc, char **argv)
{
int ret;
setlocale(LC_ALL, "");
if (argc != 3) {
wprintf(L"Usage: psafe file.psafe3 passphrase");
exit(EXIT_FAILURE);
}
init_crypto(64*1024);
size_t sz;
uint8_t *ptr;
ptr = mapfile_ro(argv[1], &sz);
if (ptr == NULL)
err(1, "%s", argv[1]);
struct psafe3_pro *pro;
pro = (struct psafe3_pro *)(ptr + 4);
struct safe_sec *sec;
sec = gcry_malloc_secure(sizeof(*sec));
ret = stretch_and_check_pass(argv[2], strlen(argv[2]), pro, sec);
if (ret != 0) {
gcry_free(sec);
wprintf(L"Invalid password.\n");
exit(1);
}
uint8_t *safe;
size_t safe_size;
safe_size = sz - (4 + sizeof(*pro) + 48);
assert(safe_size > 0);
assert(safe_size % TWOF_BLKSIZE == 0);
safe = gcry_malloc_secure(safe_size);
assert(safe != NULL);
gcry_error_t gerr;
struct decrypt_ctx ctx;
if (init_decrypt_ctx(&ctx, pro, sec) < 0)
gcrypt_fatal(ctx.gerr);
size_t bcnt;
bcnt = safe_size / TWOF_BLKSIZE;
assert(bcnt > 0);
uint8_t *encp;
uint8_t *safep;
encp = ptr + 4 + sizeof(*pro);
safep = safe;
while (bcnt--) {
gerr = gcry_cipher_decrypt(ctx.cipher, safep, TWOF_BLKSIZE, encp, TWOF_BLKSIZE);
if (gerr != GPG_ERR_NO_ERROR)
gcrypt_fatal(gerr);
safep += TWOF_BLKSIZE;
encp += TWOF_BLKSIZE;
}
enum { HDR, DB };
int state = HDR;
safep = safe;
while (safep < safe + safe_size) {
struct field *fld;
fld = (struct field *)safep;
wprintf(L"len=%-3u type=%02x ", fld->len, fld->type);
if (state == DB)
db_print(stdout, fld);
else
hd_print(stdout, fld);
if (fld->type == 0xff)
state = DB;
putwc('\n', stdout);
if (fld->len)
gcry_md_write(ctx.hmac, safep + sizeof(*fld), fld->len);
safep += ((fld->len + 5 + 15) / TWOF_BLKSIZE) * TWOF_BLKSIZE;
}
assert(memcmp(ptr + (sz - 48), "PWS3-EOFPWS3-EOF", TWOF_BLKSIZE) == 0);
#define EOL() putwc('\n', stdout)
EOL();
print_prologue(stdout, pro);
wprintf(L"KEY "); printhex(stdout, sec->pprime, 32); EOL();
wprintf(L"H(KEY) "); printhex(stdout, pro->h_pprime, 32); EOL();
gcry_md_final(ctx.hmac);
wprintf(L"HMAC' ");
uint8_t hmac[32];
memmove(hmac, gcry_md_read(ctx.hmac, GCRY_MD_SHA256), 32);
printhex(stdout, hmac, 32);
EOL();
wprintf(L"HMAC ");
printhex(stdout, ptr + (sz - 32), 32);
EOL();
#undef EOL
gcry_free(safe);
gcry_free(sec);
unmapfile(ptr, sz);
term_decrypt_ctx(&ctx);
exit(0);
}
wint_t __cdecl _fputwchar (
REG1 wchar_t ch
)
{
return(putwc(ch, stdout));
}
/*
* @implemented
*/
int _fputwchar(wchar_t c)
{
return putwc(c, stdout);
}
/* put out other arrays, copy the parsers */
static void
others()
{
extern int gen_lines;
int c, i, j;
int tmpline;
finput = fopen(parser, "r");
if (finput == NULL)
/*
* TRANSLATION_NOTE -- This is a message from yacc.
* This message is passed to error() function.
* This error message is issued when yacc can not find
* the parser to be copied.
*/
error(gettext(
"cannot find parser %s"),
parser);
warray(L"yyr1", levprd, nprod);
aryfil(temp1, nprod, 0);
/* had_act[i] is either 1 or 0 */
PLOOP(1, i)
temp1[i] = ((prdptr[i+1] - prdptr[i]-2) << 1) | had_act[i];
warray(L"yyr2", temp1, nprod);
aryfil(temp1, nstate, -10000000);
TLOOP(i)
for (j = tstates[i]; j != 0; j = mstates[j])
temp1[j] = tokset[i].value;
NTLOOP(i)
for (j = ntstates[i]; j != 0; j = mstates[j])
temp1[j] = -i;
warray(L"yychk", temp1, nstate);
warray(L"yydef", defact, nstate);
if ((fdebug = fopen(DEBUGNAME, "r")) == NULL)
error("cannot open yacc.debug");
while ((c = getwc(fdebug)) != EOF)
(void) putwc(c, ftable);
(void) fclose(fdebug);
ZAPFILE(DEBUGNAME);
if (gen_lines)
(void) fprintf(ftable, "# line\t1 \"%s\"\n", parser);
tmpline = 1;
/* copy parser text */
while ((c = getwc(finput)) != EOF) {
if (c == '\n')
tmpline++;
if (c == L'$') {
if ((c = getwc(finput)) != L'A')
(void) putwc(L'$', ftable);
else { /* copy actions */
tmpline++;
faction = fopen(ACTNAME, "r");
if (faction == NULL)
/*
* TRANSLATION_NOTE -- This is a message from yacc.
* This message is passed to error() function.
* This error is issued when yacc can not open a
* temporary file to be used. You do not need to
* use the word 'tempfile'. You can translate it to
* mean 'temporary file'.
*/
error(gettext(
"cannot open action tempfile"));
while ((c = getwc(faction)) != EOF)
(void) putwc(c, ftable);
(void) fclose(faction);
if (gen_lines)
(void) fprintf(ftable,
"\n# line\t%d \"%s\"",
tmpline,
parser);
ZAPFILE(ACTNAME);
c = getwc(finput);
}
}
(void) putwc(c, ftable);
}
(void) fclose(ftable);
}