cadcdev-svn-commits Mailing List for Cryptic Allusion DCDev (Page 29)

SourceForge Headquarters 225 Broadway Suite 1600 San Diego, CA 92101 +1 (858) 422-6466

This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "A pseudo Operating System for the Dreamcast.".

The branch, master has been updated
       via  f93a40f18cf4f537ccbb2e11b0c93b23d717bc63 (commit)
      from  5218f13d0aec2002f5ad8ada6c71ed0913600f15 (commit)

Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.

- Log -----------------------------------------------------------------
commit f93a40f18cf4f537ccbb2e11b0c93b23d717bc63
Author: Lawrence Sebald <ljs...@us...>
Date:   Thu Aug 8 00:37:13 2019 -0400

    Add initial (probably still buggy) verison of libkosfat.
    
    Please note, this is currently read-only, but that hopefully
    should change soon.

-----------------------------------------------------------------------

Summary of changes:
 addons/include/fat/fs_fat.h                        | 119 +++
 addons/libkosfat/Makefile                          |  10 +
 addons/libkosfat/bpb.c                             | 233 +++++
 addons/libkosfat/bpb.h                             | 114 +++
 addons/libkosfat/directory.c                       | 821 +++++++++++++++++
 addons/libkosfat/directory.h                       |  69 ++
 addons/libkosfat/fat.c                             | 322 +++++++
 addons/libkosfat/fatfs.c                           | 400 +++++++++
 addons/libkosfat/fatfs.h                           | 122 +++
 addons/libkosfat/fatinternal.h                     |  51 ++
 addons/libkosfat/fs_fat.c                          | 973 +++++++++++++++++++++
 .../{libkosext2fs => libkosfat}/kos/dreamcast.cnf  |   0
 addons/libkosfat/ucs.c                             | 126 +++
 addons/libkosfat/ucs.h                             |  23 +
 doc/CHANGELOG                                      |   1 +
 doc/FAQ                                            |  20 +-
 doc/RELNOTES                                       |   9 +-
 17 files changed, 3403 insertions(+), 10 deletions(-)
 create mode 100644 addons/include/fat/fs_fat.h
 create mode 100644 addons/libkosfat/Makefile
 create mode 100644 addons/libkosfat/bpb.c
 create mode 100644 addons/libkosfat/bpb.h
 create mode 100644 addons/libkosfat/directory.c
 create mode 100644 addons/libkosfat/directory.h
 create mode 100644 addons/libkosfat/fat.c
 create mode 100644 addons/libkosfat/fatfs.c
 create mode 100644 addons/libkosfat/fatfs.h
 create mode 100644 addons/libkosfat/fatinternal.h
 create mode 100644 addons/libkosfat/fs_fat.c
 copy addons/{libkosext2fs => libkosfat}/kos/dreamcast.cnf (100%)
 create mode 100644 addons/libkosfat/ucs.c
 create mode 100644 addons/libkosfat/ucs.h

