internal.c

来自「db.* (pronounced dee-be star) is an adva」· C语言 代码 · 共 542 行 · 第 1/2 页

                case ID_LP_SIZE:
                    memcpy(ptr, &task->lp_size, size);
                    break;

                case ID_FP_SIZE:
                    memcpy(ptr, &task->fp_size, size);
                    break;

                case ID_LOCK_PKT:
                    if (task->lock_pkt == NULL)
                        break;

                    memcpy(ptr, &task->lock_pkt[elem], size);
                    break;

                case ID_FREE_PKT:
                    if (task->free_pkt == NULL)
                        break;

                    memcpy(ptr, &task->free_pkt[elem], size);
                    break;

                case ID_FILE_REFS:
                    if (task->file_refs == NULL)
                        break;

                    memcpy(ptr, &task->file_refs[elem], size);
                    break;

                case ID_SESSION_ACTIVE:
                    memcpy(ptr, &task->session_active, size);
                    break;

                case ID_MAX_FILES:
                    num = psp_fileHandleLimit();
                    memcpy(ptr, &num, size);
                    break;

                case ID_MAX_CACHEPGS:
                    if (task->cache == NULL)
                        break;

                    memcpy(ptr, &task->cache->db_pgtab.pgtab_sz, size);
                    break;

                case ID_MAX_OVIXPGS:
                {
                    if (task->cache == NULL)
                        break;

                    memcpy(ptr, &task->cache->ix_pgtab.pgtab_sz, size);
                    break;
                }

                case ID_CACHE_LOOKUP:
                {
                    int tag;
                    unsigned long count = 0;

                    if (task->cache == NULL)
                        break;

                    for (tag=0; tag < task->cache->max_tags; tag++)
                        count += task->cache->tag_table[tag].lookups;

                    memcpy(ptr, &count, size);
                    break;
                }

                case ID_CACHE_HITS:
                {
                    int tag;
                    unsigned long count = 0;

                    if (task->cache == NULL)
                        break;

                    for (tag=0; tag < task->cache->max_tags; tag++)
                        count += task->cache->tag_table[tag].hits;

                    memcpy(ptr, &count, size);
                    break;
                }

                case ID_LOCKCOMM:
                    memcpy(ptr, psp_lmcName(task->lmc), size);
                    break;

                case ID_DBTAF:
                    vtstrncpy(ptr, task->dbtaf, size / sizeof(DB_TCHAR));
                    break;

                case ID_LOCKMGRN:
                    if (task->lockmgrn)
                        vtstrncpy(ptr, task->lockmgrn, size / sizeof(DB_TCHAR));
                    else
                        ((DB_TCHAR *) ptr)[0] = 0;
                    break;

                default:
                    dberr(S_INVID);
                    break;
            }
            break;                  /* end of TOPIC_GLOBAL */

        case TOPIC_TASK:
            memcpy(ptr, task, size);
            break;

        case TOPIC_PGZERO_TABLE:
            if (task->pgzero == NULL)
                break;

            if (elem >= task->size_ft)
                break;      /* need to check because of call to dio_pzread() */

            size = min(size, PGZEROSZ);   /* give only what's on disk */
            stat = task->pgzero[elem].pz_next == 0L;
            if (stat)
                dio_pzread((FILE_NO)elem, task);        /* do a dirty read */

            memcpy(ptr, &task->pgzero[elem], size);
            if (stat)
                task->pgzero[elem].pz_next = 0L;    /* clean up */

            break;

        case TOPIC_FILE_TABLE:
            if (task->file_table == NULL)
                break;

            memcpy(ptr, &task->file_table[elem], size);
            break;

        case TOPIC_RECORD_TABLE:
            if (task->record_table == NULL)
                break;

            memcpy(ptr, &task->record_table[elem], size);
            break;

        case TOPIC_SET_TABLE:
            if (task->set_table == NULL)
                break;

            memcpy(ptr, &task->set_table[elem], size);
            break;

        case TOPIC_MEMBER_TABLE:
            if (task->member_table == NULL)
                break;

            memcpy(ptr, &task->member_table[elem], size);
            break;

        case TOPIC_SORT_TABLE:
            if (task->sort_table == NULL)
                break;

            memcpy(ptr, &task->sort_table[elem], size);
            break;

        case TOPIC_FIELD_TABLE:
            if (task->field_table == NULL)
                break;

            memcpy(ptr, &task->field_table[elem], size);
            break;

        case TOPIC_KEY_TABLE:
            if (task->key_table == NULL)
                break;

            memcpy(ptr, &task->key_table[elem], size);
            break;

        case TOPIC_DB_TABLE:
            if (task->db_table == NULL)
                break;

            memcpy(ptr, &task->db_table[elem], size);
            break;

        case TOPIC_RECORD_NAMES:
            if (task->record_names == NULL || elem >= task->size_rt)
                break;

            vtstrncpy(ptr, task->record_names[elem], size / sizeof(DB_TCHAR));
            break;

        case TOPIC_SET_NAMES:
            if (task->set_names == NULL || elem >= task->size_st)
                break;

            vtstrncpy(ptr, task->set_names[elem], size / sizeof(DB_TCHAR));
            break;

        case TOPIC_FIELD_NAMES:
            if (task->field_names == NULL || elem >= task->size_fd)
                break;

            vtstrncpy(ptr, task->field_names[elem], size / sizeof(DB_TCHAR));
            break;

        case TOPIC_REC_LOCK_TABLE:
            if (task->rec_locks == NULL)
                break;

            memcpy(ptr, &task->rec_locks[elem], size);
            break;

        case TOPIC_SET_LOCK_TABLE:
            if (task->set_locks == NULL)
                break;

            memcpy(ptr, &task->set_locks[elem], size);
            break;

        case TOPIC_KEY_LOCK_TABLE:
            if (task->key_locks == NULL)
                break;

            memcpy(ptr, &task->key_locks[elem], size);
            break;

        case TOPIC_APP_LOCKS_TABLE:
            if (task->app_locks == NULL)
                break;

            memcpy(ptr, &task->app_locks[elem], size);
            break;

        case TOPIC_EXCL_LOCKS_TABLE:
            if (task->excl_locks == NULL)
                break;

            memcpy(ptr, &task->excl_locks[elem], size);
            break;

        case TOPIC_KEPT_LOCKS_TABLE:
            if (task->kept_locks == NULL)
                break;

            memcpy(ptr, &task->kept_locks[elem], size);
            break;

        case TOPIC_CURR_OWNER_TABLE:
            if (task->curr_own == NULL)
                break;

            memcpy(ptr, &task->curr_own[elem], size);
            break;

        case TOPIC_CURR_MEMBER_TABLE:
            if (task->curr_mem == NULL)
                break;

            memcpy(ptr, &task->curr_mem[elem], size);
            break;

        default:
            dberr(S_INVID);
            break;
    }

    return (task->db_status);
}