improve fileioc documentation a little bit

Signed-off-by: mateoconlechuga <matthewwaltzis@gmail.com>

Author: mateoconlechuga

docs/_static/css/tables.css

@@ -0,0 +1,6 @@
+.wy-table-responsive table td {
+  white-space: normal !important;
+}
+.wy-table-responsive {
+  overflow: visible !important;
+}

docs/conf.py

@@ -59,3 +59,11 @@
 breathe_default_project = 'CE C/C++ Toolchain'
 subprocess.call('doxygen doxyfile', shell=True)
 breathe_projects['CE C/C++ Toolchain'] = 'doxygen/xml'
+
+def check_conditional_assets(app, pagename, templatename, context, doctree):
+    if pagename != 'libraries/fileioc':
+        context["css_files"] = ['']
+
+def setup(app):
+   app.connect('html-page-context', check_conditional_assets)
+   app.add_css_file('css/tables.css')

docs/doxyfile

@@ -853,7 +853,6 @@ INPUT                  = ../src/graphx/graphx.h \
                          ../src/ce/include/ti/getcsc.h \
                          ../src/ce/include/ti/getkey.h \
                          ../src/ce/include/ti/screen.h \
-                         ../src/ce/include/ti/hooks.h \
                          ../src/ce/include/ti/info.h \
                          ../src/ce/include/ti/python.h \
                          ../src/ce/include/ti/real.h \

docs/libraries/fileioc.rst

@@ -7,9 +7,15 @@ fileioc.h
 
     #include <fileioc.h>
 
-The fileioc library is used for writing and reading program data to files.
-File support is implemented with the use of AppVars.
-Additionally, the library supports accessing program data and various OS variable manipulation.
+The :code:`fileioc` library provides access to OS variables such as AppVars, Programs, Lists, and Strings.
+
+AppVars are special types of variables that can be used to store any arbitrary data, and are utilized by the CE toolchain to provide data storage beyond what can be compiled into a program.
+AppVars may store things like save states, sprites, and user configurations.
+
+The OS stores variables in either RAM or archive (aka flash) memory.
+RAM memory is volatile and is cleared whenever the calculator is reset, whereas archive memory provides a more permanent storage for variables.
+However, variables can only be written to while in RAM as the calculator's security measures do not provide a way to directly write to the archive.
+The function :code:`ti_SetArchiveStatus` can be used to move a variable between the archive and RAM.
 
 .. contents:: :local:
    :depth: 3

docs/libraries/fontlibc.rst

@@ -7,18 +7,20 @@ fontlibc.h
 
     #include <fontlibc.h>
 
-fontlibc was designed under a "mechanism not policy" sort of philosophy.
+The :code:`fontlibc` library provides routines for displaying custom fonts and glyphs, and can be used to extend the limited font capabilities of :ref:`graphx <graphx_h>`.
+
+The :code:`fontlibc` library was designed under a "mechanism not policy" sort of philosophy.
 Rather than attempting to provide as many fancy features as a programmer could want, fontlibc tries to provide fast, basic routines that can be used to build the additional functionality you want.
 For example, word-wrap is not directly provided, but can be implemented using :code:`fontlib_SetAlternateStopCode` and :code:`fontlib_GetStringWidth`.
-fontlib hopes to provide enough performance to be usable in games, while providing powerful enough basic features for fancy GUIs and document editors.
+fontlibc hopes to provide enough performance to be usable in games, while providing powerful enough basic features for fancy GUIs and document editors.
 
 .. contents:: :local:
    :depth: 3
 
 Creating Fonts
 --------------
 
-Fonts for use with FontLibC can be made with any program that can produce Windows 3.x .FNT resource files.
+Fonts for use with fontlibc can be made with any program that can produce Windows 3.x .FNT resource files.
 
 Editor Software
 ~~~~~~~~~~~~~~~

docs/libraries/graphx.rst

@@ -7,7 +7,7 @@ graphx.h
 
     #include <graphx.h>
 
-The graphx library implements efficient graphics routines from everything to drawing sprites, shapes, and tilemaps.
+The :code:`graphx` library implements efficient graphics routines from everything to drawing sprites, shapes, and tilemaps.
 This allows a programmer to easily add quality graphics to their program without needing to worry about the low-level implementation details.
 
 .. contents:: :local:

docs/libraries/keypadc.rst