diff --git a/addons/include/fat/fs_fat.h b/addons/include/fat/fs_fat.h
new file mode 100644
index 0000000..003892b
--- /dev/null
+++ b/addons/include/fat/fs_fat.h
@@ -0,0 +1,119 @@
+/* KallistiOS ##version##
+
+   ext2/fs_fat.h
+   Copyright (C) 2012, 2013, 2019 Lawrence Sebald
+*/
+
+#ifndef __FAT_FS_FAT_H
+#define __FAT_FS_FAT_H
+
+#include <sys/cdefs.h>
+__BEGIN_DECLS
+
+#include <stdint.h>
+#include <kos/blockdev.h>
+
+/** \file   fat/fs_fat.h
+    \brief  VFS interface for a FAT filesystem.
+
+    This file defines the public interface to add support for the FAT
+    filesystem, as in common use on all kinds of systems and popularized by
+    MS-DOS and Windows. This interface supports FAT12, FAT16, and FAT32, with
+    both short and long names.
+
+    Note that there is a lower-level interface sitting underneath of this layer.
+    This lower-level interface (simply called fatfs) should not generally be
+    used by any normal applications. As of this point, it is completely non
+    thread-safe and the fs_fat layer takes extreme care to overcome those
+    issues with the lower-level interface. Over time, I may fix the thread-
+    safety issues in fatfs, but that is not particularly high on my priority
+    list at the moment. There shouldn't really be a reason to work directly with
+    the fatfs layer anyway, as this layer should give you everything you need
+    by interfacing with the VFS in the normal fashion.
+
+    \author Lawrence Sebald
+*/
+
+/** \brief  Initialize fs_fat.
+
+    This function initializes fs_fat, preparing various internal structures for
+    use.
+
+    \retval 0           On success. No error conditions currently defined.
+*/
+int fs_fat_init(void);
+
+/** \brief  Shut down fs_fat.
+
+    This function shuts down fs_fat, basically undoing what fs_fat_init() did.
+
+    \retval 0           On success. No error conditions currently defined.
+*/
+int fs_fat_shutdown(void);
+
+/** \defgroup fat_mount_flags          Mount flags for fs_fat
+
+    These values are the valid flags that can be passed for the flags parameter
+    to the fs_fat_mount() function. Note that these can be combined, except for
+    the read-only flag.
+
+    Also, it is not possible to mount some filesystems as read-write. For
+    instance, if the filesystem was marked as not cleanly unmounted the driver
+    will fail to mount the device as read-write. Also, if the block device does
+    not support writing, then the filesystem will not be mounted as read-write
+    (for obvious reasons).
+
+    These should stay synchronized with the ones in fatfs.h.
+
+    @{
+*/
+#define FS_FAT_MOUNT_READONLY       0x00000000  /**< \brief Mount read-only */
+#define FS_FAT_MOUNT_READWRITE      0x00000001  /**< \brief Mount read-write */
+/** @} */
+
+/** \brief  Mount a FAT filesystem in the VFS.
+
+    This function mounts an ext2 filesystem to the specified mount point on the
+    VFS. This function will detect whether or not an FAT filesystem exists on
+    the given block device and mount it only if there is actually an FAT
+    filesystem.
+
+    \param  mp          The path to mount the filesystem at.
+    \param  dev         The block device containing the filesystem.
+    \param  flags       Mount flags. Bitwise OR of values from fat_mount_flags
+    \retval 0           On success.
+    \retval -1          On error.
+*/
+int fs_fat_mount(const char *mp, kos_blockdev_t *dev, uint32_t flags);
+
+/** \brief  Unmount a FAT filesystem from the VFS.
+
+    This function unmoutns an FAT filesystem that was previously mounted by the
+    fs_fat_mount() function.
+
+    \param  mp          The mount point of the filesystem to be unmounted.
+    \retval 0           On success.
+    \retval -1          On error.
+*/
+int fs_fat_unmount(const char *mp);
+
+/** \brief  Sync a FAT filesystem, flushing all pending writes to the block
+            device.
+
+    This function completes all pending writes on the filesystem, making sure
+    all data and metadata are in a consistent state on the block device. As both
+    inode and block writes are normally postponed until they are either evicted
+    from the cache or the filesystem is unmounted, doing this periodically may
+    be a good idea if there is a chance that the filesystem will not be
+    unmounted cleanly.
+
+    \param  mp          The mount point of the filesystem to be synced.
+    \retval 0           On success.
+    \retval -1          On error.
+
+    \note   This function has no effect if the filesystem was mounted read-only.
+*/
+int fs_fat_sync(const char *mp);
+
+__END_DECLS
+#endif /* !__FAT_FS_FAT_H */
diff --git a/addons/libkosfat/Makefile b/addons/libkosfat/Makefile
new file mode 100644
index 0000000..66b6667
--- /dev/null
+++ b/addons/libkosfat/Makefile
@@ -0,0 +1,10 @@
+# libkosfat Makefile
+#
+
+TARGET = libkosfat.a
+OBJS = fat.o bpb.o fatfs.o directory.o ucs.o fs_fat.o
+
+# Make sure everything comiles nice and cleanly (or not at all).
+KOS_CFLAGS += -W -Wextra -pedantic -std=c99 -Werror
+
+include $(KOS_BASE)/addons/Makefile.prefab
diff --git a/addons/libkosfat/bpb.c b/addons/libkosfat/bpb.c
new file mode 100644
index 0000000..c671296
--- /dev/null
+++ b/addons/libkosfat/bpb.c
@@ -0,0 +1,233 @@
+/* KallistiOS ##version##
+
+   bpb.c
+   Copyright (C) 2012, 2019 Lawrence Sebald
+*/
+
+#include <stdio.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h>
+#include <inttypes.h>
+
+#include "fatfs.h"
+#include "fatinternal.h"
+
+static int fat_read_raw_boot(fat_bootblock_t *sb, kos_blockdev_t *bd) {
+    if(bd->l_block_size > 9) {
+        uint8_t *buf;
+
+        if(!(buf = (uint8_t *)malloc(1 << bd->l_block_size)))
+            return -ENOMEM;
+
+        if(bd->read_blocks(bd, 0, 1, buf))
+            return -EIO;
+
+        memcpy(sb, buf, 512);
+        free(buf);
+        return 0;
+    }
+    else if(bd->l_block_size == 9) {
+        return bd->read_blocks(bd, 0, 1, sb);
+    }
+    else {
+        return bd->read_blocks(bd, 0, 512 >> bd->l_block_size, sb);
+    }
+}
+
+static int fat_read_fsinfo(fat32_fsinfo_t *fsinfo, int s, kos_blockdev_t *bd) {
+    if(bd->l_block_size > 9) {
+        uint8_t *buf;
+
+        if(!(buf = (uint8_t *)malloc(1 << bd->l_block_size)))
+            return -ENOMEM;
+
+        if(bd->read_blocks(bd, s, 1, buf))
+            return -EIO;
+
+        memcpy(fsinfo, buf, 512);
+        free(buf);
+        return 0;
+    }
+    else if(bd->l_block_size == 9) {
+        /* This should generally be the case... */
+        return bd->read_blocks(bd, s, 1, fsinfo);
+    }
+    else {
+        /* This shouldn't happen. */
+        return -EIO;
+    }
+}
+
+static int fat_parse_boot(fat_bootblock_t *bb, fat_superblock_t *sb) {
+    uint32_t rds, fsz, ts, ds, bps, rs, nc, fds;
+
+    /* Do work needed to determine what type of filesystem we have... */
+    rds = bb->bpb.root_dir_entries[0] | (bb->bpb.root_dir_entries[1] << 8);
+    bps = bb->bpb.bytes_per_sector[0] | (bb->bpb.bytes_per_sector[1] << 8);
+    rds = ((rds << 5) + (bps - 1)) / bps;
+
+    fsz = bb->bpb.fat_size[0] | (bb->bpb.fat_size[1] << 8);
+    if(!fsz)
+        fsz = bb->ebpb.fat32.fat_size[0] | (bb->ebpb.fat32.fat_size[1] << 8) |
+            (bb->ebpb.fat32.fat_size[2] << 16) |
+            (bb->ebpb.fat32.fat_size[3] << 24);
+
+    ts = bb->bpb.num_sectors16[0] | (bb->bpb.num_sectors16[1] << 8);
+    if(!ts)
+        ts = bb->bpb.num_sectors32[0] | (bb->bpb.num_sectors32[1] << 8) |
+            (bb->bpb.num_sectors32[2] << 16) | (bb->bpb.num_sectors32[3] << 24);
+
+    rs = bb->bpb.reserved_sectors[0] | (bb->bpb.reserved_sectors[1] << 8);
+    fds = rs + (bb->bpb.num_fats * fsz) + rds;
+    ds = ts - fds;
+
+    nc = ds / bb->bpb.sectors_per_cluster;
+
+    /* Fill in stuff in the superblock structure. */
+    sb->num_sectors = ts;
+    sb->fat_size = fsz;
+    sb->bytes_per_sector = bps;
+    sb->reserved_sectors = rs;
+    sb->num_clusters = nc;
+    sb->num_fats = bb->bpb.num_fats;
+    sb->sectors_per_cluster = bb->bpb.sectors_per_cluster;
+    sb->first_data_block = fds;
+
+    if(nc <= FAT_MAX_FAT12_CLUSTERS)
+        sb->fs_type = FAT_FS_FAT12;
+    else if(nc <= FAT_MAX_FAT16_CLUSTERS)
+        sb->fs_type = FAT_FS_FAT16;
+    else
+        sb->fs_type = FAT_FS_FAT32;
+
+    if(rds)
+        sb->root_dir = bb->bpb.root_dir_entries[0] |
+            (bb->bpb.root_dir_entries[1] << 8);
+    else
+        sb->root_dir = bb->ebpb.fat32.rootdir_cluster[0] |
+            (bb->ebpb.fat32.rootdir_cluster[1] << 8) |
+            (bb->ebpb.fat32.rootdir_cluster[2] << 16) |
+            (bb->ebpb.fat32.rootdir_cluster[3] << 24);
+
+    if(sb->fs_type == FAT_FS_FAT32) {
+        /* Make sure that the filesystem is sane... */
+        if(bb->ebpb.fat32.fs_version[0] || bb->ebpb.fat32.fs_version[1])
+            return -EINVAL;
+
+        sb->fsinfo_sector = bb->ebpb.fat32.fsinfo_sector[0] |
+            bb->ebpb.fat32.fsinfo_sector[1];
+
+        sb->backup_bpb = bb->ebpb.fat32.backup_bpb[0] |
+            bb->ebpb.fat32.backup_bpb[1];
+
+        if(bb->ebpb.fat32.ext_boot_sig == 0x28 ||
+           bb->ebpb.fat32.ext_boot_sig == 0x29)
+            memcpy(sb->volume_id, bb->ebpb.fat32.volume_id, 4);
+
+        if(bb->ebpb.fat32.ext_boot_sig == 0x29)
+            memcpy(sb->volume_label, bb->ebpb.fat32.volume_label, 11);
+    }
+    else {
+        if(bb->ebpb.fat16.ext_boot_sig == 0x28 ||
+           bb->ebpb.fat16.ext_boot_sig == 0x29)
+            memcpy(sb->volume_id, bb->ebpb.fat16.volume_id, 4);
+
+        if(bb->ebpb.fat16.ext_boot_sig == 0x29)
+            memcpy(sb->volume_label, bb->ebpb.fat16.volume_label, 11);
+    }
+
+    return 0;
+}
+
+int fat_read_boot(fat_superblock_t *sb, kos_blockdev_t *bd) {
+    int rv;
+    fat_bootblock_t bb;
+    fat32_fsinfo_t fsinfo;
+
+    memset(&bb, 0, sizeof(fat_bootblock_t));
+    memset(sb, 0, sizeof(fat_superblock_t));
+
+    if((rv = fat_read_raw_boot(&bb, bd)) < 0) {
+        return rv;
+    }
+
+    /* Make sure it looks sane... */
+    if(bb.ebpb.fat16.boot_sig[0] != 0x55 || bb.ebpb.fat16.boot_sig[1] != 0xAA) {
+        return -EINVAL;
+    }
+
+    if((rv = fat_parse_boot(&bb, sb)) < 0) {
+        return rv;
+    }
+
+    /* Make sure our sector sizes match up... */
+    if(sb->bytes_per_sector != (1 << bd->l_block_size)) {
+        return -EINVAL;
+    }
+
+    /* If we have an fsinfo sector, read it. */
+    if(sb->fsinfo_sector) {
+        memset(&fsinfo, 0, sizeof(fat32_fsinfo_t));
+
+        if((rv = fat_read_fsinfo(&fsinfo, sb->fsinfo_sector, bd)) < 0) {
+            return rv;
+        }
+
+        /* Check it for sanity... */
+        if(fsinfo.fsinfo_sig1 != FAT32_FSINFO_SIG1 ||
+           fsinfo.fsinfo_sig2 != FAT32_FSINFO_SIG2 ||
+           fsinfo.fsinfo_sig3 != FAT32_FSINFO_SIG3) {
+            dbglog(DBG_KDEBUG, "Potentially invalid FSinfo sector: "
+                   "%08" PRIx32 " %08" PRIx32 " %08" PRIx32 "\n",
+                   fsinfo.fsinfo_sig1, fsinfo.fsinfo_sig2,
+                   fsinfo.fsinfo_sig3);
+        }
+        else {
+            /* Parse out what we care about... */
+            sb->free_clusters = fsinfo.free_clusters;
+            sb->last_alloc_cluster = fsinfo.last_alloc_cluster;
+        }
+    }
+
+    return 0;
+}
+
+#ifdef FAT_DEBUG
+static const char *fs_types[] = { "FAT12", "FAT16", "FAT32" };
+void fat_print_superblock(const fat_superblock_t *sb) {
+    char label[12];
+
+    dbglog(DBG_KDEBUG, "FAT Superblock:\n");
+    dbglog(DBG_KDEBUG, "Filesystem type: %s\n", fs_types[sb->fs_type]);
+    dbglog(DBG_KDEBUG, "Sector Count: %" PRIu32 "\n", sb->num_sectors);
+    dbglog(DBG_KDEBUG, "FAT Size: %" PRIu32 "\n", sb->fat_size);
+    dbglog(DBG_KDEBUG, "Number of FAT copies: %" PRIu8 "\n", sb->num_fats);
+    dbglog(DBG_KDEBUG, "Sectors per cluster: %" PRIu16 "\n",
+           sb->sectors_per_cluster);
+    dbglog(DBG_KDEBUG, "Bytes per sector: %" PRIu16 "\n", sb->bytes_per_sector);
+    dbglog(DBG_KDEBUG, "Reserved sectors: %" PRIu16 "\n", sb->reserved_sectors);
+    dbglog(DBG_KDEBUG, "First data block: %" PRIu32 "\n", sb->first_data_block);
+    dbglog(DBG_KDEBUG, "Volume ID: %02" PRIx8 "%02" PRIx8 "-%02" PRIx8 "%02"
+           PRIx8 "\n", sb->volume_id[3], sb->volume_id[2], sb->volume_id[1],
+           sb->volume_id[0]);
+    memcpy(label, sb->volume_label, 11);
+    label[11] = 0;
+    dbglog(DBG_KDEBUG, "Volume Label: '%s'\n", label);
+
+    if(sb->fs_type == FAT_FS_FAT32) {
+        dbglog(DBG_KDEBUG, "Root directory cluster: %" PRIu32 "\n",
+               sb->root_dir);
+        dbglog(DBG_KDEBUG, "FSinfo Sector: %" PRIu16 "\n", sb->fsinfo_sector);
+        dbglog(DBG_KDEBUG, "Backup BPB: %" PRIu16 "\n", sb->backup_bpb);
+        dbglog(DBG_KDEBUG, "Free clusters: %" PRIu32 "\n",
+               sb->free_clusters);
+        dbglog(DBG_KDEBUG, "Last used cluster: %" PRIu32 "\n",
+               sb->last_alloc_cluster);
+    }
+    else {
+        dbglog(DBG_KDEBUG, "Root directory size: %" PRIu32 "\n", sb->root_dir);
+    }
+}
+#endif /* FAT_DEBUG */
diff --git a/addons/libkosfat/bpb.h b/addons/libkosfat/bpb.h
new file mode 100644
index 0000000..cb34882
--- /dev/null
+++ b/addons/libkosfat/bpb.h
@@ -0,0 +1,114 @@
+/* KallistiOS ##version##
+
+   bpb.h
+   Copyright (C) 2019 Lawrence Sebald
+*/
+
+#ifndef __FAT_BPB_H
+#define __FAT_BPB_H
+
+#include <sys/cdefs.h>
+__BEGIN_DECLS
+
+#include <stdint.h>
+
+typedef struct fat_bpb {
+    uint8_t jmp[3];         /* 0xEB 0x?? 0x90 or 0xE9 0x?? 0x?? */
+    uint8_t oem_name[8];
+    uint8_t bytes_per_sector[2];
+    uint8_t sectors_per_cluster;
+    uint8_t reserved_sectors[2];
+    uint8_t num_fats;
+    uint8_t root_dir_entries[2];
+    uint8_t num_sectors16[2];
+    uint8_t media_code;
+    uint8_t fat_size[2];
+    uint8_t sectors_per_track[2];
+    uint8_t num_heads[2];
+    uint8_t hidden_sector_count[4];
+    uint8_t num_sectors32[4];
+} __attribute__((packed)) fat_bpb_t;
+
+typedef struct fat16_ebpb {
+    uint8_t drive_number;
+    uint8_t reserved;
+    uint8_t ext_boot_sig;
+    uint8_t volume_id[4];
+    uint8_t volume_label[11];
+    uint8_t fs_type[8];
+    uint8_t boot_code[448];
+    uint8_t boot_sig[2];
+} __attribute__((packed)) fat16_ebpb_t;
+
+typedef struct fat32_ebpb {
+    uint8_t fat_size[4];
+    uint8_t flags[2];
+    uint8_t fs_version[2];
+    uint8_t rootdir_cluster[4];
+    uint8_t fsinfo_sector[2];
+    uint8_t backup_bpb[2];
+    uint8_t reserved[12];
+    uint8_t drive_number;
+    uint8_t reserved2;
+    uint8_t ext_boot_sig;
+    uint8_t volume_id[4];
+    uint8_t volume_label[11];
+    uint8_t fs_type[8];
+    uint8_t boot_code[420];
+    uint8_t boot_sig[2];
+} __attribute__((packed)) fat32_ebpb_t;
+
+typedef struct fat_bootblock {
+    fat_bpb_t bpb;
+    union {
+        fat16_ebpb_t fat16;
+        fat32_ebpb_t fat32;
+    } ebpb;
+} __attribute__((packed)) fat_bootblock_t;
+
+typedef struct fat32_fsinfo {
+    uint32_t fsinfo_sig1;
+    uint8_t reserved[480];
+    uint32_t fsinfo_sig2;
+    uint32_t free_clusters;
+    uint32_t last_alloc_cluster;
+    uint8_t reserved2[12];
+    uint32_t fsinfo_sig3;
+} __attribute__((packed)) fat32_fsinfo_t;
+
+#define FAT32_FSINFO_SIG1 0x41615252
+#define FAT32_FSINFO_SIG2 0x61417272
+#define FAT32_FSINFO_SIG3 0xAA550000
+
+typedef struct fat_superblock {
+    uint32_t num_sectors;
+    uint32_t fat_size;
+    uint32_t root_dir;
+    uint32_t num_clusters;
+    uint32_t first_data_block;
+
+    uint32_t free_clusters;
+    uint32_t last_alloc_cluster;
+    uint16_t fsinfo_sector;
+    uint16_t backup_bpb;
...<truncated>...


hooks/post-receive
-- 
A pseudo Operating System for the Dreamcast.




2003	Jan	Feb	Mar	Apr	May	Jun	Jul	Aug	Sep	Oct	Nov (35)	Dec (2)
2004	Jan (37)	Feb (10)	Mar	Apr (2)	May (17)	Jun (1)	Jul (14)	Aug (14)	Sep (4)	Oct	Nov (14)	Dec (4)
2005	Jan (6)	Feb	Mar	Apr (6)	May	Jun	Jul	Aug	Sep (1)	Oct	Nov (92)	Dec (12)
2006	Jan (3)	Feb (4)	Mar	Apr (5)	May (3)	Jun (15)	Jul (3)	Aug (1)	Sep (29)	Oct (1)	Nov (6)	Dec (5)
2007	Jan (2)	Feb (2)	Mar	Apr (3)	May (14)	Jun (2)	Jul (16)	Aug (73)	Sep (12)	Oct (9)	Nov (27)	Dec (3)
2008	Jan (4)	Feb (4)	Mar (3)	Apr (8)	May (23)	Jun (4)	Jul (1)	Aug (3)	Sep (7)	Oct (5)	Nov (1)	Dec (1)
2009	Jan	Feb (10)	Mar	Apr (4)	May (4)	Jun (10)	Jul	Aug (1)	Sep	Oct (7)	Nov	Dec (1)
2010	Jan	Feb (1)	Mar	Apr (6)	May	Jun (3)	Jul (11)	Aug (1)	Sep	Oct (15)	Nov (1)	Dec (5)
2011	Jan (4)	Feb (1)	Mar (6)	Apr	May (22)	Jun	Jul (8)	Aug (2)	Sep	Oct	Nov	Dec (2)
2012	Jan	Feb (10)	Mar (1)	Apr (6)	May (27)	Jun (48)	Jul (30)	Aug (4)	Sep	Oct (3)	Nov (1)	Dec (11)
2013	Jan (4)	Feb (7)	Mar (6)	Apr (18)	May (28)	Jun (20)	Jul	Aug (4)	Sep (1)	Oct (1)	Nov (2)	Dec (7)
2014	Jan (3)	Feb (2)	Mar (4)	Apr (9)	May (11)	Jun (10)	Jul	Aug (18)	Sep (12)	Oct (17)	Nov (10)	Dec (16)
2015	Jan (5)	Feb (1)	Mar (5)	Apr (4)	May (28)	Jun (2)	Jul	Aug	Sep (6)	Oct	Nov (2)	Dec (1)
2016	Jan (14)	Feb	Mar (3)	Apr	May	Jun (3)	Jul (4)	Aug (4)	Sep (1)	Oct (1)	Nov	Dec (1)
2017	Jan (11)	Feb	Mar (21)	Apr	May (1)	Jun	Jul	Aug	Sep	Oct	Nov	Dec (1)
2018	Jan	Feb	Mar (1)	Apr	May (1)	Jun	Jul	Aug (2)	Sep (4)	Oct (4)	Nov	Dec (1)
2019	Jan (1)	Feb	Mar	Apr (1)	May	Jun	Jul	Aug (13)	Sep (4)	Oct	Nov	Dec
2020	Jan (10)	Feb (9)	Mar (5)	Apr (4)	May (3)	Jun (18)	Jul (4)	Aug (2)	Sep (20)	Oct (2)	Nov	Dec
2021	Jan	Feb	Mar	Apr (2)	May (1)	Jun (2)	Jul (1)	Aug (2)	Sep	Oct	Nov	Dec (2)
2022	Jan (1)	Feb (2)	Mar (2)	Apr (1)	May	Jun	Jul	Aug (5)	Sep	Oct (1)	Nov	Dec (1)
2023	Jan (10)	Feb (7)	Mar (29)	Apr (31)	May (29)	Jun (34)	Jul (3)	Aug (24)	Sep (22)	Oct (10)	Nov (38)	Dec (27)
2024	Jan (15)	Feb (8)	Mar (4)	Apr (20)	May (33)	Jun (18)	Jul (15)	Aug (23)	Sep (26)	Oct (32)	Nov (6)	Dec (4)
2025	Jan (7)	Feb (1)	Mar (1)	Apr (4)	May (46)	Jun (19)	Jul (26)	Aug (13)	Sep	Oct	Nov	Dec

cadcdev-svn-commits Mailing List for Cryptic Allusion DCDev (Page 29)

cadcdev-svn-commits — Source Code Repository Updates