예제 #1
0
파일: a-lib.c 프로젝트: asampal/ren-c
*/ RL_API REBYTE *RL_Word_String(u32 word)
/*
**	Return a string related to a given global word identifier.
**
**	Returns:
**		A copy of the word string, null terminated.
**	Arguments:
**		word - a global word identifier
**	Notes:
**		The result is a null terminated copy of the name for your own use.
**		The string is always UTF-8 encoded (chars > 127 are encoded.)
**		In this API, word identifiers are always canonical. Therefore,
**		the returned string may have different spelling/casing than expected.
**		The string is allocated with OS_ALLOC and you can OS_FREE it any time.
**
***********************************************************************/
{
	REBYTE *s1, *s2;
	// !!This code should use a function from c-words.c (but nothing perfect yet.)
	if (word == 0 || word >= PG_Word_Table.series->tail) return 0;
	s1 = VAL_SYM_NAME(BLK_SKIP(PG_Word_Table.series, word));
	s2 = OS_ALLOC_ARRAY(REBYTE, LEN_BYTES(s1) + 1);
	COPY_BYTES(s2, s1, LEN_BYTES(s1) + 1);
	return s2;
}
예제 #2
0
파일: a-lib.c 프로젝트: kjanz1899/ren-c
//
//  RL_Word_String: C
// 
// Return a string related to a given global word identifier.
// 
// Returns:
//     A copy of the word string, null terminated.
// Arguments:
//     word - a global word identifier
// Notes:
//     The result is a null terminated copy of the name for your own use.
//     The string is always UTF-8 encoded (chars > 127 are encoded.)
//     In this API, word identifiers are always canonical. Therefore,
//     the returned string may have different spelling/casing than expected.
//     The string is allocated with OS_ALLOC and you can OS_FREE it any time.
//
RL_API REBYTE *RL_Word_String(u32 word)
{
    REBYTE *s1, *s2;
    // !!This code should use a function from c-words.c (but nothing perfect yet.)
    if (word == 0 || word >= ARR_LEN(PG_Word_Table.array)) return 0;
    s1 = VAL_SYM_NAME(ARR_AT(PG_Word_Table.array, word));
    s2 = OS_ALLOC_N(REBYTE, LEN_BYTES(s1) + 1);
    COPY_BYTES(s2, s1, LEN_BYTES(s1) + 1);
    return s2;
}
예제 #3
0
파일: host-stdio.c 프로젝트: mbk/ren-c
static REBYTE *Get_Next_Line()
{
	REBYTE *bp = inbuf;
	REBYTE *out;
	REBCNT len;

	// Scan for line terminator or end:
	for (bp = inbuf; *bp != CR && *bp != LF && *bp != 0; bp++);

	// If found, copy the line and remove it from buffer:
	if (*bp) {
		if (*bp == CR && bp[1] == LF) bp++;
		len = bp - inbuf;
		out = OS_ALLOC_ARRAY(REBYTE, len + 2);
		COPY_BYTES(out, inbuf, len+1);
		out[len+1] = 0;
		memmove(inbuf, bp + 1, 1 + LEN_BYTES(bp + 1));
		return out;
	}

	return 0; // more input needed
}
예제 #4
0
파일: dev-file.c 프로젝트: Oldes/R3A110
*/	static int Read_Directory(REBREQ *dir, REBREQ *file)
/*
**		This function will read a file directory, one file entry
**		at a time, then close when no more files are found.
**
**	Procedure:
**
**		This function is passed directory and file arguments.
**		The dir arg provides information about the directory to read.
**		The file arg is used to return specific file information.
**
**		To begin, this function is called with a dir->handle that
**		is set to zero and a dir->file.path string for the directory.
**
**		The directory is opened and a handle is stored in the dir
**		structure for use on subsequent calls. If an error occurred,
**		dir->error is set to the error code and -1 is returned.
**		The dir->size field can be set to the number of files in the
**		dir, if it is known. The dir->file.index field can be used by this
**		function to store information between calls.
**
**		If the open succeeded, then information about the first file
**		is stored in the file argument and the function returns 0.
**		On an error, the dir->error is set, the dir is closed,
**		dir->handle is nulled, and -1 is returned.
**
**		The caller loops until all files have been obtained. This
**		action should be uninterrupted. (The caller should not perform
**		additional OS or IO operations between calls.)
**
**		When no more files are found, the dir is closed, dir->handle
**		is nulled, and 1 is returned. No file info is returned.
**		(That is, this function is called one extra time. This helps
**		for OSes that may deallocate file strings on dir close.)
**
**		Note that the dir->file.path can contain wildcards * and ?. The
**		processing of these can be done in the OS (if supported) or
**		by a separate filter operation during the read.
**
**		Store file date info in file->file.index or other fields?
**		Store permissions? Ownership? Groups? Or, require that
**		to be part of a separate request?
**
***********************************************************************/
{
	struct stat info;
	struct dirent *d;
	char *cp;
	DIR *h;
	int n;

	// Remove * from tail, if present. (Allowed because the
	// path was copied into to-local-path first).
	n = strlen(cp = dir->file.path);
	if (n > 0 && cp[n-1] == '*') cp[n-1] = 0;

	// If no dir handle, open the dir:
	if (!(h = dir->handle)) {
		h = opendir(dir->file.path);
		if (!h) {
			dir->error = errno;
			return DR_ERROR;
		}
		dir->handle = h;
		CLR_FLAG(dir->flags, RRF_DONE);
	}

	// Get dir entry (skip over the . and .. dir cases):
	do {
		// Read next file entry or error:
		if (!(d = readdir(h))) {
			//dir->error = errno;
			closedir(h);
			dir->handle = 0;
			//if (dir->error) return DR_ERROR;
			SET_FLAG(dir->flags, RRF_DONE); // no more files
			return DR_DONE;
		}
		cp = d->d_name;
	} while (cp[0] == '.' && (cp[1] == 0 || cp[1] == '.'));

	file->modes = 0;
	COPY_BYTES(file->file.path, cp, MAX_FILE_NAME);

	// NOTE: not all posix filesystems support this (mainly
	// the Linux and BSD support it.) If this fails to build, a
	// different mechanism must be used. However, this is the
	// most efficient, because it does not require a separate
	// file system call for determining directories.
	if (d->d_type == DT_DIR) SET_FLAG(file->modes, RFM_DIR);

	// Line below DOES NOT WORK -- because we need full path.
	//Get_File_Info(file); // updates modes, size, time

	return DR_DONE;
}
예제 #5
0
파일: Write.c 프로젝트: GnoConsortium/gno
KS_E_ERROR ks_file_write(KS_FILE_PTR file_ptr,
                         LongWord position,
                         LongWord data_size,
                         Pointer data_buffer)
{
    /* ************************************************************** *
     *  Local declarations:                                           *
     * ************************************************************** */

    KS_E_ERROR   error;            /* Holds error codes for subroutine*/
                                   /*  calls                          */
    LongWord     data_offset;      /* Offset into the buffer to return*/
    LongWord     remaining_space;  /* Space remaining in file buffer  */
    LongWord     buffer_request;   /* Size of each copy from the      */
                                   /*  file buffer                    */


    ROUTINE_ENTER();


    /* ************************************************************** *
     *  Verify the structure ID passed in is the correct one.         *
     * ************************************************************** */

    if (file_ptr->struct_id != KS_FILE_ID)
        {
        KS_ERROR(KS_E_INVALID_STRUCT_ID, KS_FILE_ID);
        };


    /* ************************************************************** *
     *  Zero the number of bytes transfered in the KS_FILE structure. *
     * ************************************************************** */

    file_ptr->data_size = 0;


    /* ************************************************************** *
     *  If there is a buffer, then lets put data into the file buffer.*
     * ************************************************************** */

    if (file_ptr->buffer_size != NULL)
        {

        /* ********************************************************** *
         *  Loop till we satisfy the request (or take an error)       *
         * ********************************************************** */

        data_offset = 0;

        while (data_size > 0)
            {

            /* ****************************************************** *
             *  Calculate the remaining space in the buffer.  If      *
             *  there is any space left in the buffer then lets copy  *
             *  as much as we need to into the file buffer.           *
             * ****************************************************** */

            remaining_space = (file_ptr->buffer_available) -
                              (file_ptr->buffer_offset);

            if (remaining_space > 0)
                {
                buffer_request = MIN(data_size,
                                     remaining_space);

                COPY_BYTES(data_buffer,
                           data_offset,
                           file_ptr->buffer,
                           file_ptr->buffer_offset,
                           buffer_request);

                /* ************************************************** *
                 *  Now modify the parameters of the buffers by:      *
                 *                                                    *
                 *  1) Adding the size of the request to the file     *
                 *  buffer ofset and the data offset (IE: Indices to  *
                 *  the file buffer and the read request buffer).     *
                 *                                                    *
                 *  2) Subtracting the request size from the read     *
                 *  request size and the remaining number of          *
                 *  characters in the file buffer.                    *
                 * ************************************************** */

                file_ptr->buffer_offset = file_ptr->buffer_offset +
                                          buffer_request;

                data_offset = data_offset + buffer_request;

                file_ptr->data_size = data_offset; 

                data_size = data_size - buffer_request;

                remaining_space = remaining_space - buffer_request;
                };


            /* ****************************************************** *
             *  If the file buffer is full, then we have to write it  *
             *  to disk.  The problem is that the buffer size may     *
             *  have changed due to what our user wants (users are    *
             *  bound to be the end of all computing...).  This means *
             *  that we'll junp through a few hoops if we must change *
             *  buffer sizes - so expect some weirdness here.         *
             * ****************************************************** */

            if (remaining_space == 0)
                {

                /* ************************************************** *
                 *  Issue a Read to the file into our buffer.         *
                 * ************************************************** */

                KSf_pkts.IO.pCount = 4;
                KSf_pkts.IO.refNum = file_ptr->refNum;
                KSf_pkts.IO.dataBuffer = TO_POINTER(file_ptr->buffer);
                KSf_pkts.IO.requestCount = file_ptr->buffer_size;

                WriteGS(&KSf_pkts.IO);

                if ((error = GET_ERROR()) != KS_E_SUCCESS)
                    {
                    goto EXIT_NOW;
                    };

                file_ptr->buffer_available = file_ptr->buffer_size;
                file_ptr->buffer_offset = 0;


                /* ************************************************** *
                 *  This is the above mentioned weirdness - if the    *
                 *  user specified a different size buffer we will    *
                 *  no comply with their wishes.                      *
                 * ************************************************** */

                if (file_ptr->buffer_size != KSf_FileBufferSize)
                    {
                    KS_MEMORY_DEALLOCATE(file_ptr->buffer_handle,
                                         error);

                    if (error != KS_E_SUCCESS)
                        {
                        goto EXIT_NOW;
                        };

                    KS_MEMORY_ALLOCATE(attrFixed + attrLocked,
                                       KSf_FileBufferSize,
                                       BUFFER_USERID,
                                       file_ptr->buffer_handle,
                                       error);

                    if (error != KS_E_SUCCESS)
                        {
                        goto EXIT_NOW;
                        };

                    file_ptr->buffer = (Byte *)
                                         *(file_ptr->buffer_handle);

                    file_ptr->buffer_size = KSf_FileBufferSize;

                    file_ptr->buffer_available = KSf_FileBufferSize;
                    };

                };  /* End if there is no remaining buffer space      */

            };  /* End while there are characters to be read...       */

        KS_SUCCESS();

        };  /* End if we are doing buffer I/O from the file           */




    /* ************************************************************** *
     *  Ok, we've done enough buffering... lets do some real output...*
     *                                                                *
     *  Position the 'mark' (where we will write to) in the file.     *
     *  Note: We'll move the mark only if our user asks us to.        *
     * ************************************************************** */

    if (position != KS_NEXT_FILE_POSITION)
        {
        KSf_pkts.position.pCount = 3;
        KSf_pkts.position.refNum = file_ptr->refNum;
        KSf_pkts.position.base = startPlus;
        KSf_pkts.position.displacement = position;

        SetMarkGS(&KSf_pkts.position);

        if ((error = GET_ERROR()) != KS_E_SUCCESS)
            {
            goto EXIT_NOW;
            };

        };  /* End if we must change the file position                */


    /* ************************************************************** *
     *  Setup the I/O packet and write what our user is asking for.   *
     * ************************************************************** */

    KSf_pkts.IO.pCount = 4;
    KSf_pkts.IO.refNum = file_ptr->refNum;
    KSf_pkts.IO.dataBuffer = data_buffer;
    KSf_pkts.IO.requestCount = data_size;

    WriteGS(&KSf_pkts.IO);

    if ((error = GET_ERROR()) != KS_E_SUCCESS)
        {
        goto EXIT_NOW;
        };


    /* ************************************************************** *
     *  Save the number of bytes transfered in the KS_FILE structure. *
     * ************************************************************** */

    file_ptr->data_size = KSf_pkts.IO.transferCount;


    /* ************************************************************** *
     *  Return the status back to our caller.                         *
     * ************************************************************** */

EXIT_NOW:

    if (error != KS_E_SUCCESS)
        {
        KS_ERROR(error, KS_FILE_ID);
        };

    KS_SUCCESS();

}   /* End of ks_file_write()                                         */
예제 #6
0
파일: d-crash.c 프로젝트: MannyZhong/r3
*/	void Crash(REBINT id, ...)
/*
**		Print a failure message and abort.
**
**		LATIN1 ONLY!! (For now)
**
**		The error is identified by id number, which can reference an
**		error message string in the boot strings block.
**
**		Note that lower level error messages should not attempt to
**		use the %r (mold value) format (uses higher level functions).
**
**		See panics.h for list of crash errors.
**
***********************************************************************/
{
	va_list args;
	REBYTE buf[CRASH_BUF_SIZE];
	REBYTE *msg;
	REBINT n = 0;

	va_start(args, id);

	DISABLE_GC;
	if (Reb_Opts->crash_dump) {
		Dump_Info();
		Dump_Stack(0, 0);
	}

	// "REBOL PANIC #nnn:"
	COPY_BYTES(buf, Crash_Msgs[CM_ERROR], CRASH_BUF_SIZE);
	APPEND_BYTES(buf, " #", CRASH_BUF_SIZE);
	Form_Int(buf + LEN_BYTES(buf), id);
	APPEND_BYTES(buf, ": ", CRASH_BUF_SIZE);

	// "REBOL PANIC #nnn: put error message here"
	// The first few error types only print general error message.
	// Those errors > RP_STR_BASE have specific error messages (from boot.r).
	if      (id < RP_BOOT_DATA) n = CM_DEBUG;
	else if (id < RP_INTERNAL) n = CM_BOOT;
	else if (id < RP_ASSERTS)  n = CM_INTERNAL;
	else if (id < RP_DATATYPE) n = CM_ASSERT;
	else if (id < RP_STR_BASE) n = CM_DATATYPE;
	else if (id > RP_STR_BASE + RS_MAX - RS_ERROR) n = CM_DEBUG;

	// Use the above string or the boot string for the error (in boot.r):
	msg = (REBYTE*)(n >= 0 ? Crash_Msgs[n] : BOOT_STR(RS_ERROR, id - RP_STR_BASE - 1));
	Form_Var_Args(buf + LEN_BYTES(buf), CRASH_BUF_SIZE - 1 - LEN_BYTES(buf), msg, args);

	n = LEN_BYTES(Crash_Msgs[CM_CONTACT]);
	if ((LEN_BYTES(buf) + n) < (CRASH_BUF_SIZE - 1))
		APPEND_BYTES(buf, Crash_Msgs[CM_CONTACT], n);

	// Convert to OS-specific char-type:
#ifdef disable_for_now //OS_WIDE_CHAR   /// win98 does not support it
	{
		REBCHR s1[512];
		REBCHR s2[2000];

		n = TO_OS_STR(s1, Crash_Msgs[CM_ERROR], LEN_BYTES(Crash_Msgs[CM_ERROR]));
		if (n > 0) s1[n] = 0; // terminate
		else OS_EXIT(200); // bad conversion

		n = TO_OS_STR(s2, buf, LEN_BYTES(buf));
		if (n > 0) s2[n] = 0;
		else OS_EXIT(200);

		OS_CRASH(s1, s2);
	}
#else
	OS_CRASH(Crash_Msgs[CM_ERROR], buf);
#endif
}