コード例 #1
0
ファイル: builtin.c プロジェクト: geraldstanje/luci
/**
 * Writes a given LuciStringObj to a LuciFileObj.
 *
 * @param args list of args
 * @param c number of args
 * @returns LuciNilObj
 */
LuciObject *luci_fwrite(LuciObject **args, unsigned int c)
{
    if (c < 2) {
        LUCI_DIE("%s", "Missing parameter to write()\n");
    }

    /* grab the FILE parameter */
    LuciObject *fobj = args[0];
    if (!fobj || (!ISTYPE(fobj, obj_file_t))) {
        LUCI_DIE("%s", "Not a file object\n");
    }

    /* grab string parameter */
    LuciObject *text_obj = args[1];
    if (!text_obj || (!ISTYPE(text_obj, obj_string_t)) ) {
        LUCI_DIE("%s", "Not a string\n");
    }
    char *text = AS_STRING(text_obj)->s;

    if (AS_FILE(fobj)->mode == f_read_m) {
        LUCI_DIE("%s", "Can't write to  It is opened for reading.\n");
    }

    fwrite(text, sizeof(char), strlen(text), AS_FILE(fobj)->ptr);

    return LuciNilObj;
}
コード例 #2
0
ファイル: fs.c プロジェクト: liwei606/OS_proj
Folder* folder_open(FileSystem *fs, Inode *inode) {
    Folder *folder = NULL;
    char *buffer = NULL;
    int offset = 0;
    int i = 0;
    
    folder = (Folder *) malloc(sizeof(Folder));
    file_init(AS_FILE(folder), fs, inode);
    buffer = (char *) malloc(inode->filesize);
    file_get_contents(AS_FILE(folder), buffer);
#ifdef DEBUG
    fprintf(stderr, "folder_open buffer=");
    for (i = 0; i < inode->filesize; ++i) fprintf(stderr, " %x", buffer[i]);
    fprintf(stderr, "\n");
#endif
    folder->nitem = util_readint(buffer, 0);
#ifdef DEBUG
    fprintf(stderr, "folder_open, folder->nitem=%d\n", folder->nitem);
#endif
    folder->items = (FolderItem *) malloc(sizeof(FolderItem) * folder->nitem);
    offset = 4;
    for (i = 0; i < folder->nitem; ++i) {
        int cname_len = 0;
        
        cname_len = util_readint(buffer, offset);
        offset += 4;
        memcpy(folder->items[i].cname, buffer + offset, cname_len);
        folder->items[i].cname[cname_len] = 0;  // make it a string
        offset += cname_len;
        folder->items[i].page_num = util_readint(buffer, offset);
        offset += 4;
    }
    free(buffer);
    return folder;
}
コード例 #3
0
ファイル: filetype.c プロジェクト: geraldstanje/luci
/**
 * Copies a LuciFileObj
 *
 * Marks the copy's 'iscopy' flag to ensure garbage collection
 * never closes a FILE* that is supposed to be open
 *
 * @param o LuciFileObj to copy
 * @returns copy of LuciFileObj
 */
LuciObject *LuciFile_copy(LuciObject *o)
{
    LuciFileObj *f = AS_FILE(o);
    LuciObject *copy = LuciFile_new(f->ptr, f->size, f->mode);
    AS_FILE(copy)->iscopy = true;    /* prevent garbage collector from closing this file */
    return copy;
}
コード例 #4
0
ファイル: builtin.c プロジェクト: geraldstanje/luci
/**
 * Reads the contents of a file into a LuciStringObj.
 *
 * @param args list of args
 * @param c number of args
 * @returns contents of the file from the first arg.
 */
LuciObject *luci_fread(LuciObject **args, unsigned int c)
{
    if (c < 1) {
        LUCI_DIE("%s", "Missing parameter to read()\n");
    }

    LuciObject *fobj = args[0];

    if (!ISTYPE(fobj, obj_file_t)) {
        LUCI_DIE("%s", "Not a file object\n");
    }

    if (AS_FILE(fobj)->mode != f_read_m) {
        LUCI_DIE("%s", "Can't open  It is opened for writing.\n");
    }

    /* seek to file start, we're gonna read the whole thing */
    /* fseek(fobj->ptr, 0, SEEK_SET); */

    long len = AS_FILE(fobj)->size;
    char *read = alloc(len + 1);
    fread(read, sizeof(char), len, AS_FILE(fobj)->ptr);
    read[len] = '\0';

    /* fseek(fobj->ptr, 0, SEEK_SET); */

    LuciObject *ret = LuciString_new(read);

    return ret;
}
コード例 #5
0
ファイル: builtin.c プロジェクト: geraldstanje/luci
/**
 * Asserts that a given LuciObject is equivalent to a boolean True
 *
 * Currently uses C @code assert @endcode , which will exit a program
 * mid-execution if the assertion fails.
 *
 * @param args list of args
 * @param c number of args
 * @returns LuciNilObj
 */