@@ -7,7 +7,7 @@ keypadc.h
 
     #include <keypadc.h>
 
-The keypadc library is used for quickly polling the status of the keys in the keypad.
+The :code:`keypadc` library is used for quickly polling the status of the keys in the keypad.
 It supports multi-key presses, and can be used for extremely responsive input compared to OS routines such as :code:`os_GetCSC()`.
 
 .. contents:: :local:

docs/static/faq.rst

@@ -59,13 +59,19 @@ Linking Assembly Source Files
 Assembly routines can be linked into a C/C++ program provided the following conditions are met:
 
 - The file's extension is **.asm**. It can be placed at any depth in the sources directory.
-- The routine should have a C/C++ prototype if it used externally.
+- The appropriate section is declared - either :code:`.text` for code, :code:`.data` for initialized data, or :code:`.rodata` for read-only data.
+  This is done using the `section` keyword, whereby everything after the keyword will be added to the defined section.
 - The assembly routine must be prefixed with an underscore, and have a corresponding `public` entry in the assembly file.
 - Any external functions called from the assembly source must be listed as being `extern`.
+- A separate header file should define a C/C++ prototype for the function if it is called from C/C++ code.
 
-Below is an example assembly source file that relies on an external function:
+Below is an example C prototype followed by the assembly implementation:
 
-.. code-block:: asm
+.. code-block:: c
+
+    void asm_func(int arg);
+
+.. code-block::
 
     	assume	adl=1
 
@@ -75,21 +81,13 @@ Below is an example assembly source file that relies on an external function:
     _asm_func:
     	pop	hl
     	pop	de
-    	push	de
+    	push	de	; de = arg
     	push	hl
 	call	_external_func
     	ret
 
     	extern	_external_func
 
-The C prototype is shown below:
-
-C File:
-
-.. code-block:: c
-
-    void asm_func(int a);
-
 Arguments
 ~~~~~~~~~
 

docs/static/getting-started.rst

@@ -6,14 +6,14 @@ Getting Started
 Installing the CE Toolchain
 ---------------------------
 
-* Download the latest stable toolchain release for your OS `here <https://github.com/CE-Programming/toolchain/releases/latest>`_.
+* Download the latest stable toolchain release for your OS `here <https://github.com/CE-Programming/toolchain/releases/latest>`__.
 
-  * You can optionally try the "nightly" build `here <https://github.com/CE-Programming/toolchain/releases/tag/nightly>`_ instead - this is where all current development happens, and provides the latest features and support before an official release.
-
-* Extract the archive to a location **without any spaces in it**.
+  * You can optionally try the "nightly" build `here <https://github.com/CE-Programming/toolchain/releases/tag/nightly>`__ instead - this is where all current development happens, and provides the latest features and support before an official release.
 
 **On Windows**
 
+    * Extract the archive to a location **without any spaces in it**, e.g. :code:`C:\CEdev`.
+
     * Double click :code:`cedev.bat` inside the extracted :code:`CEdev` folder to launch the toolchain environment.
       You may have to allow the script to be run depending on the user account control.
 
@@ -22,6 +22,8 @@ Installing the CE Toolchain
 
 **On Linux or macOS**
 
+    * Extract the archive to a location **without any spaces in it**, e.g. :code:`/home/user/CEdev`.
+
     * Extend the PATH environment variable to point to :code:`CEdev/bin` by modifying `.bashrc`, `.zshrc`, or whatever flavor your OS uses.
 
         .. indent with spaces

docs/static/hardware.rst

@@ -168,9 +168,9 @@ Archived variables, the operating system, and applications, are all stored in fl
 While you can freely read any and all of flash, the calculator's hardware prevents you from writing to flash, and in fact, attempting to do so will cause a crash.
 The calculator's operating system works with special hardware to enforce this restriction in order to prevent students from patching the OS to let them cheat.
 Consequently, the only way to store data in flash is to create a variable in RAM and then archive it.
-The :code:`fileioc` library makes this easy.
+The :ref:`fileioc library <fileioc_h>` makes this easy.
 
-Because teachers (and therefore TI's management) get very worked up by cheating, the toolchain does not and will not provide any means of bypassing this restriction.
+Because teachers (and therefore TI's management) get very worked up by cheating, the toolchain does not (and will not) provide any means of bypassing this restriction.
 
 The LCD
 ^^^^^^^