LuciObject *luci_assert(LuciObject **args, unsigned int c)
{
    if (c < 1) {
        LUCI_DIE("%s", "Missing condition parameter to assert()\n");
    }

    LuciObject *item = args[0];

    if (ISTYPE(item, obj_int_t) && !AS_INT(item)->i) {
        LUCI_DIE("%s\n", "Assertion failed");
    } else if (ISTYPE(item, obj_float_t) && !((long)AS_FLOAT(item)->f)) {
        LUCI_DIE("%s\n", "Float assertion failed");
    } else if (ISTYPE(item, obj_string_t)) {
        if (strcmp("", AS_STRING(item)->s) == 0) {
            LUCI_DIE("%s\n", "String assertion failed");
        }
    } else if (ISTYPE(item, obj_list_t) && (AS_LIST(item)->count == 0)) {
        LUCI_DIE("%s\n", "List assertion failed");
    } else if (ISTYPE(item, obj_map_t) && (AS_MAP(item)->count == 0)) {
        LUCI_DIE("%s\n", "Map assertion failed");
    } else if (ISTYPE(item, obj_file_t) && (AS_FILE(item)->ptr)) {
        LUCI_DIE("%s\n", "File assertion failed");
    }
    return LuciNilObj;
}
コード例 #6
0
ファイル: filetype.c プロジェクト: geraldstanje/luci
/**
 * Finalizes a LuciFileObj
 *
 * Closes it's internal C FILE* only if it is not a copy of
 * the original LuciFileObj
 *
 * @param in LuciFileObj
 */
void LuciFile_finalize(LuciObject *in)
{
    LuciFileObj *f = AS_FILE(in);

    if (!f->iscopy) {
        fclose(f->ptr);
    }
}
コード例 #7
0
ファイル: filetype.c プロジェクト: geraldstanje/luci
/**
 * Returns a boolean representation of a LuciFileObj
 *
 * true if the file pointer is not NULL
 *
 * @returns LuciIntObj
 */
LuciObject* LuciFile_asbool(LuciObject *o)
{
    LuciObject *res = LuciNilObj;

    if (AS_FILE(o)->ptr) {
        res = LuciInt_new(true);
    } else {
        res = LuciInt_new(false);
    }
    return res;
}
コード例 #8
0
ファイル: builtin.c プロジェクト: geraldstanje/luci
/**
 * Closes an open LuciFileObj.
 *
 * @param args list of args
 * @param c number of args
 * @returns LuciNilObj
 */
LuciObject *luci_fclose(LuciObject **args, unsigned int c)
{
    if (c < 1) {
        LUCI_DIE("%s", "Missing parameter to close()\n");
    }

    LuciObject *fobj = args[0];

    if (!ISTYPE(fobj, obj_file_t)) {
        LUCI_DIE("%s", "Not a file object\n");
    }

    if (AS_FILE(fobj)->ptr) {
        close_file(AS_FILE(fobj)->ptr);
    }
    /* else, probably already closed (it's NULL) */

    LUCI_DEBUG("%s\n", "Closed file object.");

    return LuciNilObj;
}
コード例 #9
0
ファイル: builtin.c プロジェクト: geraldstanje/luci
/**
 * Reads a line of input from stdin
 *
 * @param args first arg is either NULL or a LuciFileObj
 * @param c if 0, read from stdin. if > 0, read from file.
 * @returns LuciStringObj containing what was read
 */
LuciObject *luci_readline(LuciObject **args, unsigned int c)
{
    size_t lenmax = 64, len = 0;
    int ch;
    FILE *read_from = NULL;
    char *input;

    if (c < 1) {
        LUCI_DEBUG("%s\n", "readline from stdin");
        read_from = stdin;
    }
    else {
        LuciObject *item = args[0];
        if (item && (ISTYPE(item, obj_file_t))) {
            LUCI_DEBUG("%s\n", "readline from file");
            read_from = AS_FILE(item)->ptr;
        }
        else {
            LUCI_DIE("args[0]: %p, type: %s\n", args[0], item->type->type_name);
            LUCI_DIE("%s", "Can't readline from non-file object\n");
        }
    }

    input = alloc(lenmax * sizeof(char));
    if (input == NULL) {
        LUCI_DIE("%s", "Failed to allocate buffer for reading stdin\n");
    }
    do {
        ch = fgetc(read_from);

        if (len >= lenmax) {
            lenmax *= 2;
            if ((input = realloc(input, lenmax * sizeof(char))) == NULL) {
                LUCI_DIE("%s", "Failed to allocate buffer for reading\n");
            }
        }
        input[len++] = (char)ch;
    } while (ch != EOF && ch != '\n');

    if (ch == EOF) {
        LUCI_DEBUG("%s\n", "readline at EOF, returning nil");
        return LuciNilObj;
    }

    /* overwrite the newline or EOF char with a NUL terminator */
    input[--len] = '\0';
    LuciObject *ret = LuciString_new(input);

    LUCI_DEBUG("Read line %s\n", AS_STRING(ret)->s);

    return ret;
}
コード例 #10
0
ファイル: filetype.c プロジェクト: geraldstanje/luci
/**
 * Prints a representation of a LuciFileObj to stdout
 *
 * @param in LuciFileObj to print
 */
void LuciFile_print(LuciObject *in)
{
    switch (AS_FILE(in)->mode) {
        case f_read_m:
            printf("<file 'r'>");
            break;
        case f_write_m:
            printf("<file 'w'>");
            break;
        case f_append_m:
            printf("<file 'a'>");
            break;
        default:
            break;
    }
}
コード例 #11
0
ファイル: fs.c プロジェクト: liwei606/OS_proj
void folder_close(Folder **folder) {
    if (folder && *folder) {
        int len = 0;
        int i = 0;
        char *buffer = NULL;
        int offset = 0;
        
        len = 4;
        for (i = 0; i < (*folder)->nitem; ++i) {
            len += 4;
            len += strlen((*folder)->items[i].cname);
            len += 4;
        }
        buffer = (char *) malloc(len);
        util_writeint(buffer, 0, (*folder)->nitem);
#ifdef DEBUG
        fprintf(stderr, "folder_close, (*folder)->nitem=%d\n", (*folder)->nitem);
#endif
        offset = 4;
        for (i = 0; i < (*folder)->nitem; ++i) {
            int cname_len = 0;
            
            cname_len = (int) strlen((*folder)->items[i].cname);
            util_writeint(buffer, offset, cname_len);
            offset += 4;
            memcpy(buffer + offset, (*folder)->items[i].cname, cname_len);
            offset += cname_len;
            util_writeint(buffer, offset, (*folder)->items[i].page_num);
            offset += 4;
        }
#ifdef DEBUG
        fprintf(stderr, "offset=%d, len=%d\n", offset, len);
        fprintf(stderr, "folder_close buffer=");
        for (i = 0; i < len; ++i) fprintf(stderr, " %x", buffer[i]);
        fprintf(stderr, "\n");
#endif
        file_put_contents(AS_FILE(*folder), buffer, len);
        free(buffer);
        free((*folder)->items);
        free(*folder);
        *folder = NULL;
    }
}
コード例 #12
0
ファイル: fs2.2.c プロジェクト: liwei606/OS_proj
int fs_mkdir(FileSystem *fs, const char *d) {
    int p = 0;
    Inode *inode = NULL;
    Folder *fd = NULL;
    char ppath[4096] = "";
    char cname[4096] = "";
    Folder *pfd = NULL;
    int parent_page_num = 0;
    
    p = freelist_allocate(fs->freelist);
    if (p <= 1) return ERROR;
    inode = inode_new(p);
    if (!inode) return ERROR;
    inode->type = INODE_FOLDER;
    inode->filesize = 0;
    inode->lastmod = time(NULL);
    inode->firstpage = 0;
    fs_save_inode(fs, inode);
    inode_free(&inode);
    
    fs_split_path(d, ppath, cname);
#ifdef DEBUG
    fprintf(stderr, "fs_mkdir, d=`%s`, ppath=`%s`, cname=`%s`\n", d, ppath, cname);
#endif
    
    pfd = folder_open(fs, folder_lookup(fs, fs->cur, ppath));
    parent_page_num = AS_FILE(pfd)->inode->page_num;
    folder_add_child(pfd, cname, p);
    folder_close(&pfd);
    
    fd = folder_open(fs, fs_load_inode(fs, p));
    fs_split_path(d, ppath, cname);
    folder_add_child(fd, "", ROOT_PAGE_NUM());
    folder_add_child(fd, ".", p);
    folder_add_child(fd, "..", parent_page_num);
    folder_close(&fd);
    return OK;
}
コード例 #13
0
ファイル: filetype.c プロジェクト: geraldstanje/luci
/**
 * Produces a LuciStringObj representation of a LuciFileObj
 *
 * @param o LuciFileObj to represent
 * @returns LuciStringObj representation of o
 */
LuciObject *LuciFile_repr(LuciObject *o)
{
    char *s = alloc(32);
    snprintf(s, 32, "file @ %p", AS_FILE(o)->ptr);
    return LuciString_new(s);
}
コード例 #14
0
ファイル: filetype.c プロジェクト: geraldstanje/luci
/**
 * Returns the size of a LuciFileObj in bytes
 *
 * @param o LuciFileObj
 * @returns LuciIntObj size of file in bytes
 */
LuciObject* LuciFile_len(LuciObject *o)
{
    return LuciInt_new(AS_FILE(o)->size);
}