forked from Mirror/GodMode9
Compare commits
1 Commits
master
...
readme-con
| Author | SHA1 | Date | |
|---|---|---|---|
|
42065daa86 |
2
.github/workflows/ci.yml
vendored
2
.github/workflows/ci.yml
vendored
@ -35,7 +35,7 @@ jobs:
|
||||
rm $ZIPNAME
|
||||
echo "OUTNAME=${ZIPNAME%.zip}" >> $GITHUB_ENV
|
||||
|
||||
- uses: actions/upload-artifact@v4
|
||||
- uses: actions/upload-artifact@v2
|
||||
with:
|
||||
name: ${{ env.OUTNAME }}
|
||||
path: release/*
|
||||
|
||||
7
.gitignore
vendored
7
.gitignore
vendored
@ -5,7 +5,6 @@
|
||||
*.obj
|
||||
*.elf
|
||||
*.map
|
||||
*.dis
|
||||
|
||||
# Precompiled Headers
|
||||
*.gch
|
||||
@ -36,14 +35,10 @@
|
||||
|
||||
# OS leftovers
|
||||
desktop.ini
|
||||
.DS_Store
|
||||
|
||||
# Sublime files
|
||||
*.sublime-*
|
||||
|
||||
# Visual Studio Code files
|
||||
.vscode
|
||||
|
||||
# Build directories
|
||||
/build
|
||||
/output
|
||||
@ -54,5 +49,3 @@ desktop.ini
|
||||
|
||||
# User additions
|
||||
/zzz_backup
|
||||
/arm9/source/language.inl
|
||||
*.trf
|
||||
|
||||
61
Makefile
61
Makefile
@ -16,28 +16,18 @@ export RELDIR := release
|
||||
export COMMON_DIR := ../common
|
||||
|
||||
# Definitions for initial RAM disk
|
||||
VRAM_TAR := $(OUTDIR)/vram0.tar
|
||||
VRAM_DATA := data/*
|
||||
VRAM_FLAGS := --make-new --path-limit 99
|
||||
VRAM_OUT := $(OUTDIR)/vram0.tar
|
||||
VRAM_DATA := data
|
||||
VRAM_FLAGS := --make-new --path-limit 99 --size-limit 262144
|
||||
ifeq ($(NTRBOOT),1)
|
||||
VRAM_SCRIPTS := resources/gm9/scripts/*
|
||||
VRAM_SCRIPTS := resources/gm9/scripts
|
||||
endif
|
||||
|
||||
# Definitions for translation files
|
||||
JSON_FOLDER := resources/languages
|
||||
TRF_FOLDER := resources/gm9/languages
|
||||
|
||||
SOURCE_JSON := $(JSON_FOLDER)/source.json
|
||||
LANGUAGE_INL := arm9/source/language.inl
|
||||
|
||||
JSON_FILES := $(filter-out $(SOURCE_JSON),$(wildcard $(JSON_FOLDER)/*.json))
|
||||
TRF_FILES := $(subst $(JSON_FOLDER),$(TRF_FOLDER),$(JSON_FILES:.json=.trf))
|
||||
|
||||
ifeq ($(OS),Windows_NT)
|
||||
ifeq ($(TERM),cygwin)
|
||||
PY3 := py -3 # Windows / CMD/PowerShell
|
||||
else
|
||||
PY3 := py # Windows / MSYS2
|
||||
PY3 := python3 # Windows / MSYS2
|
||||
endif
|
||||
else
|
||||
PY3 := python3 # Unix-like
|
||||
@ -50,18 +40,18 @@ export ASFLAGS := -g -x assembler-with-cpp $(INCLUDE)
|
||||
export CFLAGS := -DDBUILTS="\"$(DBUILTS)\"" -DDBUILTL="\"$(DBUILTL)\"" -DVERSION="\"$(VERSION)\"" -DFLAVOR="\"$(FLAVOR)\"" \
|
||||
-g -Os -Wall -Wextra -Wcast-align -Wformat=2 -Wno-main \
|
||||
-fomit-frame-pointer -ffast-math -std=gnu11 -MMD -MP \
|
||||
-Wno-unused-function -Wno-format-truncation -Wno-format-nonliteral $(INCLUDE) -ffunction-sections -fdata-sections
|
||||
-Wno-unused-function -Wno-format-truncation $(INCLUDE) -ffunction-sections -fdata-sections
|
||||
export LDFLAGS := -Tlink.ld -nostartfiles -Wl,--gc-sections,-z,max-page-size=4096
|
||||
ELF := arm9/arm9_code.elf arm9/arm9_data.elf arm11/arm11.elf
|
||||
ELF := arm9/arm9.elf arm11/arm11.elf
|
||||
|
||||
.PHONY: all firm $(VRAM_TAR) elf release clean
|
||||
.PHONY: all firm vram0 elf release clean
|
||||
all: firm
|
||||
|
||||
clean:
|
||||
@set -e; for elf in $(ELF); do \
|
||||
$(MAKE) --no-print-directory -C $$(dirname $$elf) clean; \
|
||||
done
|
||||
@rm -rf $(OUTDIR) $(RELDIR) $(FIRM) $(FIRMD) $(VRAM_TAR) $(LANGUAGE_INL) $(TRF_FILES)
|
||||
@rm -rf $(OUTDIR) $(RELDIR) $(FIRM) $(FIRMD) $(VRAM_OUT)
|
||||
|
||||
unmarked_readme: .FORCE
|
||||
@$(PY3) utils/unmark.py -f README.md data/README_internal.md
|
||||
@ -85,44 +75,29 @@ release: clean unmarked_readme
|
||||
@cp $(OUTDIR)/$(FLAVOR)_dev.firm.sha $(RELDIR)/
|
||||
@cp $(ELF) $(RELDIR)/elf
|
||||
@cp $(CURDIR)/README.md $(RELDIR)
|
||||
@cp $(CURDIR)/resources/lua-doc.md $(RELDIR)/lua-doc.md
|
||||
@cp -R $(CURDIR)/resources/gm9 $(RELDIR)/gm9
|
||||
@cp -R $(CURDIR)/resources/sample $(RELDIR)/sample
|
||||
|
||||
@-7za a $(RELDIR)/$(FLAVOR)-$(VERSION)-$(DBUILTS).zip ./$(RELDIR)/*
|
||||
|
||||
$(VRAM_TAR): $(SPLASH) $(OVERRIDE_FONT) $(VRAM_DATA) $(VRAM_SCRIPTS)
|
||||
@mkdir -p "$(@D)"
|
||||
@echo "Creating $@"
|
||||
@$(PY3) utils/add2tar.py $(VRAM_FLAGS) $(VRAM_TAR) $(shell ls -d -1 $^)
|
||||
|
||||
$(LANGUAGE_INL): $(SOURCE_JSON)
|
||||
@echo "Creating $@"
|
||||
@$(PY3) utils/transcp.py $< $@
|
||||
|
||||
$(TRF_FOLDER)/%.trf: $(JSON_FOLDER)/%.json
|
||||
@$(PY3) utils/transriff.py $< $@
|
||||
vram0:
|
||||
@mkdir -p "$(OUTDIR)"
|
||||
@echo "Creating $(VRAM_OUT)"
|
||||
@$(PY3) utils/add2tar.py $(VRAM_FLAGS) $(VRAM_OUT) $(shell ls -d $(SPLASH) $(OVERRIDE_FONT) $(VRAM_DATA)/* $(VRAM_SCRIPTS))
|
||||
|
||||
%.elf: .FORCE
|
||||
@echo "Building $@"
|
||||
@$(MAKE) --no-print-directory -C $(@D) $(@F)
|
||||
@$(MAKE) --no-print-directory -C $(@D)
|
||||
|
||||
# Indicate a few explicit dependencies:
|
||||
# The ARM9 data section depends on the VRAM drive
|
||||
arm9/arm9_data.elf: $(VRAM_TAR) $(LANGUAGE_INL)
|
||||
# And the code section depends on the data section being built already
|
||||
arm9/arm9_code.elf: arm9/arm9_data.elf
|
||||
|
||||
firm: $(ELF) $(TRF_FILES)
|
||||
firm: $(ELF) vram0
|
||||
@test `wc -c <$(VRAM_OUT)` -le 262144
|
||||
@mkdir -p $(call dirname,"$(FIRM)") $(call dirname,"$(FIRMD)")
|
||||
@echo "[FLAVOR] $(FLAVOR)"
|
||||
@echo "[VERSION] $(VERSION)"
|
||||
@echo "[BUILD] $(DBUILTL)"
|
||||
@echo "[FIRM] $(FIRM)"
|
||||
@$(PY3) -m firmtool build $(FIRM) $(FTFLAGS) -g -D $(ELF) -C NDMA NDMA XDMA
|
||||
@$(PY3) -m firmtool build $(FIRM) $(FTFLAGS) -g -A 0x80C0000 -D $(ELF) $(VRAM_OUT) -C NDMA XDMA memcpy
|
||||
@echo "[FIRM] $(FIRMD)"
|
||||
@$(PY3) -m firmtool build $(FIRMD) $(FTDFLAGS) -g -D $(ELF) -C NDMA NDMA XDMA
|
||||
|
||||
vram0: $(VRAM_TAR) .FORCE # legacy target name
|
||||
@$(PY3) -m firmtool build $(FIRMD) $(FTDFLAGS) -g -A 0x80C0000 -D $(ELF) $(VRAM_OUT) -C NDMA XDMA memcpy
|
||||
|
||||
.FORCE:
|
||||
|
||||
@ -1,6 +1,4 @@
|
||||
|
||||
LIBS ?=
|
||||
|
||||
OBJECTS := $(patsubst $(SOURCE)/%.s, $(BUILD)/%.o, \
|
||||
$(patsubst $(SOURCE)/%.c, $(BUILD)/%.o, \
|
||||
$(call rwildcard, $(SOURCE), *.s *.c)))
|
||||
@ -13,12 +11,11 @@ all: $(TARGET).elf
|
||||
|
||||
.PHONY: clean
|
||||
clean:
|
||||
@rm -rf $(BUILD) $(TARGET).elf $(TARGET).dis $(TARGET).map
|
||||
@rm -rf $(BUILD) $(TARGET).elf $(TARGET).map
|
||||
|
||||
$(TARGET).elf: $(OBJECTS) $(OBJECTS_COMMON)
|
||||
@mkdir -p "$(@D)"
|
||||
@$(CC) $(LDFLAGS) $^ -o $@ $(LIBS)
|
||||
@$(OBJDUMP) -S -h $@ > $@.dis
|
||||
@$(CC) $(LDFLAGS) $^ -o $@
|
||||
|
||||
$(BUILD)/%.cmn.o: $(COMMON_DIR)/%.c
|
||||
@mkdir -p "$(@D)"
|
||||
|
||||
@ -1,4 +1,3 @@
|
||||
export OBJDUMP := arm-none-eabi-objdump
|
||||
|
||||
dirname = $(shell dirname $(1))
|
||||
|
||||
@ -26,12 +25,6 @@ else ifeq ($(FLAVOR),ZuishMode9)
|
||||
CFLAGS += -DDEFAULT_FONT=\"font_zuish_8x8.pbm\"
|
||||
endif
|
||||
|
||||
ifeq ($(LARGEDLC),1)
|
||||
CFLAGS += -DTITLE_MAX_CONTENTS=1536
|
||||
else
|
||||
CFLAGS += -DTITLE_MAX_CONTENTS=1024
|
||||
endif
|
||||
|
||||
ifeq ($(SALTMODE),1)
|
||||
CFLAGS += -DSALTMODE
|
||||
endif
|
||||
@ -68,10 +61,6 @@ ifdef SD_TIMEOUT
|
||||
CFLAGS += -DSD_TIMEOUT=$(SD_TIMEOUT)
|
||||
endif
|
||||
|
||||
ifeq ($(NO_LUA),1)
|
||||
CFLAGS += -DNO_LUA
|
||||
endif
|
||||
|
||||
ifdef N_PANES
|
||||
CFLAGS += -DN_PANES=$(N_PANES)
|
||||
endif
|
||||
|
||||
26
README.md
26
README.md
@ -39,9 +39,9 @@ GodMode9 is designed to be intuitive, buttons leading to the results you'd expec
|
||||
## How to build this / developer info
|
||||
Build `GodMode9.firm` via `make firm`. This requires [firmtool](https://github.com/TuxSH/firmtool), [Python 3.5+](https://www.python.org/downloads/) and [devkitARM](https://sourceforge.net/projects/devkitpro/) installed).
|
||||
|
||||
You may run `make release` to get a nice, release-ready package of all required files. To build __SafeMode9__ (a bricksafe variant of GodMode9, with limited write permissions) instead of GodMode9, compile with `make FLAVOR=SafeMode9`. To switch screens, compile with `make SWITCH_SCREENS=1`. For additional customization, you may choose the internal font by replacing `font_default.frf` inside the `data` directory. You may also hardcode the brightness via `make FIXED_BRIGHTNESS=x`, whereas `x` is a value between 0...15.
|
||||
You may run `make release` to get a nice, release-ready package of all required files. To build __SafeMode9__ (a bricksafe variant of GodMode9, with limited write permissions) instead of GodMode9, compile with `make FLAVOR=SafeMode9`. To switch screens, compile with `make SWITCH_SCREENS=1`. For additional customization, you may choose the internal font by replacing `font_default.pbm` inside the `data` directory. You may also hardcode the brightness via `make FIXED_BRIGHTNESS=x`, whereas `x` is a value between 0...15.
|
||||
|
||||
Further customization is possible by hardcoding `aeskeydb.bin` (just put the file into the `data` folder when compiling). All files put into the `data` folder will turn up in the `V:` drive, but keep in mind there's a hard 223.5KiB limit for all files inside, including overhead. A standalone script runner is compiled by providing `autorun.lua` or `autorun.gm9` (again, in the `data` folder) and building with `make SCRIPT_RUNNER=1`. There's more possibility for customization, read the Makefiles to learn more.
|
||||
Further customization is possible by hardcoding `aeskeydb.bin` (just put the file into the `data` folder when compiling). All files put into the `data` folder will turn up in the `V:` drive, but keep in mind there's a hard 3MB limit for all files inside, including overhead. A standalone script runner is compiled by providing `autorun.gm9` (again, in the `data` folder) and building with `make SCRIPT_RUNNER=1`. There's more possibility for customization, read the Makefiles to learn more.
|
||||
|
||||
To build a .firm signed with SPI boot keys (for ntrboot and the like), run `make NTRBOOT=1`. You may need to rename the output files if the ntrboot installer you use uses hardcoded filenames. Some features such as boot9 / boot11 access are not currently available from the ntrboot environment.
|
||||
|
||||
@ -65,10 +65,6 @@ For certain functionality, GodMode9 may need 'support files'. Support files shou
|
||||
* __`seeddb.bin`__: This file is optional and required to decrypt and mount seed-encrypted NCCHs and CIAs (if the seed in question is not installed to your NAND). Note that your seeddb.bin must also contain the seed for the specific game you need to decrypt.
|
||||
* __`encTitleKeys.bin`__ / __`decTitleKeys.bin`__: These files are optional and provide titlekeys, which are required to decrypt and install contents downloaded from CDN (for DSi and 3DS content).
|
||||
|
||||
### Fonts and translations
|
||||
GodMode9 also supports custom fonts and translations as support files. These both use custom formats, fonts use FRF (Font RIFF) files which can be created using the `fontriff.py` Python script in the 'utils' folder. Translations use TRF (Translation RIFF) files from the `transriff.py` script. Examples of the inputs to these scripts can be found in the 'fonts' and 'languages' folders of the 'resources' folder respectively.
|
||||
|
||||
TRF files can be placed in `0:/gm9/languages` to show in the language menu accessible from the HOME menu and shown on first load. Official translations are provided from the community via the [GodMode9 Crowdin](https://crowdin.com/project/GodMode9). Languages can use a special font by having an FRF with the same name, for example `en.trf` and `en.frf`.
|
||||
|
||||
## Drives in GodMode9
|
||||
GodMode9 provides access to system data via drives, a listing of what each drive contains and additional info follows below. Some of these drives are removable (such as drive `7:`), some will only turn up if they are available (drive `8:` and everything associated with EmuNAND, f.e.). Information on the 3DS console file system is also found on [3Dbrew.org](https://3dbrew.org/wiki/Flash_Filesystem).
|
||||
@ -92,7 +88,7 @@ GodMode9 provides access to system data via drives, a listing of what each drive
|
||||
* __`K: AESKEYDB IMAGE`__: An `aeskeydb.bin` image can be mounted and accessed via this drive. The drive shows all keys inside the aeskeydb.bin. This is read-only.
|
||||
* __`T: TICKET.DB IMAGE / BDRI IMAGE`__: Ticket database files can be mounted and accessed via this drive. This provides easy and quick access to all tickets inside the `ticket.db`. This drive also provides access to other BDRI images, such as the Title database (`title.db`).
|
||||
* __`M: MEMORY VIRTUAL`__: This provides access to various memory regions. This is protected by a special write permission, and caution is advised when doing modifications inside this drive. This drive also gives access to `boot9.bin`, `boot11.bin` (boot9strap only) and `otp.mem` (sighaxed systems only).
|
||||
* __`V: VRAM VIRTUAL`__: This drive resides in part of ARM9 internal memory and contains files essential to GodMode9. The font (in FRF format), the splash logo (in PNG format) and the readme file are found there, as well as any file that is provided inside the `data` folder at build time. This is read-only.
|
||||
* __`V: VRAM VIRTUAL`__: This drive resides in the first VRAM bank and contains files essential to GodMode9. The font (in PBM format), the splash logo (in PNG format) and the readme file are found there, as well as any file that is provided inside the `data` folder at build time. This is read-only.
|
||||
* __`Y: TITLE MANAGER`__: The title manager is accessed via the HOME menu and provides easy access to all installed titles.
|
||||
* __`Z: LAST SEARCH`__: After a search operation, search results are found inside this drive. The drive can be accessed at a later point to return to the former search results.
|
||||
|
||||
@ -122,9 +118,8 @@ With the possibilites GodMode9 provides, not everything may be obvious at first
|
||||
* __Inject a file to another file__: Put exactly one file (the file to be injected from) into the clipboard (via the Y button). Press A on the file to be injected to. There will be an option to inject the first file into it.
|
||||
|
||||
### Scripting functionality
|
||||
* __Run .lua scripts from anywhere on your SD card__: You can run Lua scripts via the A button menu. For an overview of usable commands have a look into the documentation and sample scripts included in the release archive. *Don't run scripts from untrusted sources.*
|
||||
* __Run Lua scripts via a neat menu__: Press the HOME button, select `More...` -> `Lua scripts...`. Any script you put into `0:/gm9/luascripts` (subdirs included) will be found here. Scripts ran via this method won't have the confirmation at the beginning either.
|
||||
* __Run legacy .gm9 scripts__: The old format of .gm9 scripts is still available, but is deprecated and will see no further development.
|
||||
* __Run .gm9 scripts from anywhere on your SD card__: You can run scripts in .gm9 format via the A button menu. .gm9 scripts use a shell-like language and can be edited in any text editor. For an overview of usable commands have a look into the sample scripts included in the release archive. *Don't run scripts from untrusted sources.*
|
||||
* __Run .gm9 scripts via a neat menu__: Press the HOME button, select `More...` -> `Scripts...`. Any script you put into `0:/gm9/scripts` (subdirs included) will be found here. Scripts ran via this method won't have the confirmation at the beginning either.
|
||||
|
||||
### SD card handling
|
||||
* __Format your SD card / setup an EmuNAND__: Press the HOME button, select `More...` -> `SD format menu`. This also allows to setup a RedNAND (single/multi) or GW type EmuNAND on your SD card. You will get a warning prompt and an unlock sequence before any operation starts.
|
||||
@ -173,8 +168,8 @@ With the possibilites GodMode9 provides, not everything may be obvious at first
|
||||
## License
|
||||
You may use this under the terms of the GNU General Public License GPL v2 or under the terms of any later revisions of the GPL. Refer to the provided `LICENSE.txt` file for further information.
|
||||
|
||||
## Contact info
|
||||
You can chat directly with us via IRC @ #GodMode9 on [libera.chat](https://web.libera.chat/#GodMode9) or [Discord](https://discord.gg/BRcbvtFxX4)!
|
||||
## Conact info
|
||||
You can chat directly with us via IRC @ #GodMode9 on [libera.chat](https://web.libera.chat/) or [Discord](https://discord.gg/BRcbvtFxX4)!
|
||||
|
||||
## Credits
|
||||
This tool would not have been possible without the help of numerous people. Thanks go to (in no particular order)...
|
||||
@ -184,13 +179,9 @@ This tool would not have been possible without the help of numerous people. Than
|
||||
* **Wolfvak** for ARM11 code, FIRM binary launcher, exception handlers, PCX code, Makefile and for help on countless other occasions
|
||||
* **SciresM** for helping me figure out RomFS and for boot9strap
|
||||
* **SciresM**, **Myria**, **Normmatt**, **TuxSH** and **hedgeberg** for figuring out sighax and giving us access to bootrom
|
||||
* **ihaveamac** for implementing Lua support, and first developing the simple CIA generation method and for being of great help in porting it
|
||||
* **DarkRTA** for linker support during the implementation of Lua
|
||||
* **luigoalma** for fixing Lua to compile without issues
|
||||
* **Gruetzig** for re-implementing the Lua os module
|
||||
* **ihaveamac** for first developing the simple CIA generation method and for being of great help in porting it
|
||||
* **wwylele** and **aspargas2** for documenting and implementing the DISA, DIFF, and BDRI formats
|
||||
* **dratini0** for savefile management, based on [TWLSaveTool](https://github.com/TuxSH/TWLSaveTool/)
|
||||
* **Pk11** for unicode support and her ongoing work on GodMode9 translations and translation support
|
||||
* **b1l1s** for helping me figure out A9LH compatibility
|
||||
* **Gelex** and **AuroraWright** for helping me figure out various things
|
||||
* **stuckpixel** for the new 6x10 font and help on various things
|
||||
@ -207,7 +198,6 @@ This tool would not have been possible without the help of numerous people. Than
|
||||
* **Lilith Valentine** for testing and helpful advice
|
||||
* **Project Nayuki** for [qrcodegen](https://github.com/nayuki/QR-Code-generator)
|
||||
* **Amazingmax fonts** for the Amazdoom font
|
||||
* **TakWolf** for [fusion-pixel-font](https://github.com/TakWolf/fusion-pixel-font) used for Chinese and Korean
|
||||
* The fine folks on **the official GodMode9 IRC channel and Discord server**
|
||||
* The fine folks on **freenode #Cakey**
|
||||
* All **[3dbrew.org](https://www.3dbrew.org/wiki/Main_Page) editors**
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
PROCESSOR := ARM11
|
||||
|
||||
TARGET := $(shell basename "$(CURDIR)")
|
||||
TARGET := $(shell basename $(CURDIR))
|
||||
|
||||
SOURCE := source
|
||||
BUILD := build
|
||||
@ -11,7 +11,7 @@ INCLUDE := $(foreach dir,$(INCDIRS),-I"$(shell pwd)/$(dir)")
|
||||
|
||||
ASFLAGS += $(SUBARCH) $(INCLUDE)
|
||||
CFLAGS += $(SUBARCH) $(INCLUDE) -flto
|
||||
LDFLAGS += $(SUBARCH) -Wl,--use-blx,-Map,$(TARGET).map -flto
|
||||
LDFLAGS += $(SUBARCH) -Wl,-Map,$(TARGET).map -flto
|
||||
|
||||
include ../Makefile.common
|
||||
include ../Makefile.build
|
||||
|
||||
@ -16,7 +16,7 @@ SECTIONS
|
||||
__text_va = ABSOLUTE(.);
|
||||
*(.text*)
|
||||
. = ALIGN(4K);
|
||||
__text_va_end = .;
|
||||
__text_len = . - __text_va;
|
||||
} >AXIWRAM
|
||||
|
||||
.data : ALIGN(4K)
|
||||
@ -25,7 +25,7 @@ SECTIONS
|
||||
__data_va = ABSOLUTE(.);
|
||||
*(.data*)
|
||||
. = ALIGN(4K);
|
||||
__data_va_end = .;
|
||||
__data_len = . - __data_va;
|
||||
} >AXIWRAM
|
||||
|
||||
.rodata : ALIGN(4K)
|
||||
@ -34,7 +34,7 @@ SECTIONS
|
||||
__rodata_va = ABSOLUTE(.);
|
||||
*(.rodata*)
|
||||
. = ALIGN(4K);
|
||||
__rodata_va_end = .;
|
||||
__rodata_len = . - __rodata_va;
|
||||
} >AXIWRAM
|
||||
|
||||
.shared (NOLOAD) : ALIGN(4K)
|
||||
@ -43,7 +43,7 @@ SECTIONS
|
||||
__shared_va = ABSOLUTE(.);
|
||||
*(.shared*)
|
||||
. = ALIGN(4K);
|
||||
__shared_va_end = .;
|
||||
__shared_len = . - __shared_va;
|
||||
} >AXIWRAM
|
||||
|
||||
.bss (NOLOAD) : ALIGN(4K)
|
||||
@ -52,6 +52,6 @@ SECTIONS
|
||||
__bss_va = ABSOLUTE(.);
|
||||
*(.bss*)
|
||||
. = ALIGN(4K);
|
||||
__bss_va_end = .;
|
||||
__bss_len = . - __bss_va;
|
||||
} >AXIWRAM
|
||||
}
|
||||
|
||||
@ -76,12 +76,10 @@ __boot:
|
||||
b 1b
|
||||
|
||||
corezero_start:
|
||||
@ assumes the .bss section size is 128 byte aligned (or zero)
|
||||
@ assume __bss_len is 128 byte aligned
|
||||
ldr r0, =__bss_pa
|
||||
ldr r1, =__bss_va_end @ calculate the length of .bss using the VA start and end
|
||||
ldr r2, =__bss_va
|
||||
sub r1, r1, r2
|
||||
add r1, r0, r1 @ fixup to be PA start and end
|
||||
ldr r1, =__bss_len
|
||||
add r1, r0, r1
|
||||
mov r2, #0
|
||||
mov r3, #0
|
||||
mov r4, #0
|
||||
|
||||
@ -22,8 +22,6 @@
|
||||
|
||||
#include <stdatomic.h>
|
||||
|
||||
#include "common.h"
|
||||
|
||||
#include "arm/timer.h"
|
||||
|
||||
#include "hw/gpio.h"
|
||||
@ -118,13 +116,16 @@ u32 mcuGetSpecialHID(void)
|
||||
|
||||
void mcuSetStatusLED(u32 period_ms, u32 color)
|
||||
{
|
||||
u32 r, g, b, delay;
|
||||
u32 r, g, b;
|
||||
mcuStatusLED ledState;
|
||||
|
||||
delay = clamp((period_ms * 0x200) / 1000, 1, 0xFF);
|
||||
// handle proper non-zero periods
|
||||
// so small the hardware can't handle it
|
||||
if (period_ms != 0 && period_ms < 63)
|
||||
period_ms = 63;
|
||||
|
||||
ledState.delay = delay;
|
||||
ledState.smoothing = delay;
|
||||
ledState.delay = (period_ms * 0x10) / 1000;
|
||||
ledState.smoothing = 0x40;
|
||||
ledState.loop_delay = 0x10;
|
||||
ledState.unk = 0;
|
||||
|
||||
|
||||
@ -20,7 +20,7 @@
|
||||
|
||||
#include <types.h>
|
||||
|
||||
#define DEF_SECT_(n) extern u32 __##n##_pa, __##n##_va, __##n##_va_end;
|
||||
#define DEF_SECT_(n) extern u32 __##n##_pa, __##n##_va, __##n##_len;
|
||||
DEF_SECT_(text)
|
||||
DEF_SECT_(data)
|
||||
DEF_SECT_(rodata)
|
||||
@ -30,6 +30,6 @@ DEF_SECT_(shared)
|
||||
|
||||
#define SECTION_VA(n) ((u32)&__##n##_va)
|
||||
#define SECTION_PA(n) ((u32)&__##n##_pa)
|
||||
#define SECTION_LEN(n) (((u32)(&__##n##_va_end) - (u32)(&__##n##_va)))
|
||||
#define SECTION_LEN(n) ((u32)&__##n##_len)
|
||||
|
||||
#define SECTION_TRI(n) SECTION_VA(n), SECTION_PA(n), SECTION_LEN(n)
|
||||
|
||||
@ -1,24 +1,17 @@
|
||||
PROCESSOR := ARM9
|
||||
|
||||
TARGET := $(shell basename "$(CURDIR)")
|
||||
TARGET := $(shell basename $(CURDIR))
|
||||
|
||||
SOURCE := source
|
||||
BUILD := build
|
||||
|
||||
SUBARCH := -D$(PROCESSOR) -march=armv5te -mtune=arm946e-s -mthumb -mfloat-abi=soft
|
||||
INCDIRS := source source/common source/filesys source/crypto source/fatfs source/nand source/virtual source/game source/gamecart source/lodepng source/lua source/qrcodegen source/system source/utils
|
||||
INCDIRS := source source/common source/filesys source/crypto source/fatfs source/nand source/virtual source/game source/gamecart source/lodepng source/qrcodegen source/system source/utils
|
||||
INCLUDE := $(foreach dir,$(INCDIRS),-I"$(shell pwd)/$(dir)")
|
||||
|
||||
ASFLAGS += $(SUBARCH) $(INCLUDE)
|
||||
CFLAGS += $(SUBARCH) $(INCLUDE) -fno-builtin-memcpy -flto
|
||||
LDFLAGS += $(SUBARCH) -Wl,--use-blx,-Map,$(TARGET).map -flto
|
||||
LIBS += -lm
|
||||
LDFLAGS += $(SUBARCH) -Wl,-Map,$(TARGET).map -flto
|
||||
|
||||
include ../Makefile.common
|
||||
include ../Makefile.build
|
||||
|
||||
arm9_data.elf: arm9.elf
|
||||
$(OBJCOPY) -O elf32-littlearm -j .rodata* -j .data* -j .bss* $< $@
|
||||
|
||||
arm9_code.elf: arm9.elf
|
||||
$(OBJCOPY) -O elf32-littlearm -j .text* -j .vectors* $< $@
|
||||
|
||||
20
arm9/link.ld
20
arm9/link.ld
@ -4,10 +4,8 @@ ENTRY(_start)
|
||||
|
||||
MEMORY
|
||||
{
|
||||
AHBWRAM (RWX) : ORIGIN = 0x08006000, LENGTH = 512K
|
||||
VECTORS (RX) : ORIGIN = 0x08000000, LENGTH = 64
|
||||
CODEMEM (RX) : ORIGIN = 0x08000040, LENGTH = 512K - 64
|
||||
BOOTROM (R) : ORIGIN = 0x08080000, LENGTH = 128K /* BootROM mirrors, don't touch! */
|
||||
DATAMEM (RW) : ORIGIN = 0x080A0000, LENGTH = 384K
|
||||
}
|
||||
|
||||
SECTIONS
|
||||
@ -18,7 +16,7 @@ SECTIONS
|
||||
KEEP(*(.vectors));
|
||||
. = ALIGN(4);
|
||||
__vectors_len = ABSOLUTE(.) - __vectors_vma;
|
||||
} >VECTORS AT>CODEMEM
|
||||
} >VECTORS AT>AHBWRAM
|
||||
|
||||
.text : ALIGN(4) {
|
||||
__text_s = ABSOLUTE(.);
|
||||
@ -26,28 +24,24 @@ SECTIONS
|
||||
*(.text*);
|
||||
. = ALIGN(4);
|
||||
__text_e = ABSOLUTE(.);
|
||||
} >CODEMEM
|
||||
} >AHBWRAM
|
||||
|
||||
.rodata : ALIGN(4) {
|
||||
*(.rodata*);
|
||||
. = ALIGN(4);
|
||||
__exidx_start = .;
|
||||
*(.ARM.exidx* .gnu.linkonce.armexidx.*)
|
||||
__exidx_end = .;
|
||||
. = ALIGN(4);
|
||||
} >DATAMEM
|
||||
} >AHBWRAM
|
||||
|
||||
.data : ALIGN(4) {
|
||||
*(.data*);
|
||||
. = ALIGN(4);
|
||||
} >DATAMEM
|
||||
} >AHBWRAM
|
||||
|
||||
.bss (NOLOAD) : ALIGN(4) {
|
||||
.bss : ALIGN(4) {
|
||||
__bss_start = .;
|
||||
*(.bss*);
|
||||
. = ALIGN(4);
|
||||
__bss_end = .;
|
||||
} >DATAMEM
|
||||
} >AHBWRAM
|
||||
|
||||
__end__ = ABSOLUTE(.);
|
||||
}
|
||||
|
||||
@ -27,7 +27,7 @@ void CreateScreenshot(void) {
|
||||
|
||||
fvx_rmkdir(OUTPUT_PATH);
|
||||
get_dstime(&dstime);
|
||||
snprintf(filename, sizeof(filename), OUTPUT_PATH "/snap_%02X%02X%02X%02X%02X%02X.png",
|
||||
snprintf(filename, 64, OUTPUT_PATH "/snap_%02X%02X%02X%02X%02X%02X.png",
|
||||
dstime.bcd_Y, dstime.bcd_M, dstime.bcd_D,
|
||||
dstime.bcd_h, dstime.bcd_m, dstime.bcd_s);
|
||||
filename[63] = '\0';
|
||||
|
||||
@ -1,10 +1,8 @@
|
||||
#include <stdarg.h>
|
||||
|
||||
#include "language.h"
|
||||
#include "swkbd.h"
|
||||
#include "timer.h"
|
||||
#include "hid.h"
|
||||
#include "utf.h"
|
||||
|
||||
|
||||
static inline char to_uppercase(char c) {
|
||||
@ -81,7 +79,7 @@ static void DrawKey(const TouchBox* key, const bool pressed, const u32 uppercase
|
||||
if (key->id == KEY_TXTBOX) return;
|
||||
|
||||
char keystr[16];
|
||||
if (key->id >= 0x80) snprintf(keystr, sizeof(keystr), "%s", keystrs[key->id - 0x80]);
|
||||
if (key->id >= 0x80) snprintf(keystr, 16, "%s", keystrs[key->id - 0x80]);
|
||||
else {
|
||||
keystr[0] = (uppercase) ? to_uppercase(key->id) : key->id;
|
||||
keystr[1] = 0;
|
||||
@ -92,7 +90,7 @@ static void DrawKey(const TouchBox* key, const bool pressed, const u32 uppercase
|
||||
const u32 f_offs_y = (key->h - FONT_HEIGHT_EXT) / 2;
|
||||
|
||||
DrawRectangle(BOT_SCREEN, key->x, key->y, key->w, key->h, color);
|
||||
DrawString(BOT_SCREEN, keystr, key->x + f_offs_x, key->y + f_offs_y, COLOR_SWKBD_CHARS, color);
|
||||
DrawString(BOT_SCREEN, keystr, key->x + f_offs_x, key->y + f_offs_y, COLOR_SWKBD_CHARS, color, false);
|
||||
}
|
||||
|
||||
static void DrawKeyBoardBox(TouchBox* swkbd, u32 color) {
|
||||
@ -121,50 +119,34 @@ static void DrawKeyBoard(TouchBox* swkbd, const u32 uppercase) {
|
||||
}
|
||||
|
||||
static void DrawTextBox(const TouchBox* txtbox, const char* inputstr, const u32 cursor, u32* scroll) {
|
||||
const u32 input_shown_length = (txtbox->w / FONT_WIDTH_EXT) - 2;
|
||||
const u32 input_shown = (txtbox->w / FONT_WIDTH_EXT) - 2;
|
||||
const u32 inputstr_size = strlen(inputstr); // we rely on a zero terminated string
|
||||
const u16 x = txtbox->x;
|
||||
const u16 y = txtbox->y;
|
||||
|
||||
// fix scroll
|
||||
if (cursor < *scroll) {
|
||||
*scroll = cursor;
|
||||
} else {
|
||||
int scroll_adjust = -input_shown_length;
|
||||
for (u32 i = *scroll; i < cursor; i++) {
|
||||
if (i >= inputstr_size || (inputstr[i] & 0xC0) != 0x80) scroll_adjust++;
|
||||
}
|
||||
|
||||
for (int i = 0; i < scroll_adjust; i++)
|
||||
*scroll += *scroll >= inputstr_size ? 1 : GetCharSize(inputstr + *scroll);
|
||||
}
|
||||
|
||||
u32 input_shown_size = 0;
|
||||
for (u32 i = 0; i < input_shown_length || (*scroll + input_shown_size < inputstr_size && (inputstr[*scroll + input_shown_size] & 0xC0) == 0x80); input_shown_size++) {
|
||||
if (*scroll + input_shown_size >= inputstr_size || (inputstr[*scroll + input_shown_size] & 0xC0) != 0x80) i++;
|
||||
}
|
||||
if (cursor < *scroll) *scroll = cursor;
|
||||
else if (cursor - *scroll > input_shown) *scroll = cursor - input_shown;
|
||||
|
||||
// draw input string
|
||||
DrawStringF(BOT_SCREEN, x, y, COLOR_STD_FONT, COLOR_STD_BG, "%c%-*.*s%c",
|
||||
DrawStringF(BOT_SCREEN, x, y, COLOR_STD_FONT, COLOR_STD_BG, "%c%-*.*s%-*.*s%c",
|
||||
(*scroll) ? '<' : '|',
|
||||
(int) input_shown_size,
|
||||
(int) input_shown_size,
|
||||
(inputstr_size > input_shown) ? input_shown : inputstr_size,
|
||||
(inputstr_size > input_shown) ? input_shown : inputstr_size,
|
||||
(*scroll > inputstr_size) ? "" : inputstr + *scroll,
|
||||
(inputstr_size - (s32) *scroll > input_shown_size) ? '>' : '|'
|
||||
(inputstr_size > input_shown) ? 0 : input_shown - inputstr_size,
|
||||
(inputstr_size > input_shown) ? 0 : input_shown - inputstr_size,
|
||||
"",
|
||||
(inputstr_size - (s32) *scroll > input_shown) ? '>' : '|'
|
||||
);
|
||||
|
||||
// draw cursor
|
||||
u16 cpos = 0;
|
||||
for (u16 i = *scroll; i < cursor; i++) {
|
||||
if (i >= inputstr_size || (inputstr[i] & 0xC0) != 0x80) cpos++;
|
||||
}
|
||||
|
||||
DrawStringF(BOT_SCREEN, x-(FONT_WIDTH_EXT/2), y+10, COLOR_STD_FONT, COLOR_STD_BG, "%-*.*s^%-*.*s",
|
||||
(int) (1 + cpos),
|
||||
(int) (1 + cpos),
|
||||
1 + cursor - *scroll,
|
||||
1 + cursor - *scroll,
|
||||
"",
|
||||
(int) (input_shown_length - cpos),
|
||||
(int) (input_shown_length - cpos),
|
||||
input_shown - (cursor - *scroll),
|
||||
input_shown - (cursor - *scroll),
|
||||
""
|
||||
);
|
||||
}
|
||||
@ -181,17 +163,8 @@ static void MoveTextBoxCursor(const TouchBox* txtbox, const char* inputstr, cons
|
||||
const TouchBox* tb = TouchBoxGet(&id, x, y, txtbox, 0);
|
||||
if (id == KEY_TXTBOX) {
|
||||
u16 x_tb = x - tb->x;
|
||||
|
||||
const u32 inputstr_size = strlen(inputstr);
|
||||
const u16 cpos_x = (x_tb < (FONT_WIDTH_EXT/2)) ? 0 : (x_tb - (FONT_WIDTH_EXT/2)) / FONT_WIDTH_EXT;
|
||||
u16 cpos_length = 0;
|
||||
u16 cpos_size = 0;
|
||||
while ((cpos_length < cpos_x && cpos_length < input_shown) || (*scroll + cpos_size < inputstr_size && (inputstr[*scroll + cpos_size] & 0xC0) == 0x80)) {
|
||||
if (*scroll + cpos_size >= inputstr_size || (inputstr[*scroll + cpos_size] & 0xC0) != 0x80) cpos_length++;
|
||||
cpos_size++;
|
||||
}
|
||||
|
||||
u32 cursor_next = *scroll + cpos_size;
|
||||
u16 cpos = (x_tb < (FONT_WIDTH_EXT/2)) ? 0 : (x_tb - (FONT_WIDTH_EXT/2)) / FONT_WIDTH_EXT;
|
||||
u32 cursor_next = *scroll + ((cpos <= input_shown) ? cpos : input_shown);
|
||||
// move cursor to position pointed to
|
||||
if (*cursor != cursor_next) {
|
||||
if (cursor_next < max_size) *cursor = cursor_next;
|
||||
@ -200,10 +173,10 @@ static void MoveTextBoxCursor(const TouchBox* txtbox, const char* inputstr, cons
|
||||
}
|
||||
// move beyound visible field
|
||||
if (timer_msec(timer) >= scroll_cooldown) {
|
||||
if ((cpos_length == 0) && (*scroll > 0))
|
||||
*scroll -= GetPrevCharSize(inputstr + *scroll);
|
||||
else if ((cpos_length >= input_shown) && (*cursor < (max_size-1)))
|
||||
*scroll += GetCharSize(inputstr + *scroll);
|
||||
if ((cpos == 0) && (*scroll > 0))
|
||||
(*scroll)--;
|
||||
else if ((cpos >= input_shown) && (*cursor < (max_size-1)))
|
||||
(*scroll)++;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -254,9 +227,9 @@ bool ShowKeyboard(char* inputstr, const u32 max_size, const char *format, ...) {
|
||||
TouchBox* textbox = swkbd_alphabet; // always use this textbox
|
||||
|
||||
static bool show_instr = true;
|
||||
const char* instr = STR_KEYBOARD_CONTROLS_DETAILS;
|
||||
static const char* instr = "Keyboard Controls:\n \n\x1B/\x1A - Move cursor\nR - Caps / Capslock\nX - Delete char\nY - Insert char\nA - Submit\nB - Cancel\n \nSELECT switches to\nclassic prompt";
|
||||
if (show_instr) {
|
||||
ShowPrompt(false, "%s", instr);
|
||||
ShowPrompt(false, instr);
|
||||
show_instr = false;
|
||||
}
|
||||
|
||||
@ -269,7 +242,7 @@ bool ShowKeyboard(char* inputstr, const u32 max_size, const char *format, ...) {
|
||||
char str[512]; // arbitrary limit, should be more than enough
|
||||
va_list va;
|
||||
va_start(va, format);
|
||||
vsnprintf(str, sizeof(str), format, va);
|
||||
vsnprintf(str, 512, format, va);
|
||||
va_end(va);
|
||||
u32 str_width = GetDrawStringWidth(str);
|
||||
if (str_width < (24 * FONT_WIDTH_EXT)) str_width = 24 * FONT_WIDTH_EXT;
|
||||
@ -313,18 +286,16 @@ bool ShowKeyboard(char* inputstr, const u32 max_size, const char *format, ...) {
|
||||
break;
|
||||
} else if (key == KEY_BKSPC) {
|
||||
if (cursor) {
|
||||
int size = GetPrevCharSize(inputstr + cursor);
|
||||
if (cursor <= inputstr_size) {
|
||||
memmove(inputstr + cursor - size, inputstr + cursor, inputstr_size - cursor + size);
|
||||
inputstr_size -= size;
|
||||
memmove(inputstr + cursor - 1, inputstr + cursor, inputstr_size - cursor + 1);
|
||||
inputstr_size--;
|
||||
}
|
||||
cursor -= size;
|
||||
cursor--;
|
||||
}
|
||||
} else if (key == KEY_LEFT) {
|
||||
if (cursor) cursor -= GetPrevCharSize(inputstr + cursor);
|
||||
if (cursor) cursor--;
|
||||
} else if (key == KEY_RIGHT) {
|
||||
int size = cursor > inputstr_size ? 1 : GetCharSize(inputstr + cursor);
|
||||
if (cursor + size < max_size) cursor += size;
|
||||
if (cursor < (max_size-1)) cursor++;
|
||||
} else if (key == KEY_ALPHA) {
|
||||
swkbd = swkbd_alphabet;
|
||||
} else if (key == KEY_SPECIAL) {
|
||||
@ -333,31 +304,7 @@ bool ShowKeyboard(char* inputstr, const u32 max_size, const char *format, ...) {
|
||||
swkbd = swkbd_numpad;
|
||||
} else if (key == KEY_SWITCH) {
|
||||
ClearScreen(BOT_SCREEN, COLOR_STD_BG);
|
||||
return ShowStringPrompt(inputstr, max_size, "%s", str);
|
||||
} else if (key == KEY_UNICODE) {
|
||||
if (cursor > 3 && cursor <= inputstr_size) {
|
||||
u16 codepoint = 0;
|
||||
for (char *c = inputstr + cursor - 4; c < inputstr + cursor; c++) {
|
||||
if ((*c >= '0' && *c <= '9') || (*c >= 'A' && *c <= 'F') || (*c >= 'a' && *c <= 'f')) {
|
||||
codepoint <<= 4;
|
||||
codepoint |= *c - (*c <= '9' ? '0' : ((*c <= 'F' ? 'A' : 'a') - 10));
|
||||
} else {
|
||||
codepoint = 0;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if(codepoint != 0) {
|
||||
char character[5] = {0};
|
||||
u16 input[2] = {codepoint, 0};
|
||||
utf16_to_utf8((u8*)character, input, 4, 1);
|
||||
|
||||
u32 char_size = GetCharSize(character);
|
||||
memmove(inputstr + cursor - 4 + char_size, inputstr + cursor, max_size - cursor + 4 - char_size);
|
||||
memcpy(inputstr + cursor - 4, character, char_size);
|
||||
cursor -= 4 - char_size;
|
||||
}
|
||||
}
|
||||
return ShowStringPrompt(inputstr, max_size, str);
|
||||
} else if (key && (key < 0x80)) {
|
||||
if ((cursor < (max_size-1)) && (inputstr_size < max_size)) {
|
||||
// pad string (if cursor beyound string size)
|
||||
|
||||
@ -19,12 +19,11 @@ enum {
|
||||
KEY_RIGHT = 0x89,
|
||||
KEY_ESCAPE = 0x8A,
|
||||
KEY_SWITCH = 0x8B,
|
||||
KEY_UNICODE = 0x8C,
|
||||
KEY_TXTBOX = 0xFF
|
||||
};
|
||||
|
||||
// special key strings
|
||||
#define SWKBD_KEYSTR "", "DEL", "INS", "SUBMIT", "CAPS", "#$@", "123", "ABC", "←", "→", "ESC", "SWITCH", "U+"
|
||||
#define SWKBD_KEYSTR "", "DEL", "INS", "SUBMIT", "CAPS", "#$@", "123", "ABC", "\x1b", "\x1a", "ESC", "SWITCH"
|
||||
|
||||
#define COLOR_SWKBD_NORMAL COLOR_GREY
|
||||
#define COLOR_SWKBD_PRESSED COLOR_LIGHTGREY
|
||||
@ -57,7 +56,7 @@ enum {
|
||||
'4', '5', '6', 'D', 'C', \
|
||||
'3', '2', '1', 'B', 'A', \
|
||||
'0', '.', '_', KEY_LEFT, KEY_RIGHT, \
|
||||
KEY_ALPHA, KEY_UNICODE, ' ', KEY_BKSPC
|
||||
KEY_ALPHA, ' ', KEY_BKSPC
|
||||
|
||||
// offset, num of keys in row, width of special keys (...), 0
|
||||
#define SWKBD_LAYOUT_ALPHABET \
|
||||
@ -81,9 +80,9 @@ enum {
|
||||
5, 0, \
|
||||
5, 0, \
|
||||
5, 18, 18, 0, \
|
||||
4, 20, 20, 31, 20, 0, \
|
||||
3, 30, 34, 30, 0, \
|
||||
0
|
||||
|
||||
|
||||
#define ShowKeyboardOrPrompt (TouchIsCalibrated() ? ShowKeyboard : ShowStringPrompt)
|
||||
bool PRINTF_ARGS(3) ShowKeyboard(char* inputstr, u32 max_size, const char *format, ...);
|
||||
bool ShowKeyboard(char* inputstr, u32 max_size, const char *format, ...);
|
||||
|
||||
@ -2,7 +2,6 @@
|
||||
#include "ui.h"
|
||||
#include "hid.h"
|
||||
#include "crc16.h"
|
||||
#include "language.h"
|
||||
#include "spiflash.h"
|
||||
#include "support.h"
|
||||
|
||||
@ -47,8 +46,8 @@ bool ShowTouchCalibrationDialog(void)
|
||||
|
||||
// clear screen, draw instructions
|
||||
ClearScreen(BOT_SCREEN, COLOR_STD_BG);
|
||||
DrawStringCenter(BOT_SCREEN, COLOR_STD_FONT, COLOR_STD_BG, "%s",
|
||||
STR_TOUCH_CROSSHAIRS_TO_CALIBRATE_TOUCHSCREEN_USE_STYLUS);
|
||||
DrawStringCenter(BOT_SCREEN, COLOR_STD_FONT, COLOR_STD_BG,
|
||||
"Touch the red crosshairs to\ncalibrate your touchscreen.\n \nUse the stylus for best\nresults!");
|
||||
|
||||
// set calibration defaults
|
||||
SetCalibrationDefaults();
|
||||
|
||||
@ -15,134 +15,21 @@
|
||||
#include "power.h"
|
||||
#include "hid.h"
|
||||
#include "fixp.h"
|
||||
#include "language.h"
|
||||
|
||||
#define STRBUF_SIZE 512 // maximum size of the string buffer
|
||||
#define FONT_MAX_WIDTH 8
|
||||
#define FONT_MAX_HEIGHT 10
|
||||
#define PROGRESS_REFRESH_RATE 30 // the progress bar is only allowed to draw to screen every X milliseconds
|
||||
|
||||
typedef struct {
|
||||
char chunk_id[4]; // NOT null terminated
|
||||
u32 size;
|
||||
} RiffChunkHeader;
|
||||
|
||||
typedef struct {
|
||||
u8 width;
|
||||
u8 height;
|
||||
u16 count;
|
||||
} FontMeta;
|
||||
|
||||
static u32 font_width = 0;
|
||||
static u32 font_height = 0;
|
||||
static u32 font_count = 0;
|
||||
static u32 line_height = 0;
|
||||
static u8* font_bin = NULL;
|
||||
static u16* font_map = NULL;
|
||||
static u16 ascii_lut[0x60];
|
||||
|
||||
// lookup table to sort CP-437 so it can be binary searched with Unicode codepoints
|
||||
static const u8 cp437_sorted[0x100] = {
|
||||
0x00, 0xF5, 0xF6, 0xFC, 0xFD, 0xFB, 0xFA, 0xA4, 0xF3, 0xF2, 0xF4, 0xF9, 0xF8, 0xFE, 0xFF, 0xF7,
|
||||
0xEF, 0xF1, 0xAD, 0xA5, 0x6D, 0x65, 0xED, 0xAE, 0xA9, 0xAB, 0xAA, 0xA8, 0xB2, 0xAC, 0xEE, 0xF0,
|
||||
0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10,
|
||||
0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20,
|
||||
0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, 0x30,
|
||||
0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F, 0x40,
|
||||
0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x50,
|
||||
0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x5B, 0x5C, 0x5D, 0x5E, 0x5F, 0xB8,
|
||||
0x77, 0x95, 0x85, 0x7F, 0x80, 0x7D, 0x81, 0x83, 0x86, 0x87, 0x84, 0x8B, 0x8A, 0x88, 0x74, 0x75,
|
||||
0x78, 0x82, 0x76, 0x8F, 0x90, 0x8D, 0x94, 0x92, 0x96, 0x7A, 0x7B, 0x62, 0x63, 0x64, 0xA7, 0x97,
|
||||
0x7E, 0x89, 0x8E, 0x93, 0x8C, 0x79, 0x66, 0x6F, 0x73, 0xB9, 0x68, 0x72, 0x71, 0x61, 0x67, 0x70,
|
||||
0xE9, 0xEA, 0xEB, 0xBD, 0xC3, 0xD8, 0xD9, 0xCD, 0xCC, 0xDA, 0xC8, 0xCE, 0xD4, 0xD3, 0xD2, 0xBF,
|
||||
0xC0, 0xC5, 0xC4, 0xC2, 0xBC, 0xC6, 0xD5, 0xD6, 0xD1, 0xCB, 0xE0, 0xDD, 0xD7, 0xC7, 0xE3, 0xDE,
|
||||
0xDF, 0xDB, 0xDC, 0xD0, 0xCF, 0xC9, 0xCA, 0xE2, 0xE1, 0xC1, 0xBE, 0xE6, 0xE5, 0xE7, 0xE8, 0xE4,
|
||||
0x9D, 0x7C, 0x98, 0xA0, 0x9A, 0xA1, 0x6C, 0xA2, 0x9B, 0x99, 0x9C, 0x9E, 0xB1, 0xA3, 0x9F, 0xB3,
|
||||
0xB5, 0x6A, 0xB7, 0xB6, 0xBA, 0xBB, 0x91, 0xB4, 0x69, 0xAF, 0x6E, 0xB0, 0xA6, 0x6B, 0xEC, 0x60
|
||||
};
|
||||
|
||||
// Unicode font mapping for sorted CP-437
|
||||
static const u16 cp437_sorted_map[0x100] = {
|
||||
0x0000, 0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027, 0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E,
|
||||
0x002F, 0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037, 0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E,
|
||||
0x003F, 0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047, 0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E,
|
||||
0x004F, 0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057, 0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E,
|
||||
0x005F, 0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067, 0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E,
|
||||
0x006F, 0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077, 0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E,
|
||||
0x00A0, 0x00A1, 0x00A2, 0x00A3, 0x00A5, 0x00A7, 0x00AA, 0x00AB, 0x00AC, 0x00B0, 0x00B1, 0x00B2, 0x00B5, 0x00B6, 0x00B7, 0x00BA,
|
||||
0x00BB, 0x00BC, 0x00BD, 0x00BF, 0x00C4, 0x00C5, 0x00C6, 0x00C7, 0x00C9, 0x00D1, 0x00D6, 0x00DC, 0x00DF, 0x00E0, 0x00E1, 0x00E2,
|
||||
0x00E4, 0x00E5, 0x00E6, 0x00E7, 0x00E8, 0x00E9, 0x00EA, 0x00EB, 0x00EC, 0x00ED, 0x00EE, 0x00EF, 0x00F1, 0x00F2, 0x00F3, 0x00F4,
|
||||
0x00F6, 0x00F7, 0x00F9, 0x00FA, 0x00FB, 0x00FC, 0x00FF, 0x0192, 0x0393, 0x0398, 0x03A3, 0x03A6, 0x03A9, 0x03B1, 0x03B4, 0x03B5,
|
||||
0x03C0, 0x03C3, 0x03C4, 0x03C6, 0x2022, 0x203C, 0x207F, 0x20A7, 0x2190, 0x2191, 0x2192, 0x2193, 0x2194, 0x2195, 0x21A8, 0x2219,
|
||||
0x221A, 0x221E, 0x221F, 0x2229, 0x2248, 0x2261, 0x2264, 0x2265, 0x2302, 0x2310, 0x2320, 0x2321, 0x2500, 0x2502, 0x250C, 0x2510,
|
||||
0x2514, 0x2518, 0x251C, 0x2524, 0x252C, 0x2534, 0x253C, 0x2550, 0x2551, 0x2552, 0x2553, 0x2554, 0x2555, 0x2556, 0x2557, 0x2558,
|
||||
0x2559, 0x255A, 0x255B, 0x255C, 0x255D, 0x255E, 0x255F, 0x2560, 0x2561, 0x2562, 0x2563, 0x2564, 0x2565, 0x2566, 0x2567, 0x2568,
|
||||
0x2569, 0x256A, 0x256B, 0x256C, 0x2580, 0x2584, 0x2588, 0x258C, 0x2590, 0x2591, 0x2592, 0x2593, 0x25A0, 0x25AC, 0x25B2, 0x25BA,
|
||||
0x25BC, 0x25C4, 0x25CB, 0x25D8, 0x25D9, 0x263A, 0x263B, 0x263C, 0x2640, 0x2642, 0x2660, 0x2663, 0x2665, 0x2666, 0x266A, 0x266B
|
||||
};
|
||||
|
||||
// lookup table to convert the old CP-437 escapes to Unicode
|
||||
static const u16 cp437_escapes[0x20] = {
|
||||
0x0000, 0x263A, 0x263B, 0x2665, 0x2666, 0x2663, 0x2660, 0x2022, 0x25D8, 0x25CB, 0x25D9, 0x2642, 0x2640, 0x266A, 0x266B, 0x263C,
|
||||
0x25BA, 0x25C4, 0x2195, 0x203C, 0x00B6, 0x00A7, 0x25AC, 0x21A8, 0x2191, 0x2193, 0x2192, 0x2190, 0x221F, 0x2194, 0x25B2, 0x25BC
|
||||
};
|
||||
static u8 font_bin[FONT_MAX_HEIGHT * 256];
|
||||
|
||||
#define PIXEL_OFFSET(x, y) (((x) * SCREEN_HEIGHT) + (SCREEN_HEIGHT - (y) - 1))
|
||||
|
||||
|
||||
u16 GetFontIndex(u16 c, bool use_ascii_lut)
|
||||
{
|
||||
if (c < 0x20) return GetFontIndex(cp437_escapes[c], use_ascii_lut);
|
||||
else if (use_ascii_lut && c < 0x80) return ascii_lut[c - 0x20];
|
||||
|
||||
int left = 0;
|
||||
int right = font_count;
|
||||
|
||||
while (left <= right) {
|
||||
int mid = left + ((right - left) / 2);
|
||||
if (font_map[mid] == c)
|
||||
return mid;
|
||||
|
||||
if (font_map[mid] < c)
|
||||
left = mid + 1;
|
||||
else
|
||||
right = mid - 1;
|
||||
}
|
||||
|
||||
// if not found in font, return a '?'
|
||||
return ascii_lut['?' - 0x20];
|
||||
}
|
||||
|
||||
// gets a u32 codepoint from a UTF-8 string and moves the pointer to the next character
|
||||
u32 GetCharacter(const char** str)
|
||||
{
|
||||
u32 c;
|
||||
|
||||
if ((**str & 0x80) == 0) {
|
||||
c = *(*str)++;
|
||||
} else if ((**str & 0xE0) == 0xC0) {
|
||||
c = (*(*str)++ & 0x1F) << 6;
|
||||
c |= *(*str)++ & 0x3F;
|
||||
} else if ((**str & 0xF0) == 0xE0) {
|
||||
c = (*(*str)++ & 0x0F) << 12;
|
||||
c |= (*(*str)++ & 0x3F) << 6;
|
||||
c |= *(*str)++ & 0x3F;
|
||||
} else if ((**str & 0xF8) == 0xF0) {
|
||||
c = (*(*str)++ & 0x07) << 18;
|
||||
c |= (*(*str)++ & 0x3F) << 12;
|
||||
c |= (*(*str)++ & 0x3F) << 6;
|
||||
c |= *(*str)++ & 0x3F;
|
||||
} else {
|
||||
// invalid UTF-8, skip to next character
|
||||
(*str)++;
|
||||
c = '?';
|
||||
}
|
||||
|
||||
return c;
|
||||
}
|
||||
|
||||
const u8* GetFontFromPbm(const void* pbm, const u32 pbm_size, u32* w, u32* h) {
|
||||
const char* hdr = (const char*) pbm;
|
||||
u8* GetFontFromPbm(const void* pbm, const u32 pbm_size, u32* w, u32* h) {
|
||||
char* hdr = (char*) pbm;
|
||||
u32 hdr_max_size = min(512, pbm_size);
|
||||
u32 pbm_w = 0;
|
||||
u32 pbm_h = 0;
|
||||
@ -203,101 +90,27 @@ const u8* GetFontFromPbm(const void* pbm, const u32 pbm_size, u32* w, u32* h) {
|
||||
return (u8*) pbm + p;
|
||||
}
|
||||
|
||||
const u8* GetFontFromRiff(const void* riff, const u32 riff_size, u32* w, u32* h, u16* count) {
|
||||
const void* ptr = riff;
|
||||
const RiffChunkHeader* riff_header;
|
||||
const RiffChunkHeader* chunk_header;
|
||||
|
||||
// check header magic and load size
|
||||
if (!ptr) return NULL;
|
||||
riff_header = ptr;
|
||||
if (memcmp(riff_header->chunk_id, "RIFF", 4) != 0) return NULL;
|
||||
|
||||
// ensure enough space is allocated
|
||||
if (riff_header->size > riff_size) return NULL;
|
||||
|
||||
ptr += sizeof(RiffChunkHeader);
|
||||
|
||||
while ((u32)(ptr - riff) < riff_header->size + sizeof(RiffChunkHeader)) {
|
||||
chunk_header = ptr;
|
||||
|
||||
// check for and load META section
|
||||
if (memcmp(chunk_header->chunk_id, "META", 4) == 0) {
|
||||
|
||||
if (chunk_header->size != 4) return NULL;
|
||||
|
||||
const FontMeta *meta = ptr + sizeof(RiffChunkHeader);
|
||||
if (meta->width > FONT_MAX_WIDTH || meta->height > FONT_MAX_HEIGHT) return NULL;
|
||||
|
||||
// all good
|
||||
if (w) *w = meta->width;
|
||||
if (h) *h = meta->height;
|
||||
if (count) *count = meta->count;
|
||||
return ptr;
|
||||
}
|
||||
|
||||
ptr += sizeof(RiffChunkHeader) + chunk_header->size;
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
// sets the font from a given RIFF or PBM
|
||||
// if no font is given, the font is fetched from the default VRAM0 location
|
||||
bool SetFont(const void* font, u32 font_size) {
|
||||
// sets the font from a given PBM
|
||||
// if no PBM is given, the PBM is fetched from the default VRAM0 location
|
||||
bool SetFontFromPbm(const void* pbm, u32 pbm_size) {
|
||||
u32 w, h;
|
||||
u16 count;
|
||||
const u8* ptr = NULL;
|
||||
u8* ptr = NULL;
|
||||
|
||||
if (!font) {
|
||||
u64 font_size64 = 0;
|
||||
font = FindVTarFileInfo(VRAM0_FONT, &font_size64);
|
||||
font_size = (u32) font_size64;
|
||||
if (!pbm) {
|
||||
u64 pbm_size64 = 0;
|
||||
pbm = FindVTarFileInfo(VRAM0_FONT_PBM, &pbm_size64);
|
||||
pbm_size = (u32) pbm_size64;
|
||||
}
|
||||
|
||||
if (!font)
|
||||
if (pbm)
|
||||
ptr = GetFontFromPbm(pbm, pbm_size, &w, &h);
|
||||
|
||||
if (!ptr) {
|
||||
return false;
|
||||
|
||||
if ((ptr = GetFontFromRiff(font, font_size, &w, &h, &count))) { // RIFF font
|
||||
font_width = w;
|
||||
font_height = h;
|
||||
font_count = count;
|
||||
|
||||
const RiffChunkHeader* riff_header;
|
||||
const RiffChunkHeader* chunk_header;
|
||||
|
||||
// load total size
|
||||
riff_header = font;
|
||||
|
||||
while (((u32)ptr - (u32)font) < riff_header->size + sizeof(RiffChunkHeader)) {
|
||||
chunk_header = (const void *)ptr;
|
||||
|
||||
if (memcmp(chunk_header->chunk_id, "CDAT", 4) == 0) { // character data
|
||||
if (font_bin) free(font_bin);
|
||||
font_bin = malloc(font_height * font_count);
|
||||
if (!font_bin) return NULL;
|
||||
|
||||
memcpy(font_bin, ptr + sizeof(RiffChunkHeader), font_height * font_count);
|
||||
} else if (memcmp(chunk_header->chunk_id, "CMAP", 4) == 0) { // character map
|
||||
if (font_map) free(font_map);
|
||||
font_map = malloc(sizeof(u16) * font_count);
|
||||
if (!font_map) return NULL;
|
||||
|
||||
memcpy(font_map, ptr + sizeof(RiffChunkHeader), sizeof(u16) * font_count);
|
||||
}
|
||||
|
||||
ptr += sizeof(RiffChunkHeader) + chunk_header->size;
|
||||
}
|
||||
} else if ((ptr = GetFontFromPbm(font, font_size, &w, &h))) {
|
||||
font_count = 0x100;
|
||||
|
||||
if (w > 8) {
|
||||
} else if (w > 8) {
|
||||
font_width = w / 16;
|
||||
font_height = h / 16;
|
||||
|
||||
if (font_bin) free(font_bin);
|
||||
font_bin = malloc(font_height * font_count);
|
||||
if (!font_bin) return NULL;
|
||||
memset(font_bin, 0x00, w * h / 8);
|
||||
|
||||
for (u32 cy = 0; cy < 16; cy++) {
|
||||
for (u32 row = 0; row < font_height; row++) {
|
||||
@ -305,7 +118,7 @@ bool SetFont(const void* font, u32 font_size) {
|
||||
u32 bp0 = (cx * font_width) >> 3;
|
||||
u32 bm0 = (cx * font_width) % 8;
|
||||
u8 byte = ((ptr[bp0] << bm0) | (ptr[bp0+1] >> (8 - bm0))) & (0xFF << (8 - font_width));
|
||||
font_bin[(cp437_sorted[(cy << 4) + cx] * font_height) + row] = byte;
|
||||
font_bin[(((cy << 4) + cx) * font_height) + row] = byte;
|
||||
}
|
||||
ptr += font_width << 1;
|
||||
}
|
||||
@ -313,24 +126,7 @@ bool SetFont(const void* font, u32 font_size) {
|
||||
} else {
|
||||
font_width = w;
|
||||
font_height = h / 256;
|
||||
for (u32 i = 0; i < font_count; i++)
|
||||
memcpy(font_bin + cp437_sorted[i] * font_height, ptr + i * font_height, font_height);
|
||||
}
|
||||
|
||||
if (font_map) free(font_map);
|
||||
font_map = malloc(sizeof(u16) * font_count);
|
||||
if (!font_map) return NULL;
|
||||
|
||||
memcpy(font_map, cp437_sorted_map, sizeof(cp437_sorted_map));
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
// set up ASCII lookup table
|
||||
ascii_lut['?' - 0x20] = GetFontIndex('?', false);
|
||||
for (int i = 0; i < 0x60; i++) {
|
||||
ascii_lut[i] = GetFontIndex(i + 0x20, false);
|
||||
memcpy(font_bin, ptr, h);
|
||||
}
|
||||
|
||||
line_height = min(10, font_height + 2);
|
||||
@ -426,14 +222,14 @@ void DrawQrCode(u16 *screen, const u8* qrcode)
|
||||
}
|
||||
}
|
||||
|
||||
void DrawCharacter(u16 *screen, u32 character, int x, int y, u32 color, u32 bgcolor)
|
||||
void DrawCharacter(u16 *screen, int character, int x, int y, u32 color, u32 bgcolor)
|
||||
{
|
||||
for (int yy = 0; yy < (int) font_height; yy++) {
|
||||
int xDisplacement = x * SCREEN_HEIGHT;
|
||||
int yDisplacement = SCREEN_HEIGHT - (y + yy) - 1;
|
||||
u16* screenPos = screen + xDisplacement + yDisplacement;
|
||||
|
||||
u8 charPos = font_bin[GetFontIndex(character, true) * font_height + yy];
|
||||
u8 charPos = font_bin[character * font_height + yy];
|
||||
for (int xx = 7; xx >= (8 - (int) font_width); xx--) {
|
||||
if ((charPos >> xx) & 1) {
|
||||
*screenPos = color;
|
||||
@ -445,12 +241,14 @@ void DrawCharacter(u16 *screen, u32 character, int x, int y, u32 color, u32 bgco
|
||||
}
|
||||
}
|
||||
|
||||
void DrawString(u16 *screen, const char *str, int x, int y, u32 color, u32 bgcolor)
|
||||
void DrawString(u16 *screen, const char *str, int x, int y, u32 color, u32 bgcolor, bool fix_utf8)
|
||||
{
|
||||
size_t max_len = (((screen == TOP_SCREEN) ? SCREEN_WIDTH_TOP : SCREEN_WIDTH_BOT) - x) / font_width;
|
||||
size_t len = (strlen(str) > max_len) ? max_len : strlen(str);
|
||||
|
||||
for (size_t i = 0; i < max_len && *str; i++) {
|
||||
DrawCharacter(screen, GetCharacter(&str), x + i * font_width, y, color, bgcolor);
|
||||
for (size_t i = 0; i < len; i++) {
|
||||
char c = (char) (fix_utf8 && str[i] >= 0x80) ? '?' : str[i];
|
||||
DrawCharacter(screen, c, x + i * font_width, y, color, bgcolor);
|
||||
}
|
||||
}
|
||||
|
||||
@ -463,7 +261,7 @@ void DrawStringF(u16 *screen, int x, int y, u32 color, u32 bgcolor, const char *
|
||||
va_end(va);
|
||||
|
||||
for (char* text = strtok(str, "\n"); text != NULL; text = strtok(NULL, "\n"), y += line_height)
|
||||
DrawString(screen, text, x, y, color, bgcolor);
|
||||
DrawString(screen, text, x, y, color, bgcolor, true);
|
||||
}
|
||||
|
||||
void DrawStringCenter(u16 *screen, u32 color, u32 bgcolor, const char *format, ...)
|
||||
@ -489,44 +287,16 @@ u32 GetDrawStringHeight(const char* str) {
|
||||
return height;
|
||||
}
|
||||
|
||||
u32 GetCharSize(const char* str) {
|
||||
const char *start = str;
|
||||
do {
|
||||
str++;
|
||||
} while ((*str & 0xC0) == 0x80);
|
||||
|
||||
return str - start;
|
||||
}
|
||||
|
||||
u32 GetPrevCharSize(const char* str) {
|
||||
const char *start = str;
|
||||
do {
|
||||
str--;
|
||||
} while ((*str & 0xC0) == 0x80);
|
||||
|
||||
return start - str;
|
||||
}
|
||||
|
||||
u32 GetDrawStringWidth(const char* str) {
|
||||
u32 width = 0;
|
||||
char* old_lf = (char*) str;
|
||||
char* str_end = (char*) str + strnlen(str, STRBUF_SIZE);
|
||||
for (char* lf = strchr(str, '\n'); lf != NULL; lf = strchr(lf + 1, '\n')) {
|
||||
u32 length = 0;
|
||||
for (char* c = old_lf; c != lf; c++) {
|
||||
if ((*c & 0xC0) != 0x80) length++;
|
||||
}
|
||||
|
||||
if (length > width) width = length;
|
||||
if ((u32) (lf - old_lf) > width) width = lf - old_lf;
|
||||
old_lf = lf;
|
||||
}
|
||||
|
||||
u32 length = 0;
|
||||
for (char* c = old_lf; c != str_end; c++) {
|
||||
if ((*c & 0xC0) != 0x80) length++;
|
||||
}
|
||||
|
||||
if (length > width) width = length;
|
||||
if ((u32) (str_end - old_lf) > width)
|
||||
width = str_end - old_lf;
|
||||
width *= font_width;
|
||||
return width;
|
||||
}
|
||||
@ -580,50 +350,26 @@ void WordWrapString(char* str, int llen) {
|
||||
}
|
||||
}
|
||||
|
||||
// dest must be at least 4x the size of nlength to account for UTF-8
|
||||
void ResizeString(char* dest, const char* orig, int nlength, int tpos, bool align_right) {
|
||||
int olength = 0;
|
||||
for (int i = 0; i < 256 && orig[i]; i++) {
|
||||
if ((orig[i] & 0xC0) != 0x80) olength++;
|
||||
}
|
||||
|
||||
if (nlength < olength) {
|
||||
TruncateString(dest, orig, nlength, tpos);
|
||||
} else {
|
||||
int nsize = 0;
|
||||
void ResizeString(char* dest, const char* orig, int nsize, int tpos, bool align_right) {
|
||||
int osize = strnlen(orig, 256);
|
||||
for (int i = 0; i < nlength || (nsize <= osize && (orig[nsize] & 0xC0) == 0x80); nsize++) {
|
||||
if (nsize > osize || (orig[nsize] & 0xC0) != 0x80) i++;
|
||||
}
|
||||
snprintf(dest, UTF_BUFFER_BYTESIZE(nlength), align_right ? "%*.*s" : "%-*.*s", nsize, nsize, orig);
|
||||
if (nsize < osize) {
|
||||
TruncateString(dest, orig, nsize, tpos);
|
||||
} else if (!align_right) {
|
||||
snprintf(dest, nsize + 1, "%-*.*s", nsize, nsize, orig);
|
||||
} else {
|
||||
snprintf(dest, nsize + 1, "%*.*s", nsize, nsize, orig);
|
||||
}
|
||||
}
|
||||
|
||||
// dest must be at least 4x the size of nlength to account for UTF-8
|
||||
void TruncateString(char* dest, const char* orig, int nlength, int tpos) {
|
||||
int osize = strnlen(orig, 256), olength = 0;
|
||||
for (int i = 0; i < 256 && orig[i]; i++) {
|
||||
if ((orig[i] & 0xC0) != 0x80) olength++;
|
||||
}
|
||||
|
||||
if (nlength < 0) {
|
||||
void TruncateString(char* dest, const char* orig, int nsize, int tpos) {
|
||||
int osize = strnlen(orig, 256);
|
||||
if (nsize < 0) {
|
||||
return;
|
||||
} else if ((nlength <= 3) || (nlength >= olength)) {
|
||||
strcpy(dest, orig);
|
||||
} else if ((nsize <= 3) || (nsize >= osize)) {
|
||||
snprintf(dest, nsize + 1, "%s", orig);
|
||||
} else {
|
||||
if (tpos + 3 > nlength) tpos = nlength - 3;
|
||||
|
||||
int tposStart = 0;
|
||||
for (int i = 0; i < tpos || (orig[tposStart] & 0xC0) == 0x80; tposStart++) {
|
||||
if ((orig[tposStart] & 0xC0) != 0x80) i++;
|
||||
}
|
||||
|
||||
int tposEnd = 0;
|
||||
for (int i = 0; i < nlength - tpos - 3; tposEnd++) {
|
||||
if ((orig[osize - 1 - tposEnd] & 0xC0) != 0x80) i++;
|
||||
}
|
||||
|
||||
snprintf(dest, UTF_BUFFER_BYTESIZE(nlength), "%-.*s...%-.*s", tposStart, orig, tposEnd, orig + osize - tposEnd);
|
||||
if (tpos + 3 > nsize) tpos = nsize - 3;
|
||||
snprintf(dest, nsize + 1, "%-.*s...%-.*s", tpos, orig, nsize - (3 + tpos), orig + osize - (nsize - (3 + tpos)));
|
||||
}
|
||||
}
|
||||
|
||||
@ -633,20 +379,20 @@ void FormatNumber(char* str, u64 number) { // str should be 32 byte in size
|
||||
for (; number / (mag1000 * 1000) > 0; mag1000 *= 1000);
|
||||
for (; mag1000 > 0; mag1000 /= 1000) {
|
||||
u32 pos = strnlen(str, 31);
|
||||
snprintf(str + pos, 31 - pos, "%0*llu%s", (pos) ? 3 : 1, (number / mag1000) % 1000, (mag1000 > 1) ? STR_THOUSAND_SEPARATOR : "");
|
||||
snprintf(str + pos, 31 - pos, "%0*llu%c", (pos) ? 3 : 1, (number / mag1000) % 1000, (mag1000 > 1) ? ',' : '\0');
|
||||
}
|
||||
}
|
||||
|
||||
void FormatBytes(char* str, u64 bytes) { // str should be 32 byte in size, just to be safe
|
||||
const char* units[] = {STR_BYTE, STR_KB, STR_MB, STR_GB};
|
||||
const char* units[] = {" Byte", " kB", " MB", " GB"};
|
||||
|
||||
if (bytes == (u64) -1) snprintf(str, 32, "%s", STR_INVALID);
|
||||
if (bytes == (u64) -1) snprintf(str, 32, "INVALID");
|
||||
else if (bytes < 1024) snprintf(str, 32, "%llu%s", bytes, units[0]);
|
||||
else {
|
||||
u32 scale = 1;
|
||||
u64 bytes100 = (bytes * 100) >> 10;
|
||||
for(; (bytes100 >= 1024*100) && (scale < 3); scale++, bytes100 >>= 10);
|
||||
snprintf(str, 32, "%llu%s%llu%s", bytes100 / 100, STR_DECIMAL_SEPARATOR, (bytes100 % 100) / 10, units[scale]);
|
||||
snprintf(str, 32, "%llu.%llu%s", bytes100 / 100, (bytes100 % 100) / 10, units[scale]);
|
||||
}
|
||||
}
|
||||
|
||||
@ -713,7 +459,7 @@ void ShowIconString(u16* icon, int w, int h, const char *format, ...)
|
||||
vsnprintf(str, STRBUF_SIZE, format, va);
|
||||
va_end(va);
|
||||
|
||||
ShowIconStringF(MAIN_SCREEN, icon, w, h, "%s", str);
|
||||
ShowIconStringF(MAIN_SCREEN, icon, w, h, str);
|
||||
}
|
||||
|
||||
bool ShowPrompt(bool ask, const char *format, ...)
|
||||
@ -728,7 +474,7 @@ bool ShowPrompt(bool ask, const char *format, ...)
|
||||
|
||||
ClearScreenF(true, false, COLOR_STD_BG);
|
||||
DrawStringCenter(MAIN_SCREEN, COLOR_STD_FONT, COLOR_STD_BG, "%s\n \n%s", str,
|
||||
(ask) ? STR_A_YES_B_NO : STR_A_TO_CONTINUE);
|
||||
(ask) ? "(<A> yes, <B> no)" : "(<A> to continue)");
|
||||
|
||||
while (true) {
|
||||
u32 pad_state = InputWait(0);
|
||||
@ -783,13 +529,13 @@ bool ShowUnlockSequence(u32 seqlvl, const char *format, ...) {
|
||||
ClearScreenF(true, false, color_bg);
|
||||
DrawStringF(MAIN_SCREEN, x, y, color_font, color_bg, "%s", str);
|
||||
#ifndef TIMER_UNLOCK
|
||||
DrawStringF(MAIN_SCREEN, x, y + str_height - 28, color_font, color_bg, "%s", STR_TO_PROCEED_ENTER_THIS);
|
||||
DrawStringF(MAIN_SCREEN, x, y + str_height - 28, color_font, color_bg, "To proceed, enter this:");
|
||||
|
||||
// generate sequence
|
||||
const char *dpad_symbols[] = { "→", "←", "↑", "↓" }; // R L U D
|
||||
const char dpad_symbols[] = { '\x1A', '\x1B', '\x18', '\x19' }; // R L U D
|
||||
|
||||
u32 sequence[seqlen_max];
|
||||
const char *seqsymbols[seqlen_max];
|
||||
char seqsymbols[seqlen_max];
|
||||
u32 lastlsh = (u32) -1;
|
||||
for (u32 n = 0; n < (seqlen-1); n++) {
|
||||
u32 lsh = lastlsh;
|
||||
@ -799,13 +545,13 @@ bool ShowUnlockSequence(u32 seqlvl, const char *format, ...) {
|
||||
seqsymbols[n] = dpad_symbols[lsh];
|
||||
}
|
||||
sequence[seqlen-1] = BUTTON_A;
|
||||
seqsymbols[seqlen-1] = "A";
|
||||
seqsymbols[seqlen-1] = 'A';
|
||||
|
||||
|
||||
while (true) {
|
||||
for (u32 n = 0; n < seqlen; n++) {
|
||||
DrawStringF(MAIN_SCREEN, x + (n*4*FONT_WIDTH_EXT), y + str_height - 28 + line_height,
|
||||
(lvl > n) ? color_on : color_off, color_bg, "<%s>", seqsymbols[n]);
|
||||
(lvl > n) ? color_on : color_off, color_bg, "<%c>", seqsymbols[n]);
|
||||
}
|
||||
if (lvl == seqlen)
|
||||
break;
|
||||
@ -820,7 +566,7 @@ bool ShowUnlockSequence(u32 seqlvl, const char *format, ...) {
|
||||
lvl = 0;
|
||||
}
|
||||
#else
|
||||
DrawStringF(MAIN_SCREEN, x, y + str_height - 28, color_font, color_bg, STR_TO_PROCEED_HOLD_X);
|
||||
DrawStringF(MAIN_SCREEN, x, y + str_height - 28, color_font, color_bg, "To proceed, hold <X>:");
|
||||
|
||||
while (!CheckButton(BUTTON_B)) {
|
||||
for (u32 n = 0; n < seqlen; n++) {
|
||||
@ -847,11 +593,10 @@ bool ShowUnlockSequence(u32 seqlvl, const char *format, ...) {
|
||||
}
|
||||
#endif
|
||||
|
||||
u32 ShowSelectPrompt(int n, const char** options, const char *format, ...) {
|
||||
u32 ShowSelectPrompt(u32 n, const char** options, const char *format, ...) {
|
||||
u32 str_width, str_height;
|
||||
u32 x, y, yopt;
|
||||
int sel = 0, scroll = 0;
|
||||
int n_show = min(n, 10);
|
||||
u32 sel = 0;
|
||||
|
||||
char str[STRBUF_SIZE];
|
||||
va_list va;
|
||||
@ -863,64 +608,30 @@ u32 ShowSelectPrompt(int n, const char** options, const char *format, ...) {
|
||||
// else if (n == 1) return ShowPrompt(true, "%s\n%s?", str, options[0]) ? 1 : 0;
|
||||
|
||||
str_width = GetDrawStringWidth(str);
|
||||
str_height = GetDrawStringHeight(str) + (n_show * (line_height + 2)) + (3 * line_height);
|
||||
str_height = GetDrawStringHeight(str) + (n * (line_height + 2)) + (3 * line_height);
|
||||
if (str_width < 24 * font_width) str_width = 24 * font_width;
|
||||
for (int i = 0; i < n; i++) if (str_width < GetDrawStringWidth(options[i]) + (3 * font_width))
|
||||
str_width = GetDrawStringWidth(options[i]) + (3 * font_width);
|
||||
for (u32 i = 0; i < n; i++) if (str_width < GetDrawStringWidth(options[i]))
|
||||
str_width = GetDrawStringWidth(options[i]);
|
||||
x = (str_width >= SCREEN_WIDTH_MAIN) ? 0 : (SCREEN_WIDTH_MAIN - str_width) / 2;
|
||||
y = (str_height >= SCREEN_HEIGHT) ? 0 : (SCREEN_HEIGHT - str_height) / 2;
|
||||
yopt = y + GetDrawStringHeight(str) + 8;
|
||||
|
||||
ClearScreenF(true, false, COLOR_STD_BG);
|
||||
DrawStringF(MAIN_SCREEN, x, y, COLOR_STD_FONT, COLOR_STD_BG, "%s", str);
|
||||
DrawStringF(MAIN_SCREEN, x, yopt + (n_show*(line_height+2)) + line_height, COLOR_STD_FONT, COLOR_STD_BG, "%s", STR_A_SELECT_B_CANCEL);
|
||||
DrawStringF(MAIN_SCREEN, x, yopt + (n*(line_height+2)) + line_height, COLOR_STD_FONT, COLOR_STD_BG, "(<A> select, <B> cancel)");
|
||||
while (true) {
|
||||
for (int i = scroll; i < scroll+n_show; i++) {
|
||||
DrawStringF(MAIN_SCREEN, x, yopt + ((line_height+2)*(i-scroll)), (sel == i) ? COLOR_STD_FONT : COLOR_LIGHTGREY, COLOR_STD_BG, "%2.2s %s",
|
||||
for (u32 i = 0; i < n; i++) {
|
||||
DrawStringF(MAIN_SCREEN, x, yopt + ((line_height+2)*i), (sel == i) ? COLOR_STD_FONT : COLOR_LIGHTGREY, COLOR_STD_BG, "%2.2s %s",
|
||||
(sel == i) ? "->" : "", options[i]);
|
||||
}
|
||||
|
||||
// show [n more]
|
||||
if (n - n_show - scroll > 0) {
|
||||
char more_str[UTF_BUFFER_BYTESIZE(str_width / font_width)], temp_str[UTF_BUFFER_BYTESIZE(64)];
|
||||
snprintf(temp_str, sizeof(temp_str), STR_N_MORE, (n - (n_show-1) - scroll));
|
||||
ResizeString(more_str, temp_str, str_width / font_width, 8, false);
|
||||
DrawString(MAIN_SCREEN, more_str, x, yopt + (line_height+2)*(n_show-1), COLOR_LIGHTGREY, COLOR_STD_BG);
|
||||
}
|
||||
// show scroll bar
|
||||
u32 bar_x = x + str_width + 2;
|
||||
const u32 flist_height = (n_show * (line_height + 2));
|
||||
const u32 bar_width = 2;
|
||||
if (n > n_show) { // draw position bar at the right
|
||||
const u32 bar_height_min = 32;
|
||||
u32 bar_height = (n_show * flist_height) / n;
|
||||
if (bar_height < bar_height_min) bar_height = bar_height_min;
|
||||
const u32 bar_y = ((u64) scroll * (flist_height - bar_height)) / (n - n_show) + yopt;
|
||||
|
||||
DrawRectangle(MAIN_SCREEN, bar_x, bar_y, bar_width, bar_height, COLOR_SIDE_BAR);
|
||||
}
|
||||
|
||||
u32 pad_state = InputWait(0);
|
||||
if (pad_state & BUTTON_DOWN) sel = (sel+1) % n;
|
||||
else if (pad_state & BUTTON_UP) sel = (sel+n-1) % n;
|
||||
else if (pad_state & BUTTON_RIGHT) sel += n_show;
|
||||
else if (pad_state & BUTTON_LEFT) sel -= n_show;
|
||||
else if (pad_state & BUTTON_A) break;
|
||||
else if (pad_state & BUTTON_B) {
|
||||
sel = n;
|
||||
break;
|
||||
}
|
||||
if (sel < 0) sel = 0;
|
||||
else if (sel >= n) sel = n-1;
|
||||
|
||||
int prev_scroll = scroll;
|
||||
if (sel < scroll) scroll = sel;
|
||||
else if (sel == n-1 && sel >= (scroll + n_show - 1)) scroll = sel - n_show + 1;
|
||||
else if (sel >= (scroll + (n_show-1) - 1)) scroll = sel - (n_show-1) + 1;
|
||||
|
||||
if (scroll != prev_scroll) {
|
||||
DrawRectangle(MAIN_SCREEN, x + font_width * 3, yopt, str_width + 4, (n_show * (line_height + 2)), COLOR_STD_BG);
|
||||
}
|
||||
}
|
||||
|
||||
ClearScreenF(true, false, COLOR_STD_BG);
|
||||
@ -928,12 +639,12 @@ u32 ShowSelectPrompt(int n, const char** options, const char *format, ...) {
|
||||
return (sel >= n) ? 0 : sel + 1;
|
||||
}
|
||||
|
||||
u32 ShowFileScrollPrompt(int n, const DirEntry** options, bool hide_ext, const char *format, ...) {
|
||||
u32 ShowFileScrollPrompt(u32 n, const DirEntry** options, bool hide_ext, const char *format, ...) {
|
||||
u32 str_height, fname_len;
|
||||
u32 x, y, yopt;
|
||||
const u32 item_width = SCREEN_WIDTH(MAIN_SCREEN) - 40;
|
||||
int sel = 0, scroll = 0;
|
||||
int n_show = min(n, 10);
|
||||
u32 n_show = min(n, 10);
|
||||
|
||||
char str[STRBUF_SIZE];
|
||||
va_list va;
|
||||
@ -952,13 +663,13 @@ u32 ShowFileScrollPrompt(int n, const DirEntry** options, bool hide_ext, const c
|
||||
|
||||
ClearScreenF(true, false, COLOR_STD_BG);
|
||||
DrawStringF(MAIN_SCREEN, x, y, COLOR_STD_FONT, COLOR_STD_BG, "%s", str);
|
||||
DrawStringF(MAIN_SCREEN, x, yopt + (n_show*(line_height+2)) + line_height, COLOR_STD_FONT, COLOR_STD_BG, "%s", STR_A_SELECT_B_CANCEL);
|
||||
DrawStringF(MAIN_SCREEN, x, yopt + (n_show*(line_height+2)) + line_height, COLOR_STD_FONT, COLOR_STD_BG, "(<A> select, <B> cancel)");
|
||||
while (true) {
|
||||
for (int i = scroll; i < scroll+n_show; i++) {
|
||||
for (u32 i = scroll; i < scroll+n_show; i++) {
|
||||
char bytestr[16];
|
||||
FormatBytes(bytestr, options[i]->size);
|
||||
|
||||
char content_str[UTF_BUFFER_BYTESIZE(fname_len)];
|
||||
char content_str[64 + 1];
|
||||
char temp_str[256];
|
||||
strncpy(temp_str, options[i]->name, 256);
|
||||
|
||||
@ -968,19 +679,18 @@ u32 ShowFileScrollPrompt(int n, const DirEntry** options, bool hide_ext, const c
|
||||
ResizeString(content_str, temp_str, fname_len, 8, false);
|
||||
|
||||
DrawStringF(MAIN_SCREEN, x, yopt + ((line_height+2)*(i-scroll)),
|
||||
(sel == i) ? COLOR_STD_FONT : COLOR_ENTRY(options[i]), COLOR_STD_BG, "%2.2s %s",
|
||||
(sel == i) ? "->" : "", content_str);
|
||||
(sel == (int)i) ? COLOR_STD_FONT : COLOR_ENTRY(options[i]), COLOR_STD_BG, "%2.2s %s",
|
||||
(sel == (int)i) ? "->" : "", content_str);
|
||||
|
||||
DrawStringF(MAIN_SCREEN, x + item_width - font_width * 11, yopt + ((line_height+2)*(i-scroll)),
|
||||
(sel == i) ? COLOR_STD_FONT : COLOR_ENTRY(options[i]), COLOR_STD_BG, "%10.10s",
|
||||
(options[i]->type == T_DIR) ? STR_DIR : (options[i]->type == T_DOTDOT) ? "(..)" : bytestr);
|
||||
(sel == (int)i) ? COLOR_STD_FONT : COLOR_ENTRY(options[i]), COLOR_STD_BG, "%10.10s",
|
||||
(options[i]->type == T_DIR) ? "(dir)" : (options[i]->type == T_DOTDOT) ? "(..)" : bytestr);
|
||||
}
|
||||
// show [n more]
|
||||
if (n - n_show - scroll > 0) {
|
||||
char more_str[UTF_BUFFER_BYTESIZE(item_width / font_width)], temp_str[UTF_BUFFER_BYTESIZE(64)];
|
||||
snprintf(temp_str, sizeof(temp_str), STR_N_MORE, (n - (n_show-1) - scroll));
|
||||
ResizeString(more_str, temp_str, item_width / font_width, 8, false);
|
||||
DrawString(MAIN_SCREEN, more_str, x, yopt + (line_height+2)*(n_show-1), COLOR_LIGHTGREY, COLOR_STD_BG);
|
||||
if (n - n_show - scroll) {
|
||||
char more_str[64 + 1];
|
||||
snprintf(more_str, 64, " [%d more]", (int)(n - (n_show-1) - scroll));
|
||||
DrawStringF(MAIN_SCREEN, x, yopt + (line_height+2)*(n_show-1), COLOR_LIGHTGREY, COLOR_STD_BG, "%-*s", item_width / font_width, more_str);
|
||||
}
|
||||
// show scroll bar
|
||||
u32 bar_x = x + item_width + 2;
|
||||
@ -998,8 +708,8 @@ u32 ShowFileScrollPrompt(int n, const DirEntry** options, bool hide_ext, const c
|
||||
} else DrawRectangle(MAIN_SCREEN, bar_x, yopt, bar_width, flist_height, COLOR_STD_BG);
|
||||
|
||||
u32 pad_state = InputWait(0);
|
||||
if (pad_state & BUTTON_DOWN) sel = (sel+1) % n;
|
||||
else if (pad_state & BUTTON_UP) sel = (sel+n-1) % n;
|
||||
if (pad_state & BUTTON_DOWN) sel++;
|
||||
else if (pad_state & BUTTON_UP) sel--;
|
||||
else if (pad_state & BUTTON_RIGHT) sel += n_show;
|
||||
else if (pad_state & BUTTON_LEFT) sel -= n_show;
|
||||
else if (pad_state & BUTTON_A) break;
|
||||
@ -1008,15 +718,15 @@ u32 ShowFileScrollPrompt(int n, const DirEntry** options, bool hide_ext, const c
|
||||
break;
|
||||
}
|
||||
if (sel < 0) sel = 0;
|
||||
else if (sel >= n) sel = n-1;
|
||||
else if (sel >= (int)n) sel = n-1;
|
||||
if (sel < scroll) scroll = sel;
|
||||
else if (sel == n-1 && sel >= (scroll + n_show - 1)) scroll = sel - n_show + 1;
|
||||
else if (sel >= (scroll + (n_show-1) - 1)) scroll = sel - (n_show-1) + 1;
|
||||
else if (sel == (int) n-1 && sel >= (int)(scroll + n_show - 1)) scroll = sel - n_show + 1;
|
||||
else if (sel >= (int)(scroll + (n_show-1) - 1)) scroll = sel - (n_show-1) + 1;
|
||||
}
|
||||
|
||||
ClearScreenF(true, false, COLOR_STD_BG);
|
||||
|
||||
return (sel >= n) ? 0 : sel + 1;
|
||||
return (sel >= (int)n) ? 0 : sel + 1;
|
||||
}
|
||||
|
||||
u32 ShowHotkeyPrompt(u32 n, const char** options, const u32* keys, const char *format, ...) {
|
||||
@ -1033,7 +743,7 @@ u32 ShowHotkeyPrompt(u32 n, const char** options, const u32* keys, const char *f
|
||||
ButtonToString(keys[i], buttonstr);
|
||||
ptr += snprintf(ptr, STRBUF_SIZE - (ptr-str), "\n<%s> %s", buttonstr, options[i]);
|
||||
}
|
||||
ptr += snprintf(ptr, STRBUF_SIZE - (ptr-str), "\n \n<%s> %s", "B", STR_CANCEL);
|
||||
ptr += snprintf(ptr, STRBUF_SIZE - (ptr-str), "\n \n<%s> %s", "B", "cancel");
|
||||
|
||||
ClearScreenF(true, false, COLOR_STD_BG);
|
||||
DrawStringCenter(MAIN_SCREEN, COLOR_STD_FONT, COLOR_STD_BG, "%s", str);
|
||||
@ -1056,7 +766,7 @@ u32 ShowHotkeyPrompt(u32 n, const char** options, const u32* keys, const char *f
|
||||
|
||||
bool ShowInputPrompt(char* inputstr, u32 max_size, u32 resize, const char* alphabet, const char *format, va_list va) {
|
||||
const u32 alphabet_size = strnlen(alphabet, 256);
|
||||
const u32 input_shown_length = 22;
|
||||
const u32 input_shown = 22;
|
||||
const u32 fast_scroll = 4;
|
||||
const u64 aprv_delay = 128;
|
||||
|
||||
@ -1082,7 +792,7 @@ bool ShowInputPrompt(char* inputstr, u32 max_size, u32 resize, const char* alpha
|
||||
ClearScreenF(true, false, COLOR_STD_BG);
|
||||
DrawStringF(MAIN_SCREEN, x, y, COLOR_STD_FONT, COLOR_STD_BG, "%s", str);
|
||||
DrawStringF(MAIN_SCREEN, x + 8, y + str_height - 40, COLOR_STD_FONT, COLOR_STD_BG,
|
||||
"%s\n%s", STR_R_FAST_SCROLL_L_CLEAR_DATA, resize ? STR_X_REMOVE_CHAR_Y_INSERT_CHAR : "");
|
||||
"R - (\x18\x19) fast scroll\nL - clear data%s", resize ? "\nX - remove char\nY - insert char" : "");
|
||||
|
||||
// wait for all keys released
|
||||
while (HID_ReadState() & BUTTON_ANY);
|
||||
@ -1095,43 +805,25 @@ bool ShowInputPrompt(char* inputstr, u32 max_size, u32 resize, const char* alpha
|
||||
|
||||
while (true) {
|
||||
u32 inputstr_size = strnlen(inputstr, max_size - 1);
|
||||
|
||||
if (cursor_s < scroll) {
|
||||
scroll = cursor_s;
|
||||
} else {
|
||||
int scroll_adjust = -input_shown_length;
|
||||
for (u32 i = scroll; i < cursor_s; i++) {
|
||||
if (i >= inputstr_size || (inputstr[i] & 0xC0) != 0x80) scroll_adjust++;
|
||||
}
|
||||
|
||||
for (int i = 0; i <= scroll_adjust; i++)
|
||||
scroll += scroll >= inputstr_size ? 1 : GetCharSize(inputstr + scroll);
|
||||
}
|
||||
|
||||
u32 input_shown_size = 0;
|
||||
for (u32 i = 0; i < input_shown_length || (scroll + input_shown_size < inputstr_size && (inputstr[scroll + input_shown_size] & 0xC0) == 0x80); input_shown_size++) {
|
||||
if (scroll + input_shown_size >= inputstr_size || (inputstr[scroll + input_shown_size] & 0xC0) != 0x80) i++;
|
||||
}
|
||||
|
||||
u16 cpos = 0;
|
||||
for (u16 i = scroll; i < cursor_s; i++) {
|
||||
if (i >= inputstr_size || (inputstr[i] & 0xC0) != 0x80) cpos++;
|
||||
}
|
||||
|
||||
DrawStringF(MAIN_SCREEN, x, y + str_height - 76, COLOR_STD_FONT, COLOR_STD_BG, "%c%-*.*s%c\n%-*.*s^%-*.*s",
|
||||
if (cursor_s < scroll) scroll = cursor_s;
|
||||
else if (cursor_s - scroll >= input_shown) scroll = cursor_s - input_shown + 1;
|
||||
while (scroll && (inputstr_size - scroll < input_shown)) scroll--;
|
||||
DrawStringF(MAIN_SCREEN, x, y + str_height - 76, COLOR_STD_FONT, COLOR_STD_BG, "%c%-*.*s%c%-*.*s\n%-*.*s^%-*.*s",
|
||||
(scroll) ? '<' : '|',
|
||||
(int) input_shown_size,
|
||||
(int) input_shown_size,
|
||||
(scroll > inputstr_size) ? "" : inputstr + scroll,
|
||||
(inputstr_size - (s32) scroll > input_shown_size) ? '>' : '|',
|
||||
(int) 1 + cpos,
|
||||
(int) 1 + cpos,
|
||||
(inputstr_size > input_shown) ? input_shown : inputstr_size,
|
||||
(inputstr_size > input_shown) ? input_shown : inputstr_size,
|
||||
inputstr + scroll,
|
||||
(inputstr_size - scroll > input_shown) ? '>' : '|',
|
||||
(inputstr_size > input_shown) ? 0 : input_shown - inputstr_size,
|
||||
(inputstr_size > input_shown) ? 0 : input_shown - inputstr_size,
|
||||
"",
|
||||
(int) input_shown_length - cpos,
|
||||
(int) input_shown_length - cpos,
|
||||
1 + cursor_s - scroll,
|
||||
1 + cursor_s - scroll,
|
||||
"",
|
||||
input_shown - (cursor_s - scroll),
|
||||
input_shown - (cursor_s - scroll),
|
||||
""
|
||||
);
|
||||
|
||||
if (cursor_a < 0) {
|
||||
for (cursor_a = alphabet_size - 1; (cursor_a > 0) && (alphabet[cursor_a] != inputstr[cursor_s]); cursor_a--);
|
||||
}
|
||||
@ -1171,26 +863,11 @@ bool ShowInputPrompt(char* inputstr, u32 max_size, u32 resize, const char* alpha
|
||||
}
|
||||
} else if (pad_state & BUTTON_X) {
|
||||
if (resize && (inputstr_size > resize)) {
|
||||
u32 char_index = 0;
|
||||
for(u32 i = 0; i < cursor_s; i++) {
|
||||
if (i >= inputstr_size || (inputstr[i] & 0xC0) != 0x80) char_index++;
|
||||
}
|
||||
|
||||
u32 to_index = char_index - (char_index % resize);
|
||||
u32 from_index = to_index + resize;
|
||||
|
||||
char* inputto = inputstr + cursor_s;
|
||||
for (u32 i = 0; i < char_index - to_index; i++) {
|
||||
inputto -= GetPrevCharSize(inputto);
|
||||
}
|
||||
char* inputfrom = inputto;
|
||||
for (u32 i = 0; i < from_index - to_index; i++) {
|
||||
inputfrom += GetCharSize(inputfrom);
|
||||
}
|
||||
|
||||
char* inputfrom = inputstr + cursor_s - (cursor_s % resize) + resize;
|
||||
char* inputto = inputstr + cursor_s - (cursor_s % resize);
|
||||
memmove(inputto, inputfrom, max_size - (inputfrom - inputstr));
|
||||
inputstr_size -= inputfrom - inputto;
|
||||
while (cursor_s >= inputstr_size || (inputstr[cursor_s] & 0xC0) == 0x80)
|
||||
inputstr_size -= resize;
|
||||
while (cursor_s >= inputstr_size)
|
||||
cursor_s--;
|
||||
cursor_a = -1;
|
||||
} else if (resize == 1) {
|
||||
@ -1207,29 +884,18 @@ bool ShowInputPrompt(char* inputstr, u32 max_size, u32 resize, const char* alpha
|
||||
cursor_a = 0;
|
||||
}
|
||||
} else if (pad_state & BUTTON_UP) {
|
||||
int size = GetCharSize(inputstr + cursor_s);
|
||||
if(size > 1) {
|
||||
memmove(inputstr + cursor_s, inputstr + cursor_s + size - 1, inputstr_size - cursor_s + size - 1);
|
||||
}
|
||||
|
||||
cursor_a += (pad_state & BUTTON_R1) ? fast_scroll : 1;
|
||||
cursor_a = cursor_a % alphabet_size;
|
||||
inputstr[cursor_s] = alphabet[cursor_a];
|
||||
} else if (pad_state & BUTTON_DOWN) {
|
||||
int size = GetCharSize(inputstr + cursor_s);
|
||||
if(size > 1) {
|
||||
memmove(inputstr + cursor_s, inputstr + cursor_s + size - 1, inputstr_size - cursor_s + size - 1);
|
||||
}
|
||||
|
||||
cursor_a -= (pad_state & BUTTON_R1) ? fast_scroll : 1;
|
||||
if (cursor_a < 0) cursor_a = alphabet_size + cursor_a;
|
||||
inputstr[cursor_s] = alphabet[cursor_a];
|
||||
} else if (pad_state & BUTTON_LEFT) {
|
||||
if (cursor_s > 0) cursor_s -= GetPrevCharSize(inputstr + cursor_s);
|
||||
if (cursor_s > 0) cursor_s--;
|
||||
cursor_a = -1;
|
||||
} else if (pad_state & BUTTON_RIGHT) {
|
||||
int size = cursor_s > inputstr_size ? 1 : GetCharSize(inputstr + cursor_s);
|
||||
if (cursor_s + size < max_size - 1) cursor_s += size;
|
||||
if (cursor_s < max_size - 2) cursor_s++;
|
||||
if (cursor_s >= inputstr_size) {
|
||||
memset(inputstr + cursor_s, alphabet[0], resize);
|
||||
inputstr[cursor_s + resize] = '\0';
|
||||
@ -1265,7 +931,7 @@ u64 ShowHexPrompt(u64 start_val, u32 n_digits, const char *format, ...) {
|
||||
va_list va;
|
||||
|
||||
if (n_digits > 16) n_digits = 16;
|
||||
snprintf(inputstr, sizeof(inputstr), "%0*llX", (int) n_digits, start_val);
|
||||
snprintf(inputstr, 16 + 1, "%0*llX", (int) n_digits, start_val);
|
||||
|
||||
va_start(va, format);
|
||||
if (ShowInputPrompt(inputstr, n_digits + 1, 0, alphabet, format, va)) {
|
||||
@ -1282,7 +948,7 @@ u64 ShowNumberPrompt(u64 start_val, const char *format, ...) {
|
||||
u64 ret = 0;
|
||||
va_list va;
|
||||
|
||||
snprintf(inputstr, sizeof(inputstr), "%llu", start_val);
|
||||
snprintf(inputstr, 20 + 1, "%llu", start_val);
|
||||
|
||||
va_start(va, format);
|
||||
if (ShowInputPrompt(inputstr, 20 + 1, 1, alphabet, format, va)) {
|
||||
@ -1402,8 +1068,8 @@ bool ShowProgress(u64 current, u64 total, const char* opstr)
|
||||
const u32 text_pos_y = bar_pos_y + bar_height + 2;
|
||||
u32 prog_width = ((total > 0) && (current <= total)) ? (current * (bar_width-4)) / total : 0;
|
||||
u32 prog_percent = ((total > 0) && (current <= total)) ? (current * 100) / total : 0;
|
||||
char tempstr[UTF_BUFFER_BYTESIZE(64)];
|
||||
char progstr[UTF_BUFFER_BYTESIZE(64)];
|
||||
char tempstr[64];
|
||||
char progstr[64];
|
||||
|
||||
static u64 last_msec_elapsed = 0;
|
||||
static u64 last_sec_remain = 0;
|
||||
@ -1427,20 +1093,16 @@ bool ShowProgress(u64 current, u64 total, const char* opstr)
|
||||
DrawRectangle(MAIN_SCREEN, bar_pos_x + 2 + prog_width, bar_pos_y + 2, (bar_width-4) - prog_width, bar_height - 4, COLOR_STD_BG);
|
||||
|
||||
TruncateString(progstr, opstr, min(63, (bar_width / FONT_WIDTH_EXT) - 7), 8);
|
||||
snprintf(tempstr, sizeof(tempstr), "%s (%lu%%)", progstr, prog_percent);
|
||||
snprintf(tempstr, 64, "%s (%lu%%)", progstr, prog_percent);
|
||||
ResizeString(progstr, tempstr, bar_width / FONT_WIDTH_EXT, 8, false);
|
||||
DrawString(MAIN_SCREEN, progstr, bar_pos_x, text_pos_y, COLOR_STD_FONT, COLOR_STD_BG);
|
||||
DrawString(MAIN_SCREEN, progstr, bar_pos_x, text_pos_y, COLOR_STD_FONT, COLOR_STD_BG, true);
|
||||
if (sec_elapsed >= 1) {
|
||||
if (sec_remain >= 3600) {
|
||||
snprintf(tempstr, sizeof(tempstr), STR_ETA_N_HOUR_N_MIN_N_SEC, (sec_remain / 3600), (sec_remain / 60) % 60, sec_remain % 60);
|
||||
} else {
|
||||
snprintf(tempstr, sizeof(tempstr), STR_ETA_N_MIN_N_SEC, sec_remain / 60, sec_remain % 60);
|
||||
}
|
||||
snprintf(tempstr, 16, "ETA %02llum%02llus", sec_remain / 60, sec_remain % 60);
|
||||
ResizeString(progstr, tempstr, 16, 8, true);
|
||||
DrawString(MAIN_SCREEN, progstr, bar_pos_x + bar_width - 1 - (FONT_WIDTH_EXT * 16),
|
||||
bar_pos_y - line_height - 1, COLOR_STD_FONT, COLOR_STD_BG);
|
||||
bar_pos_y - line_height - 1, COLOR_STD_FONT, COLOR_STD_BG, true);
|
||||
}
|
||||
DrawString(MAIN_SCREEN, STR_HOLD_B_TO_CANCEL, bar_pos_x + 2, text_pos_y + 14, COLOR_STD_FONT, COLOR_STD_BG);
|
||||
DrawString(MAIN_SCREEN, "(hold B to cancel)", bar_pos_x + 2, text_pos_y + 14, COLOR_STD_FONT, COLOR_STD_BG, false);
|
||||
|
||||
last_prog_width = prog_width;
|
||||
|
||||
@ -1453,7 +1115,13 @@ int ShowBrightnessConfig(int set_brightness)
|
||||
u32 btn_input, bar_count;
|
||||
int bar_x_pos, bar_y_pos, bar_width, bar_height;
|
||||
|
||||
const char *brightness_str = STR_BRIGHTNESS_CONTROLS;
|
||||
const char *brightness_str =
|
||||
"[\x1B] Decrease brightness\n"
|
||||
"[\x1A] Increase brightness\n"
|
||||
" \n"
|
||||
"[X] Use volume slider control\n"
|
||||
"[A] Set current brightness\n"
|
||||
"[B] Cancel";
|
||||
static const u16 brightness_slider_colmasks[] = {
|
||||
COLOR_RED, COLOR_GREEN, COLOR_BLUE, COLOR_WHITE
|
||||
};
|
||||
@ -1474,7 +1142,7 @@ int ShowBrightnessConfig(int set_brightness)
|
||||
// draw initial UI stuff
|
||||
DrawStringF(MAIN_SCREEN,
|
||||
(SCREEN_WIDTH_MAIN - GetDrawStringWidth(brightness_str)) / 2,
|
||||
(SCREEN_HEIGHT / 4) * 2, COLOR_STD_FONT, COLOR_STD_BG, "%s", brightness_str);
|
||||
(SCREEN_HEIGHT / 4) * 2, COLOR_STD_FONT, COLOR_STD_BG, brightness_str);
|
||||
|
||||
// draw all color gradient bars
|
||||
for (int x = 0; x < bar_width; x++) {
|
||||
|
||||
@ -21,11 +21,6 @@
|
||||
#define FONT_WIDTH_EXT GetFontWidth()
|
||||
#define FONT_HEIGHT_EXT GetFontHeight()
|
||||
|
||||
#define UTF_MAX_BYTES_PER_RUNE 4
|
||||
#define UTF_BUFFER_BYTESIZE(rune_count) (((rune_count) + 1) * UTF_MAX_BYTES_PER_RUNE)
|
||||
|
||||
#define PRINTF_ARGS(n) __attribute__ ((format (printf, (n), (n) + 1)))
|
||||
|
||||
#define TOP_SCREEN ((u16*)VRAM_TOP_LA)
|
||||
#define BOT_SCREEN ((u16*)VRAM_BOT_A)
|
||||
|
||||
@ -45,14 +40,13 @@
|
||||
|
||||
|
||||
#ifndef AUTO_UNLOCK
|
||||
bool PRINTF_ARGS(2) ShowUnlockSequence(u32 seqlvl, const char *format, ...);
|
||||
bool ShowUnlockSequence(u32 seqlvl, const char *format, ...);
|
||||
#else
|
||||
#define ShowUnlockSequence ShowPrompt
|
||||
#endif
|
||||
|
||||
const u8* GetFontFromPbm(const void* pbm, const u32 riff_size, u32* w, u32* h);
|
||||
const u8* GetFontFromRiff(const void* riff, const u32 riff_size, u32* w, u32* h, u16* count);
|
||||
bool SetFont(const void* font, const u32 font_size);
|
||||
u8* GetFontFromPbm(const void* pbm, const u32 pbm_size, u32* w, u32* h);
|
||||
bool SetFontFromPbm(const void* pbm, const u32 pbm_size);
|
||||
|
||||
u16 GetColor(const u16 *screen, int x, int y);
|
||||
|
||||
@ -63,13 +57,10 @@ void DrawRectangle(u16 *screen, int x, int y, u32 width, u32 height, u32 color);
|
||||
void DrawBitmap(u16 *screen, int x, int y, u32 w, u32 h, const u16* bitmap);
|
||||
void DrawQrCode(u16 *screen, const u8* qrcode);
|
||||
|
||||
void DrawCharacter(u16 *screen, u32 character, int x, int y, u32 color, u32 bgcolor);
|
||||
void DrawString(u16 *screen, const char *str, int x, int y, u32 color, u32 bgcolor);
|
||||
void PRINTF_ARGS(6) DrawStringF(u16 *screen, int x, int y, u32 color, u32 bgcolor, const char *format, ...);
|
||||
void PRINTF_ARGS(4) DrawStringCenter(u16 *screen, u32 color, u32 bgcolor, const char *format, ...);
|
||||
|
||||
u32 GetCharSize(const char* str);
|
||||
u32 GetPrevCharSize(const char* str);
|
||||
void DrawCharacter(u16 *screen, int character, int x, int y, u32 color, u32 bgcolor);
|
||||
void DrawString(u16 *screen, const char *str, int x, int y, u32 color, u32 bgcolor, bool fix_utf8);
|
||||
void DrawStringF(u16 *screen, int x, int y, u32 color, u32 bgcolor, const char *format, ...);
|
||||
void DrawStringCenter(u16 *screen, u32 color, u32 bgcolor, const char *format, ...);
|
||||
|
||||
u32 GetDrawStringHeight(const char* str);
|
||||
u32 GetDrawStringWidth(const char* str);
|
||||
@ -78,24 +69,24 @@ u32 GetFontHeight(void);
|
||||
|
||||
void MultiLineString(char* dest, const char* orig, int llen, int maxl);
|
||||
void WordWrapString(char* str, int llen);
|
||||
void ResizeString(char* dest, const char* orig, int nlength, int tpos, bool align_right);
|
||||
void TruncateString(char* dest, const char* orig, int nlength, int tpos);
|
||||
void ResizeString(char* dest, const char* orig, int nsize, int tpos, bool align_right);
|
||||
void TruncateString(char* dest, const char* orig, int nsize, int tpos);
|
||||
void FormatNumber(char* str, u64 number);
|
||||
void FormatBytes(char* str, u64 bytes);
|
||||
|
||||
void PRINTF_ARGS(1) ShowString(const char *format, ...);
|
||||
void PRINTF_ARGS(2) ShowStringF(u16* screen, const char *format, ...);
|
||||
void PRINTF_ARGS(4) ShowIconString(u16* icon, int w, int h, const char *format, ...);
|
||||
void PRINTF_ARGS(5) ShowIconStringF(u16* screen, u16* icon, int w, int h, const char *format, ...);
|
||||
bool PRINTF_ARGS(2) ShowPrompt(bool ask, const char *format, ...);
|
||||
u32 PRINTF_ARGS(3) ShowSelectPrompt(int n, const char** options, const char *format, ...);
|
||||
u32 PRINTF_ARGS(4) ShowFileScrollPrompt(int n, const DirEntry** entries, bool hide_ext, const char *format, ...);
|
||||
u32 PRINTF_ARGS(4) ShowHotkeyPrompt(u32 n, const char** options, const u32* keys, const char *format, ...);
|
||||
bool PRINTF_ARGS(3) ShowStringPrompt(char* inputstr, u32 max_size, const char *format, ...);
|
||||
u64 PRINTF_ARGS(3) ShowHexPrompt(u64 start_val, u32 n_digits, const char *format, ...);
|
||||
u64 PRINTF_ARGS(2) ShowNumberPrompt(u64 start_val, const char *format, ...);
|
||||
bool PRINTF_ARGS(3) ShowDataPrompt(u8* data, u32* size, const char *format, ...);
|
||||
bool PRINTF_ARGS(2) ShowRtcSetterPrompt(void* time, const char *format, ...);
|
||||
void ShowString(const char *format, ...);
|
||||
void ShowStringF(u16* screen, const char *format, ...);
|
||||
void ShowIconString(u16* icon, int w, int h, const char *format, ...);
|
||||
void ShowIconStringF(u16* screen, u16* icon, int w, int h, const char *format, ...);
|
||||
bool ShowPrompt(bool ask, const char *format, ...);
|
||||
u32 ShowSelectPrompt(u32 n, const char** options, const char *format, ...);
|
||||
u32 ShowFileScrollPrompt(u32 n, const DirEntry** entries, bool hide_ext, const char *format, ...);
|
||||
u32 ShowHotkeyPrompt(u32 n, const char** options, const u32* keys, const char *format, ...);
|
||||
bool ShowStringPrompt(char* inputstr, u32 max_size, const char *format, ...);
|
||||
u64 ShowHexPrompt(u64 start_val, u32 n_digits, const char *format, ...);
|
||||
u64 ShowNumberPrompt(u64 start_val, const char *format, ...);
|
||||
bool ShowDataPrompt(u8* data, u32* size, const char *format, ...);
|
||||
bool ShowRtcSetterPrompt(void* time, const char *format, ...);
|
||||
bool ShowProgress(u64 current, u64 total, const char* opstr);
|
||||
|
||||
int ShowBrightnessConfig(int set_brightness);
|
||||
|
||||
@ -40,13 +40,10 @@ u32 GetUnitKeysType(void)
|
||||
}
|
||||
|
||||
void CryptAesKeyInfo(AesKeyInfo* info) {
|
||||
static const u8 zeros[16] = { 0 };
|
||||
static const u8 keyY_dev[16] = {
|
||||
0xA2, 0x32, 0x4A, 0x7E, 0x7C, 0xE6, 0x1A, 0x9A, 0x45, 0x4A, 0x52, 0x19, 0xB3, 0x5B, 0xE9, 0x3B };
|
||||
const u8* aeskeyY = GetUnitKeysType() == KEYS_DEVKIT ? &keyY_dev[0] : &zeros[0];
|
||||
static u8 zeroes[16] = { 0 };
|
||||
u8 ctr[16] = { 0 };
|
||||
memcpy(ctr, (void*) info, 12); // CTR -> slot + type + id + zeroes
|
||||
setup_aeskeyY(0x2C, aeskeyY);
|
||||
setup_aeskeyY(0x2C, zeroes);
|
||||
use_aeskey(0x2C);
|
||||
set_ctr(ctr);
|
||||
aes_decrypt(info->key, info->key, 1, AES_CNT_CTRNAND_MODE);
|
||||
@ -155,7 +152,7 @@ u32 LoadKeyFromFile(void* key, u32 keyslot, char type, char* id)
|
||||
// load legacy slot0x??Key?.bin file instead
|
||||
if (!found && (type != 'I')) {
|
||||
char fname[64];
|
||||
snprintf(fname, sizeof(fname), "slot0x%02lXKey%s%s.bin", keyslot,
|
||||
snprintf(fname, 64, "slot0x%02lXKey%s%s.bin", keyslot,
|
||||
(type == 'X') ? "X" : (type == 'Y') ? "Y" : (type == 'I') ? "IV" : "", (id) ? id : "");
|
||||
found = (LoadSupportFile(fname, key, 16) == 16);
|
||||
}
|
||||
|
||||
@ -8,7 +8,6 @@
|
||||
#include "keydb.h"
|
||||
#include "ctrtransfer.h"
|
||||
#include "scripting.h"
|
||||
#include "gm9lua.h"
|
||||
#include "png.h"
|
||||
#include "ui.h" // only for font file detection
|
||||
|
||||
@ -128,10 +127,6 @@ u64 IdentifyFileType(const char* path) {
|
||||
}
|
||||
} else if (GetFontFromPbm(data, fsize, NULL, NULL)) {
|
||||
return FONT_PBM;
|
||||
} else if (GetFontFromRiff(data, fsize, NULL, NULL, NULL)) {
|
||||
return FONT_RIFF;
|
||||
} else if (GetLanguage(data, fsize, NULL, NULL, NULL)) {
|
||||
return TRANSLATION;
|
||||
} else if ((fsize > sizeof(AgbHeader)) &&
|
||||
(ValidateAgbHeader((AgbHeader*) data) == 0)) {
|
||||
return GAME_GBA;
|
||||
@ -159,16 +154,10 @@ u64 IdentifyFileType(const char* path) {
|
||||
return BIN_KEYDB; // key database
|
||||
} else if ((sscanf(fname, "slot%02lXKey", &id) == 1) && (strncasecmp(ext, "bin", 4) == 0) && (fsize = 16) && (id < 0x40)) {
|
||||
return BIN_LEGKEY; // legacy key file
|
||||
} else if ((strncmp((char*) data, CIFINISH_MAGIC, strlen(CIFINISH_MAGIC)) == 0) &&
|
||||
(fsize == CIFINISH_SIZE((void*) data)) && (fsize > sizeof(CifinishHeader))) {
|
||||
return BIN_CIFNSH;
|
||||
} else if (ValidateText((char*) data, (fsize > 0x200) ? 0x200 : fsize)) {
|
||||
u64 type = 0;
|
||||
if ((fsize < SCRIPT_MAX_SIZE) && (strcasecmp(ext, SCRIPT_EXT) == 0))
|
||||
if ((fsize < SCRIPT_MAX_SIZE) && (strncasecmp(ext, SCRIPT_EXT, strnlen(SCRIPT_EXT, 16) + 1) == 0))
|
||||
type |= TXT_SCRIPT; // should be a script (which is also generic text)
|
||||
// this should check if it's compiled lua bytecode (done with luac), which is NOT text
|
||||
else if ((fsize < LUASCRIPT_MAX_SIZE) && (strcasecmp(ext, LUASCRIPT_EXT) == 0))
|
||||
type |= TXT_LUA;
|
||||
if (fsize < STD_BUFFER_SIZE) type |= TXT_GENERIC;
|
||||
return type;
|
||||
} else if ((strncmp(path + 2, "/Nintendo DSiWare/", 18) == 0) &&
|
||||
|
||||
@ -27,20 +27,16 @@
|
||||
#define SYS_DISA (1ULL<<22)
|
||||
#define SYS_AGBSAVE (1ULL<<23)
|
||||
#define SYS_TICKDB (1ULL<<24)
|
||||
#define BIN_CIFNSH (1ULL<<25)
|
||||
#define BIN_NCCHNFO (1ULL<<26)
|
||||
#define BIN_TIKDB (1ULL<<27)
|
||||
#define BIN_KEYDB (1ULL<<28)
|
||||
#define BIN_LEGKEY (1ULL<<29)
|
||||
#define TXT_SCRIPT (1ULL<<30)
|
||||
#define TXT_GENERIC (1ULL<<31)
|
||||
#define GFX_PNG (1ULL<<32)
|
||||
#define FONT_PBM (1ULL<<33)
|
||||
#define FONT_RIFF (1ULL<<34)
|
||||
#define NOIMG_NAND (1ULL<<35)
|
||||
#define HDR_NAND (1ULL<<36)
|
||||
#define TRANSLATION (1ULL<<37)
|
||||
#define TXT_LUA (1ULL<<38)
|
||||
#define BIN_NCCHNFO (1ULL<<25)
|
||||
#define BIN_TIKDB (1ULL<<26)
|
||||
#define BIN_KEYDB (1ULL<<27)
|
||||
#define BIN_LEGKEY (1ULL<<28)
|
||||
#define TXT_SCRIPT (1ULL<<29)
|
||||
#define TXT_GENERIC (1ULL<<30)
|
||||
#define GFX_PNG (1ULL<<31)
|
||||
#define FONT_PBM (1ULL<<32)
|
||||
#define NOIMG_NAND (1ULL<<33)
|
||||
#define HDR_NAND (1ULL<<34)
|
||||
#define TYPE_BASE 0xFFFFFFFFFFULL // 40 bit reserved for base types
|
||||
|
||||
// #define FLAG_FIRM (1ULL<<58) // <--- for CXIs containing FIRMs
|
||||
@ -58,9 +54,8 @@
|
||||
#define FTYPE_CIABUILD_L(tp) (tp&(GAME_TMD|GAME_CDNTMD|GAME_TIE|GAME_TAD))
|
||||
#define FTYPE_CIAINSTALL(tp) ((tp&(GAME_NCSD|GAME_NCCH|GAME_CIA|GAME_CDNTMD|GAME_TWLTMD)) || ((tp&GAME_NDS)&&(tp&(FLAG_DSIW))))
|
||||
#define FTYPE_TIKINSTALL(tp) (tp&(GAME_TICKET))
|
||||
#define FTYPE_CIFINSTALL(tp) (tp&(BIN_CIFNSH))
|
||||
#define FTYPE_TIKDUMP(tp) (tp&(GAME_TIE))
|
||||
#define FTYPE_CXIDUMP(tp) (tp&(GAME_TMD|GAME_TIE))
|
||||
#define FTYPE_CXIDUMP(tp) (tp&(GAME_TMD))
|
||||
#define FTYPE_UNINSTALL(tp) (tp&(GAME_TIE))
|
||||
#define FTYPE_TIKBUILD(tp) (tp&(GAME_TICKET|SYS_TICKDB|BIN_TIKDB))
|
||||
#define FTYPE_KEYBUILD(tp) (tp&(BIN_KEYDB|BIN_LEGKEY))
|
||||
@ -78,11 +73,9 @@
|
||||
#define FTYPE_KEYINIT(tp) (tp&(BIN_KEYDB))
|
||||
#define FTYPE_KEYINSTALL(tp) (tp&(BIN_KEYDB))
|
||||
#define FTYPE_SCRIPT(tp) (tp&(TXT_SCRIPT))
|
||||
#define FTYPE_LUA(tp) (tp&(TXT_LUA))
|
||||
#define FTYPE_FONT(tp) (tp&(FONT_PBM|FONT_RIFF))
|
||||
#define FTYPE_TRANSLATION(tp) (tp&(TRANSLATION))
|
||||
#define FTYPE_FONT(tp) (tp&(FONT_PBM))
|
||||
#define FTYPE_GFX(tp) (tp&(GFX_PNG))
|
||||
#define FTYPE_SETABLE(tp) (tp&(FONT_PBM|FONT_RIFF|TRANSLATION))
|
||||
#define FTYPE_SETABLE(tp) (tp&(FONT_PBM))
|
||||
#define FTYPE_BOOTABLE(tp) (tp&(SYS_FIRM))
|
||||
#define FTYPE_INSTALLABLE(tp) (tp&(SYS_FIRM))
|
||||
#define FTYPE_AGBSAVE(tp) (tp&(SYS_AGBSAVE))
|
||||
|
||||
@ -1,7 +1,6 @@
|
||||
#include "fsdrive.h"
|
||||
#include "fsgame.h"
|
||||
#include "fsinit.h"
|
||||
#include "language.h"
|
||||
#include "virtual.h"
|
||||
#include "vcart.h"
|
||||
#include "sddata.h"
|
||||
@ -85,13 +84,13 @@ bool GetFATVolumeLabel(const char* drv, char* label) {
|
||||
}
|
||||
|
||||
bool GetRootDirContentsWorker(DirStruct* contents) {
|
||||
const char* drvname[] = { FS_DRVNAME };
|
||||
static const char* drvname[] = { FS_DRVNAME };
|
||||
static const char* drvnum[] = { FS_DRVNUM };
|
||||
u32 n_entries = 0;
|
||||
|
||||
char sdlabel[DRV_LABEL_LEN];
|
||||
if (!GetFATVolumeLabel("0:", sdlabel) || !(*sdlabel))
|
||||
strcpy(sdlabel, STR_LAB_NOLABEL);
|
||||
strcpy(sdlabel, "NOLABEL");
|
||||
|
||||
char carttype[16];
|
||||
GetVCartTypeString(carttype);
|
||||
@ -102,15 +101,15 @@ bool GetRootDirContentsWorker(DirStruct* contents) {
|
||||
if (!DriveType(drvnum[i])) continue; // drive not available
|
||||
entry->p_name = 4;
|
||||
entry->name = entry->path + entry->p_name;
|
||||
memset(entry->path, 0x00, 256);
|
||||
memset(entry->path, 0x00, 64);
|
||||
snprintf(entry->path, 4, "%s", drvnum[i]);
|
||||
if ((*(drvnum[i]) >= '7') && (*(drvnum[i]) <= '9') && !(GetMountState() & IMG_NAND)) // Drive 7...9 handling
|
||||
snprintf(entry->name, 252, "[%s] %s", drvnum[i],
|
||||
(*(drvnum[i]) == '7') ? STR_LAB_FAT_IMAGE :
|
||||
(*(drvnum[i]) == '8') ? STR_LAB_BONUS_DRIVE :
|
||||
(*(drvnum[i]) == '9') ? STR_LAB_RAMDRIVE : "UNK");
|
||||
snprintf(entry->name, 32, "[%s] %s", drvnum[i],
|
||||
(*(drvnum[i]) == '7') ? "FAT IMAGE" :
|
||||
(*(drvnum[i]) == '8') ? "BONUS DRIVE" :
|
||||
(*(drvnum[i]) == '9') ? "RAMDRIVE" : "UNK");
|
||||
else if (*(drvnum[i]) == 'G') // Game drive special handling
|
||||
snprintf(entry->name, 252, "[%s] %s %s", drvnum[i],
|
||||
snprintf(entry->name, 32, "[%s] %s %s", drvnum[i],
|
||||
(GetMountState() & GAME_CIA ) ? "CIA" :
|
||||
(GetMountState() & GAME_NCSD ) ? "NCSD" :
|
||||
(GetMountState() & GAME_NCCH ) ? "NCCH" :
|
||||
@ -120,10 +119,10 @@ bool GetRootDirContentsWorker(DirStruct* contents) {
|
||||
(GetMountState() & SYS_FIRM ) ? "FIRM" :
|
||||
(GetMountState() & GAME_TAD ) ? "DSIWARE" : "UNK", drvname[i]);
|
||||
else if (*(drvnum[i]) == 'C') // Game cart handling
|
||||
snprintf(entry->name, 252, "[%s] %s (%s)", drvnum[i], drvname[i], carttype);
|
||||
snprintf(entry->name, 32, "[%s] %s (%s)", drvnum[i], drvname[i], carttype);
|
||||
else if (*(drvnum[i]) == '0') // SD card handling
|
||||
snprintf(entry->name, 252, "[%s] %s (%s)", drvnum[i], drvname[i], sdlabel);
|
||||
else snprintf(entry->name, 252, "[%s] %s", drvnum[i], drvname[i]);
|
||||
snprintf(entry->name, 32, "[%s] %s (%s)", drvnum[i], drvname[i], sdlabel);
|
||||
else snprintf(entry->name, 32, "[%s] %s", drvnum[i], drvname[i]);
|
||||
entry->size = GetTotalSpace(entry->path);
|
||||
entry->type = T_ROOT;
|
||||
entry->marked = 0;
|
||||
@ -212,7 +211,7 @@ void SearchDirContents(DirStruct* contents, const char* path, const char* patter
|
||||
|
||||
void GetDirContents(DirStruct* contents, const char* path) {
|
||||
if (*search_path && (DriveType(path) & DRV_SEARCH)) {
|
||||
ShowString("%s", STR_SEARCHING_PLEASE_WAIT);
|
||||
ShowString("Searching, please wait...");
|
||||
SearchDirContents(contents, search_path, search_pattern, true);
|
||||
ClearScreenF(true, false, COLOR_STD_BG);
|
||||
} else if (title_manager_mode && (DriveType(path) & DRV_TITLEMAN)) {
|
||||
@ -232,7 +231,7 @@ uint64_t GetFreeSpace(const char* path)
|
||||
FATFS* fsobj = GetMountedFSObject(path);
|
||||
if ((pdrv < 0) || !fsobj) return 0;
|
||||
|
||||
snprintf(fsname, sizeof(fsname), "%i:", pdrv);
|
||||
snprintf(fsname, 3, "%i:", pdrv);
|
||||
if (f_getfree(fsname, &free_clusters, &fsptr) != FR_OK)
|
||||
return 0;
|
||||
|
||||
|
||||
@ -32,16 +32,16 @@
|
||||
#define DRV_LABEL_LEN (36)
|
||||
|
||||
#define FS_DRVNAME \
|
||||
STR_LAB_SDCARD, \
|
||||
STR_LAB_SYSNAND_CTRNAND, STR_LAB_SYSNAND_TWLN, STR_LAB_SYSNAND_TWLP, STR_LAB_SYSNAND_SD, STR_LAB_SYSNAND_VIRTUAL, \
|
||||
STR_LAB_EMUNAND_CTRNAND, STR_LAB_EMUNAND_TWLN, STR_LAB_EMUNAND_TWLP, STR_LAB_EMUNAND_SD, STR_LAB_EMUNAND_VIRTUAL, \
|
||||
STR_LAB_IMGNAND_CTRNAND, STR_LAB_IMGNAND_TWLN, STR_LAB_IMGNAND_TWLP, STR_LAB_IMGNAND_VIRTUAL, \
|
||||
STR_LAB_GAMECART, \
|
||||
STR_LAB_GAME_IMAGE, STR_LAB_AESKEYDB_IMAGE, STR_LAB_BDRI_IMAGE, STR_LAB_DISA_DIFF_IMAGE, \
|
||||
STR_LAB_MEMORY_VIRTUAL, \
|
||||
STR_LAB_VRAM_VIRTUAL, \
|
||||
STR_LAB_TITLE_MANAGER, \
|
||||
STR_LAB_LAST_SEARCH
|
||||
"SDCARD", \
|
||||
"SYSNAND CTRNAND", "SYSNAND TWLN", "SYSNAND TWLP", "SYSNAND SD", "SYSNAND VIRTUAL", \
|
||||
"EMUNAND CTRNAND", "EMUNAND TWLN", "EMUNAND TWLP", "EMUNAND SD", "EMUNAND VIRTUAL", \
|
||||
"IMGNAND CTRNAND", "IMGNAND TWLN", "IMGNAND TWLP", "IMGNAND VIRTUAL", \
|
||||
"GAMECART", \
|
||||
"GAME IMAGE", "AESKEYDB IMAGE", "BDRI IMAGE", "DISA/DIFF IMAGE", \
|
||||
"MEMORY VIRTUAL", \
|
||||
"VRAM VIRTUAL", \
|
||||
"TITLE MANAGER", \
|
||||
"LAST SEARCH" \
|
||||
|
||||
#define FS_DRVNUM \
|
||||
"0:", "1:", "2:", "3:", "A:", "S:", "4:", "5:", "6:", "B:", "E:", "7:", "8:", "9:", \
|
||||
|
||||
@ -1,7 +1,6 @@
|
||||
#include "fsgame.h"
|
||||
#include "fsperm.h"
|
||||
#include "gameutil.h"
|
||||
#include "language.h"
|
||||
#include "tie.h"
|
||||
#include "ui.h"
|
||||
#include "vff.h"
|
||||
@ -35,12 +34,12 @@ bool GoodRenamer(DirEntry* entry, bool ask) {
|
||||
return false;
|
||||
|
||||
if (ask) { // ask for confirmatiom
|
||||
char oldname_tr[UTF_BUFFER_BYTESIZE(32)];
|
||||
char oldname_tr[32+1];
|
||||
char newname_ww[256];
|
||||
TruncateString(oldname_tr, entry->name, 32, 8);
|
||||
strncpy(newname_ww, goodname, 256);
|
||||
WordWrapString(newname_ww, 32);
|
||||
if (!ShowPrompt(true, "%s\n%s\n \n%s", oldname_tr, STR_RENAME_TO_GOOD_NAME, newname_ww))
|
||||
if (!ShowPrompt(true, "%s\nRename to good name?\n \n%s", oldname_tr, newname_ww))
|
||||
return true; // call it a success because user choice
|
||||
}
|
||||
|
||||
|
||||
@ -21,7 +21,7 @@ bool InitExtFS() {
|
||||
|
||||
for (u32 i = 1; i < NORM_FS; i++) {
|
||||
char fsname[8];
|
||||
snprintf(fsname, sizeof(fsname), "%lu:", i);
|
||||
snprintf(fsname, 7, "%lu:", i);
|
||||
if (fs_mounted[i]) continue;
|
||||
fs_mounted[i] = (f_mount(fs + i, fsname, 1) == FR_OK);
|
||||
if ((!fs_mounted[i] || !ramdrv_ready) && (i == NORM_FS - 1) && !(GetMountState() & IMG_NAND)) {
|
||||
@ -44,7 +44,7 @@ bool InitImgFS(const char* path) {
|
||||
u32 drv_i = NORM_FS - IMGN_FS;
|
||||
char fsname[8];
|
||||
for (; drv_i < NORM_FS; drv_i++) {
|
||||
snprintf(fsname, sizeof(fsname), "%lu:", drv_i);
|
||||
snprintf(fsname, 7, "%lu:", drv_i);
|
||||
if (!(DriveType(fsname)&DRV_IMAGE)) break;
|
||||
}
|
||||
// deinit virtual filesystem
|
||||
@ -58,7 +58,7 @@ bool InitImgFS(const char* path) {
|
||||
else if ((type&IMG_FAT) && (drv_i < NORM_FS - IMGN_FS + 1)) drv_i = NORM_FS - IMGN_FS + 1;
|
||||
// reinit image filesystem
|
||||
for (u32 i = NORM_FS - IMGN_FS; i < drv_i; i++) {
|
||||
snprintf(fsname, sizeof(fsname), "%lu:", i);
|
||||
snprintf(fsname, 7, "%lu:", i);
|
||||
fs_mounted[i] = (f_mount(fs + i, fsname, 1) == FR_OK);
|
||||
}
|
||||
return GetMountState();
|
||||
@ -71,7 +71,7 @@ void DeinitExtFS() {
|
||||
for (u32 i = NORM_FS - 1; i > 0; i--) {
|
||||
if (fs_mounted[i]) {
|
||||
char fsname[8];
|
||||
snprintf(fsname, sizeof(fsname), "%lu:", i);
|
||||
snprintf(fsname, 7, "%lu:", i);
|
||||
f_mount(NULL, fsname, 1);
|
||||
fs_mounted[i] = false;
|
||||
}
|
||||
@ -91,7 +91,7 @@ void DismountDriveType(u32 type) { // careful with this - no safety checks
|
||||
}
|
||||
for (u32 i = 0; i < NORM_FS; i++) {
|
||||
char fsname[8];
|
||||
snprintf(fsname, sizeof(fsname), "%lu:", i);
|
||||
snprintf(fsname, 7, "%lu:", i);
|
||||
if (!fs_mounted[i] || !(type & DriveType(fsname)))
|
||||
continue;
|
||||
f_mount(NULL, fsname, 1);
|
||||
|
||||
@ -4,7 +4,6 @@
|
||||
#include "image.h"
|
||||
#include "unittype.h"
|
||||
#include "essentials.h"
|
||||
#include "language.h"
|
||||
#include "ui.h"
|
||||
#include "sdmmc.h"
|
||||
|
||||
@ -21,7 +20,7 @@
|
||||
static u32 write_permissions = PERM_BASE;
|
||||
|
||||
bool CheckWritePermissions(const char* path) {
|
||||
char area_name[UTF_BUFFER_BYTESIZE(16)];
|
||||
char area_name[16];
|
||||
int drvtype = DriveType(path);
|
||||
u32 perm;
|
||||
|
||||
@ -41,7 +40,7 @@ bool CheckWritePermissions(const char* path) {
|
||||
|
||||
// SD card write protection check
|
||||
if ((drvtype & (DRV_SDCARD | DRV_EMUNAND | DRV_ALIAS)) && SD_WRITE_PROTECTED) {
|
||||
ShowPrompt(false, "%s", STR_SD_WRITE_PROTECTED_CANT_CONTINUE);
|
||||
ShowPrompt(false, "SD card is write protected!\nCan't continue.");
|
||||
return false;
|
||||
}
|
||||
|
||||
@ -64,7 +63,7 @@ bool CheckWritePermissions(const char* path) {
|
||||
if ((drvtype & DRV_CTRNAND) || (lvl == 2)) lvl = 3;
|
||||
}
|
||||
perm = perms[lvl];
|
||||
snprintf(area_name, sizeof(area_name), STR_SYSNAND_LVL_N, lvl);
|
||||
snprintf(area_name, 16, "SysNAND (lvl%lu)", lvl);
|
||||
} else if (drvtype & DRV_EMUNAND) {
|
||||
static const u32 perms[] = { PERM_EMU_LVL0, PERM_EMU_LVL1 };
|
||||
u32 lvl = (drvtype & (DRV_ALIAS|DRV_CTRNAND)) ? 1 : 0;
|
||||
@ -74,34 +73,34 @@ bool CheckWritePermissions(const char* path) {
|
||||
if (strncasecmp(path_f, path_lvl1[i], 256) == 0) lvl = 1;
|
||||
}
|
||||
perm = perms[lvl];
|
||||
snprintf(area_name, sizeof(area_name), STR_EMUNAND_LVL_N, lvl);
|
||||
snprintf(area_name, 16, "EmuNAND (lvl%lu)", lvl);
|
||||
} else if (drvtype & DRV_GAME) {
|
||||
perm = PERM_GAME;
|
||||
snprintf(area_name, sizeof(area_name), "%s", STR_GAME_IMAGES);
|
||||
snprintf(area_name, 16, "game images");
|
||||
} else if (drvtype & DRV_CART) {
|
||||
perm = PERM_CART;
|
||||
snprintf(area_name, sizeof(area_name), "%s", STR_GAMECART_SAVES);
|
||||
snprintf(area_name, 16, "gamecart saves");
|
||||
} else if (drvtype & DRV_VRAM) {
|
||||
perm = PERM_VRAM;
|
||||
snprintf(area_name, sizeof(area_name), "vram0");
|
||||
snprintf(area_name, 16, "vram0");
|
||||
} else if (drvtype & DRV_XORPAD) {
|
||||
perm = PERM_XORPAD;
|
||||
snprintf(area_name, sizeof(area_name), "XORpads");
|
||||
snprintf(area_name, 16, "XORpads");
|
||||
} else if (drvtype & DRV_IMAGE) {
|
||||
perm = PERM_IMAGE;
|
||||
snprintf(area_name, sizeof(area_name), "%s", STR_IMAGES);
|
||||
snprintf(area_name, 16, "images");
|
||||
} else if (drvtype & DRV_MEMORY) {
|
||||
perm = PERM_MEMORY;
|
||||
snprintf(area_name, sizeof(area_name), "%s", STR_MEMORY_AREAS);
|
||||
snprintf(area_name, 16, "memory areas");
|
||||
} else if (strncasecmp(path_f, "0:/Nintendo 3DS", 15) == 0) { // this check could be better
|
||||
perm = PERM_SDDATA;
|
||||
snprintf(area_name, sizeof(area_name), "%s", STR_SD_SYSTEM_DATA);
|
||||
snprintf(area_name, 16, "SD system data");
|
||||
} else if (drvtype & DRV_SDCARD) {
|
||||
perm = PERM_SDCARD;
|
||||
snprintf(area_name, sizeof(area_name), "%s", STR_SD_CARD);
|
||||
snprintf(area_name, 16, "SD card");
|
||||
} else if (drvtype & DRV_RAMDRIVE) {
|
||||
perm = PERM_RAMDRIVE;
|
||||
snprintf(area_name, sizeof(area_name), "%s", STR_RAM_DRIVE);
|
||||
snprintf(area_name, 16, "RAM drive");
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
@ -113,14 +112,14 @@ bool CheckWritePermissions(const char* path) {
|
||||
// offer unlock if possible
|
||||
if (!(perm & (PERM_VRAM|PERM_GAME|PERM_XORPAD))) {
|
||||
// ask the user
|
||||
if (!ShowPrompt(true, STR_WRITING_TO_DRIVE_IS_LOCKED_UNLOCK_NOW, area_name))
|
||||
if (!ShowPrompt(true, "Writing to %s is locked!\nUnlock it now?", area_name))
|
||||
return false;
|
||||
|
||||
return SetWritePermissions(perm, true);
|
||||
}
|
||||
|
||||
// unlock not possible
|
||||
ShowPrompt(false, STR_UNLOCK_WRITE_FOR_DRIVE_NOT_ALLOWED, area_name);
|
||||
ShowPrompt(false, "Unlock write permission for\n%s is not allowed.", area_name);
|
||||
return false;
|
||||
}
|
||||
|
||||
@ -145,65 +144,65 @@ bool SetWritePermissions(u32 perm, bool add_perm) {
|
||||
|
||||
switch (perm) {
|
||||
case PERM_BASE:
|
||||
if (!ShowUnlockSequence(1, "%s", STR_ENABLE_BASE_WRITE))
|
||||
if (!ShowUnlockSequence(1, "You want to enable base\nwriting permissions."))
|
||||
return false;
|
||||
break;
|
||||
case PERM_SDCARD:
|
||||
if (!ShowUnlockSequence(1, "%s", STR_ENABLE_SD_WRITE))
|
||||
if (!ShowUnlockSequence(1, "You want to enable SD card\nwriting permissions."))
|
||||
return false;
|
||||
break;
|
||||
case PERM_IMAGE:
|
||||
if (!ShowUnlockSequence(1, "%s", STR_ENABLE_IMAGE_WRITE))
|
||||
if (!ShowUnlockSequence(1, "You want to enable image\nwriting permissions."))
|
||||
return false;
|
||||
break;
|
||||
case PERM_RAMDRIVE:
|
||||
if (!ShowUnlockSequence(1, "%s", STR_ENABLE_RAM_DRIVE_WRITE))
|
||||
if (!ShowUnlockSequence(1, "You want to enable RAM drive\nwriting permissions."))
|
||||
return false;
|
||||
break;
|
||||
case PERM_EMU_LVL0:
|
||||
if (!ShowUnlockSequence(1, "%s", STR_ENABLE_EMUNAND_0_WRITE))
|
||||
if (!ShowUnlockSequence(1, "You want to enable EmuNAND\nlvl0 writing permissions."))
|
||||
return false;
|
||||
break;
|
||||
case PERM_SYS_LVL0:
|
||||
if (!ShowUnlockSequence(1, "%s", STR_ENABLE_SYSNAND_0_WRITE))
|
||||
if (!ShowUnlockSequence(1, "You want to enable SysNAND\nlvl0 writing permissions."))
|
||||
return false;
|
||||
break;
|
||||
case PERM_EMU_LVL1:
|
||||
if (!ShowUnlockSequence(2, "%s", STR_ENABLE_EMUNAND_1_WRITE))
|
||||
if (!ShowUnlockSequence(2, "You want to enable EmuNAND\nlvl1 writing permissions.\n \nThis enables you to modify\nrecoverable system data,\nuser data & savegames."))
|
||||
return false;
|
||||
break;
|
||||
case PERM_SYS_LVL1:
|
||||
if (!ShowUnlockSequence(2, "%s", STR_ENABLE_SYSNAND_1_WRITE))
|
||||
if (!ShowUnlockSequence(2, "You want to enable SysNAND\nlvl1 writing permissions.\n \nThis enables you to modify\nsystem data, installations,\nuser data & savegames."))
|
||||
return false;
|
||||
break;
|
||||
case PERM_CART:
|
||||
if (!ShowUnlockSequence(2, "%s", STR_ENABLE_GAMECART_SAVE_WRITE))
|
||||
if (!ShowUnlockSequence(2, "You want to enable gamecart\nsave writing permissions."))
|
||||
return false;
|
||||
break;
|
||||
#ifndef SAFEMODE
|
||||
case PERM_SYS_LVL2:
|
||||
if (!ShowUnlockSequence(3, "%s", STR_ENABLE_SYSNAND_2_WRITE))
|
||||
if (!ShowUnlockSequence(3, "!Better be careful!\n \nYou want to enable SysNAND\nlvl2 writing permissions.\n \nThis enables you to modify\nirrecoverable system data!"))
|
||||
return false;
|
||||
break;
|
||||
case PERM_MEMORY:
|
||||
if (!ShowUnlockSequence(4, "%s", STR_ENABLE_MEMORY_WRITE))
|
||||
if (!ShowUnlockSequence(4, "!Better be careful!\n \nYou want to enable memory\nwriting permissions.\n \nWriting to certain areas may\nlead to unexpected results."))
|
||||
return false;
|
||||
break;
|
||||
case PERM_SDDATA:
|
||||
if (!ShowUnlockSequence(5, "%s", STR_ENABLE_SD_DATA_WRITE))
|
||||
if (!ShowUnlockSequence(5, "!THIS IS NOT RECOMMENDED!\n \nYou want to enable SD data\nwriting permissions.\n \nEverything here is encrypted.\nIt is recommended to use the\nA:/B: drives for modification\nof installations, user data &\nsavegames instead."))
|
||||
return false;
|
||||
break;
|
||||
case PERM_SYS_LVL3:
|
||||
if (!ShowUnlockSequence(6, "%s", STR_ENABLE_SYSNAND_3_WRITE))
|
||||
if (!ShowUnlockSequence(6, "!THIS IS YOUR ONLY WARNING!\n \nYou want to enable SysNAND\nlvl3 writing permissions.\n \nThis enables you to OVERWRITE\nyour bootloader installation,\nessential system files and/or\nBRICK your console!"))
|
||||
return false;
|
||||
break;
|
||||
default:
|
||||
ShowPrompt(false, "%s", STR_UNLOCK_WRITE_NOT_ALLOWED);
|
||||
ShowPrompt(false, "Unlock write permission is not allowed.");
|
||||
return false;
|
||||
break;
|
||||
#else
|
||||
default:
|
||||
ShowPrompt(false, "%s", STR_CANT_UNLOCK_WRITE_TRY_GODMODE9);
|
||||
ShowPrompt(false, "Can't unlock write permission.\nTry GodMode9 instead!");
|
||||
return false;
|
||||
break;
|
||||
#endif
|
||||
|
||||
@ -11,10 +11,9 @@
|
||||
#include "ff.h"
|
||||
#include "ui.h"
|
||||
#include "swkbd.h"
|
||||
#include "language.h"
|
||||
|
||||
#define SKIP_CUR (1UL<<11)
|
||||
#define OVERWRITE_CUR (1UL<<12)
|
||||
#define SKIP_CUR (1UL<<10)
|
||||
#define OVERWRITE_CUR (1UL<<11)
|
||||
|
||||
#define _MAX_FS_OPT 8 // max file selector options
|
||||
|
||||
@ -47,13 +46,13 @@ bool FormatSDCard(u64 hidden_mb, u32 cluster_size, const char* label) {
|
||||
|
||||
// FAT size check
|
||||
if (fat_size < 0x80000) { // minimum free space: 256MB
|
||||
ShowPrompt(false, "%s", STR_ERROR_SD_TOO_SMALL);
|
||||
ShowPrompt(false, "Error: SD card is too small");
|
||||
return false;
|
||||
}
|
||||
|
||||
// Write protection check
|
||||
if (SD_WRITE_PROTECTED) {
|
||||
ShowPrompt(false, "%s", STR_SD_WRITE_PROTECTED_CANT_CONTINUE);
|
||||
ShowPrompt(false, "SD card is write protected!\nCan't continue.");
|
||||
return false;
|
||||
}
|
||||
|
||||
@ -68,15 +67,15 @@ bool FormatSDCard(u64 hidden_mb, u32 cluster_size, const char* label) {
|
||||
|
||||
// one last warning....
|
||||
// 0:/Nintendo 3DS/ write permission is ignored here, this warning is enough
|
||||
if (!ShowUnlockSequence(5, "%s", STR_WARNING_PROCEEDING_WILL_FORMAT_SD_DELETE_ALL_DATA))
|
||||
if (!ShowUnlockSequence(5, "!WARNING!\n \nProceeding will format this SD.\nThis will irreversibly delete\nALL data on it."))
|
||||
return false;
|
||||
ShowString("%s", STR_FORMATTING_SD_PLEASE_WAIT);
|
||||
ShowString("Formatting SD, please wait...");
|
||||
|
||||
// write the MBR to disk
|
||||
// !this assumes a fully deinitialized file system!
|
||||
if ((sdmmc_sdcard_init() != 0) || (sdmmc_sdcard_writesectors(0, 1, mbr) != 0) ||
|
||||
(emu_size && ((sdmmc_nand_readsectors(0, 1, ncsd) != 0) || (sdmmc_sdcard_writesectors(1, 1, ncsd) != 0)))) {
|
||||
ShowPrompt(false, "%s", STR_ERROR_SD_CARD_IO_FAILURE);
|
||||
ShowPrompt(false, "Error: SD card i/o failure");
|
||||
return false;
|
||||
}
|
||||
|
||||
@ -105,9 +104,9 @@ bool FormatSDCard(u64 hidden_mb, u32 cluster_size, const char* label) {
|
||||
}
|
||||
|
||||
bool SetupBonusDrive(void) {
|
||||
if (!ShowUnlockSequence(3, "%s", STR_FORMAT_BONUS_DRIVE_DELETE_ALL_DATA))
|
||||
if (!ShowUnlockSequence(3, "Format the bonus drive?\nThis will irreversibly delete\nALL data on it."))
|
||||
return false;
|
||||
ShowString("%s", STR_FORMATTING_DRIVE_PLEASE_WAIT);
|
||||
ShowString("Formatting drive, please wait...");
|
||||
if (GetMountState() & IMG_NAND) InitImgFS(NULL);
|
||||
|
||||
u8* buffer = (u8*) malloc(STD_BUFFER_SIZE);
|
||||
@ -128,10 +127,10 @@ bool FileUnlock(const char* path) {
|
||||
|
||||
if (!(DriveType(path) & DRV_FAT)) return true; // can't really check this
|
||||
if ((res = fx_open(&file, path, FA_READ | FA_OPEN_EXISTING)) != FR_OK) {
|
||||
char pathstr[UTF_BUFFER_BYTESIZE(32)];
|
||||
char pathstr[32 + 1];
|
||||
TruncateString(pathstr, path, 32, 8);
|
||||
if (GetMountState() && (res == FR_LOCKED) &&
|
||||
(ShowPrompt(true, "%s\n%s", pathstr, STR_FILE_IS_MOUNTED_UNMOUNT_TO_UNLOCK))) {
|
||||
(ShowPrompt(true, "%s\nFile is currently mounted.\nUnmount to unlock?", pathstr))) {
|
||||
InitImgFS(NULL);
|
||||
if (fx_open(&file, path, FA_READ | FA_OPEN_EXISTING) != FR_OK)
|
||||
return false;
|
||||
@ -162,7 +161,7 @@ size_t FileGetSize(const char* path) {
|
||||
return fno.fsize;
|
||||
}
|
||||
|
||||
bool FileGetSha(const char* path, u8* hash, u64 offset, u64 size, bool sha1) {
|
||||
bool FileGetSha256(const char* path, u8* sha256, u64 offset, u64 size) {
|
||||
bool ret = true;
|
||||
FIL file;
|
||||
u64 fsize;
|
||||
@ -180,7 +179,7 @@ bool FileGetSha(const char* path, u8* hash, u64 offset, u64 size, bool sha1) {
|
||||
if (!buffer) return false;
|
||||
|
||||
ShowProgress(0, 0, path);
|
||||
sha_init(sha1 ? SHA1_MODE : SHA256_MODE);
|
||||
sha_init(SHA256_MODE);
|
||||
for (u64 pos = 0; (pos < size) && ret; pos += bufsiz) {
|
||||
UINT read_bytes = min(bufsiz, size - pos);
|
||||
UINT bytes_read = 0;
|
||||
@ -191,7 +190,7 @@ bool FileGetSha(const char* path, u8* hash, u64 offset, u64 size, bool sha1) {
|
||||
sha_update(buffer, bytes_read);
|
||||
}
|
||||
|
||||
sha_get(hash);
|
||||
sha_get(sha256);
|
||||
fvx_close(&file);
|
||||
free(buffer);
|
||||
|
||||
@ -251,7 +250,7 @@ bool FileInjectFile(const char* dest, const char* orig, u64 off_dest, u64 off_or
|
||||
|
||||
if (!CheckWritePermissions(dest)) return false;
|
||||
if (strncasecmp(dest, orig, 256) == 0) {
|
||||
ShowPrompt(false, "%s", STR_ERROR_CANT_INJECT_FILE_INTO_ITSELF);
|
||||
ShowPrompt(false, "Error: Can't inject file into itself");
|
||||
return false;
|
||||
}
|
||||
|
||||
@ -270,12 +269,12 @@ bool FileInjectFile(const char* dest, const char* orig, u64 off_dest, u64 off_or
|
||||
|
||||
// check file limits
|
||||
if (!allow_expand && (off_dest + size > fvx_size(&dfile))) {
|
||||
ShowPrompt(false, "%s", STR_OPERATION_WOULD_WRITE_BEYOND_EOF);
|
||||
ShowPrompt(false, "Operation would write beyond end of file");
|
||||
fvx_close(&dfile);
|
||||
fvx_close(&ofile);
|
||||
return false;
|
||||
} else if (off_orig + size > fvx_size(&ofile)) {
|
||||
ShowPrompt(false, "%s", STR_NOT_ENOUGH_DATA_IN_FILE);
|
||||
ShowPrompt(false, "Not enough data in file");
|
||||
fvx_close(&dfile);
|
||||
fvx_close(&ofile);
|
||||
return false;
|
||||
@ -296,8 +295,8 @@ bool FileInjectFile(const char* dest, const char* orig, u64 off_dest, u64 off_or
|
||||
ret = false;
|
||||
if (ret && !ShowProgress(pos + bytes_read, size, orig)) {
|
||||
if (flags && (*flags & NO_CANCEL)) {
|
||||
ShowPrompt(false, "%s", STR_CANCEL_IS_NOT_ALLOWED_HERE);
|
||||
} else ret = !ShowPrompt(true, "%s", STR_B_DETECTED_CANCEL);
|
||||
ShowPrompt(false, "Cancel is not allowed here");
|
||||
} else ret = !ShowPrompt(true, "B button detected. Cancel?");
|
||||
ShowProgress(0, 0, orig);
|
||||
ShowProgress(pos + bytes_read, size, orig);
|
||||
}
|
||||
@ -326,7 +325,7 @@ bool FileSetByte(const char* dest, u64 offset, u64 size, u8 fillbyte, u32* flags
|
||||
|
||||
// check file limits
|
||||
if (!allow_expand && (offset + size > fvx_size(&dfile))) {
|
||||
ShowPrompt(false, "%s", STR_OPERATION_WOULD_WRITE_BEYOND_EOF);
|
||||
ShowPrompt(false, "Operation would write beyond end of file");
|
||||
fvx_close(&dfile);
|
||||
return false;
|
||||
}
|
||||
@ -346,8 +345,8 @@ bool FileSetByte(const char* dest, u64 offset, u64 size, u8 fillbyte, u32* flags
|
||||
ret = false;
|
||||
if (ret && !ShowProgress(pos + bytes_written, size, dest)) {
|
||||
if (flags && (*flags & NO_CANCEL)) {
|
||||
ShowPrompt(false, "%s", STR_CANCEL_IS_NOT_ALLOWED_HERE);
|
||||
} else ret = !ShowPrompt(true, "%s", STR_B_DETECTED_CANCEL);
|
||||
ShowPrompt(false, "Cancel is not allowed here");
|
||||
} else ret = !ShowPrompt(true, "B button detected. Cancel?");
|
||||
ShowProgress(0, 0, dest);
|
||||
ShowProgress(pos + bytes_written, size, dest);
|
||||
}
|
||||
@ -363,8 +362,8 @@ bool FileSetByte(const char* dest, u64 offset, u64 size, u8 fillbyte, u32* flags
|
||||
bool FileCreateDummy(const char* cpath, const char* filename, u64 size) {
|
||||
char npath[256]; // 256 is the maximum length of a full path
|
||||
if (!CheckWritePermissions(cpath)) return false;
|
||||
if (filename) snprintf(npath, sizeof(npath), "%s/%s", cpath, filename);
|
||||
else snprintf(npath, sizeof(npath), "%s", cpath);
|
||||
if (filename) snprintf(npath, 255, "%s/%s", cpath, filename);
|
||||
else snprintf(npath, 255, "%s", cpath);
|
||||
|
||||
// create dummy file (fail if already existing)
|
||||
// then, expand the file size via cluster preallocation
|
||||
@ -381,7 +380,7 @@ bool FileCreateDummy(const char* cpath, const char* filename, u64 size) {
|
||||
bool DirCreate(const char* cpath, const char* dirname) {
|
||||
char npath[256]; // 256 is the maximum length of a full path
|
||||
if (!CheckWritePermissions(cpath)) return false;
|
||||
snprintf(npath, sizeof(npath), "%s/%s", cpath, dirname);
|
||||
snprintf(npath, 255, "%s/%s", cpath, dirname);
|
||||
if (fa_mkdir(npath) != FR_OK) return false;
|
||||
return (fa_stat(npath, NULL) == FR_OK);
|
||||
}
|
||||
@ -449,7 +448,6 @@ bool PathMoveCopyRec(char* dest, char* orig, u32* flags, bool move, u8* buffer,
|
||||
bool silent = (flags && (*flags & SILENT));
|
||||
bool append = (flags && (*flags & APPEND_ALL));
|
||||
bool calcsha = (flags && (*flags & CALC_SHA) && !append);
|
||||
bool sha1 = (flags && (*flags & USE_SHA1));
|
||||
bool ret = false;
|
||||
|
||||
// check destination write permission (special paths only)
|
||||
@ -462,12 +460,12 @@ bool PathMoveCopyRec(char* dest, char* orig, u32* flags, bool move, u8* buffer,
|
||||
if (move && (to_virtual || fno.fattrib & AM_VRT)) return false; // trying to move a virtual file
|
||||
|
||||
// path string (for output)
|
||||
char deststr[UTF_BUFFER_BYTESIZE(36)];
|
||||
char deststr[36 + 1];
|
||||
TruncateString(deststr, dest, 36, 8);
|
||||
|
||||
// the copy process takes place here
|
||||
if (!ShowProgress(0, 0, orig) && !(flags && (*flags & NO_CANCEL))) {
|
||||
if (ShowPrompt(true, "%s\n%s", deststr, STR_B_DETECTED_CANCEL)) return false;
|
||||
if (ShowPrompt(true, "%s\nB button detected. Cancel?", deststr)) return false;
|
||||
ShowProgress(0, 0, orig);
|
||||
}
|
||||
if (move && fvx_stat(dest, NULL) != FR_OK) { // moving if dest not existing
|
||||
@ -477,14 +475,14 @@ bool PathMoveCopyRec(char* dest, char* orig, u32* flags, bool move, u8* buffer,
|
||||
char* fname = orig + strnlen(orig, 256);
|
||||
|
||||
if (append) {
|
||||
if (!silent) ShowPrompt(false, "%s\n%s", deststr, STR_ERROR_CANNOT_APPEND_FOLDER);
|
||||
if (!silent) ShowPrompt(false, "%s\nError: Cannot append a folder", deststr);
|
||||
return false;
|
||||
}
|
||||
|
||||
// create the destination folder if it does not already exist
|
||||
if (fvx_opendir(&pdir, dest) != FR_OK) {
|
||||
if (fvx_mkdir(dest) != FR_OK) {
|
||||
if (!silent) ShowPrompt(false, "%s\n%s", deststr, STR_ERROR_OVERWRITING_FILE_WITH_DIR);
|
||||
if (!silent) ShowPrompt(false, "%s\nError: Overwriting file with dir", deststr);
|
||||
return false;
|
||||
}
|
||||
} else fvx_closedir(&pdir);
|
||||
@ -517,7 +515,7 @@ bool PathMoveCopyRec(char* dest, char* orig, u32* flags, bool move, u8* buffer,
|
||||
} else if (move) { // moving if destination exists
|
||||
if (fvx_stat(dest, &fno) != FR_OK) return false;
|
||||
if (fno.fattrib & AM_DIR) {
|
||||
if (!silent) ShowPrompt(false, "%s\n%s", deststr, STR_ERROR_OVERWRITING_DIR_WITH_FILE);
|
||||
if (!silent) ShowPrompt(false, "%s\nError: Overwriting dir with file", deststr);
|
||||
return false;
|
||||
}
|
||||
if (fvx_unlink(dest) != FR_OK) return false;
|
||||
@ -536,7 +534,7 @@ bool PathMoveCopyRec(char* dest, char* orig, u32* flags, bool move, u8* buffer,
|
||||
|
||||
if ((!append || (fvx_open(&dfile, dest, FA_WRITE | FA_OPEN_EXISTING) != FR_OK)) &&
|
||||
(fvx_open(&dfile, dest, FA_WRITE | FA_CREATE_ALWAYS) != FR_OK)) {
|
||||
if (!silent) ShowPrompt(false, "%s\n%s", deststr, STR_ERROR_CANNOT_OPEN_DESTINATION_FILE);
|
||||
if (!silent) ShowPrompt(false, "%s\nError: Cannot open destination file", deststr);
|
||||
fvx_close(&ofile);
|
||||
return false;
|
||||
}
|
||||
@ -545,7 +543,7 @@ bool PathMoveCopyRec(char* dest, char* orig, u32* flags, bool move, u8* buffer,
|
||||
osize = fvx_size(&ofile);
|
||||
dsize = append ? fvx_size(&dfile) : 0; // always 0 if not appending to file
|
||||
if ((fvx_lseek(&dfile, (osize + dsize)) != FR_OK) || (fvx_sync(&dfile) != FR_OK) || (fvx_tell(&dfile) != (osize + dsize))) { // check space via cluster preallocation
|
||||
if (!silent) ShowPrompt(false, "%s\n%s", deststr, STR_ERROR_NOT_ENOUGH_SPACE_AVAILABLE);
|
||||
if (!silent) ShowPrompt(false, "%s\nError: Not enough space available", deststr);
|
||||
ret = false;
|
||||
}
|
||||
|
||||
@ -554,7 +552,7 @@ bool PathMoveCopyRec(char* dest, char* orig, u32* flags, bool move, u8* buffer,
|
||||
fvx_lseek(&ofile, 0);
|
||||
fvx_sync(&ofile);
|
||||
|
||||
if (calcsha) sha_init(sha1 ? SHA1_MODE : SHA256_MODE);
|
||||
if (calcsha) sha_init(SHA256_MODE);
|
||||
for (u64 pos = 0; (pos < osize) && ret; pos += bufsiz) {
|
||||
UINT bytes_read = 0;
|
||||
UINT bytes_written = 0;
|
||||
@ -567,8 +565,8 @@ bool PathMoveCopyRec(char* dest, char* orig, u32* flags, bool move, u8* buffer,
|
||||
u64 total = osize;
|
||||
if (ret && !ShowProgress(current, total, orig)) {
|
||||
if (flags && (*flags & NO_CANCEL)) {
|
||||
ShowPrompt(false, "%s\n%s", deststr, STR_CANCEL_IS_NOT_ALLOWED_HERE);
|
||||
} else ret = !ShowPrompt(true, "%s\n%s", deststr, STR_B_DETECTED_CANCEL);
|
||||
ShowPrompt(false, "%s\nCancel is not allowed here", deststr);
|
||||
} else ret = !ShowPrompt(true, "%s\nB button detected. Cancel?", deststr);
|
||||
ShowProgress(0, 0, orig);
|
||||
ShowProgress(current, total, orig);
|
||||
}
|
||||
@ -582,11 +580,11 @@ bool PathMoveCopyRec(char* dest, char* orig, u32* flags, bool move, u8* buffer,
|
||||
if (!ret && ((dsize == 0) || (fvx_lseek(&dfile, dsize) != FR_OK) || (f_truncate(&dfile) != FR_OK))) {
|
||||
fvx_unlink(dest);
|
||||
} else if (!to_virtual && calcsha) {
|
||||
u8 hash[0x20];
|
||||
u8 sha256[0x20];
|
||||
char* ext_sha = dest + strnlen(dest, 256);
|
||||
snprintf(ext_sha, 256 - (ext_sha - dest), ".sha%c", sha1 ? '1' : '\0');
|
||||
sha_get(hash);
|
||||
FileSetData(dest, hash, sha1 ? 20 : 32, 0, true);
|
||||
strncpy(ext_sha, ".sha", 256 - (ext_sha - dest));
|
||||
sha_get(sha256);
|
||||
FileSetData(dest, sha256, 0x20, 0, true);
|
||||
}
|
||||
}
|
||||
|
||||
@ -610,19 +608,19 @@ bool PathMoveCopy(const char* dest, const char* orig, u32* flags, bool move) {
|
||||
char lorig[256];
|
||||
strncpy(ldest, dest, 256);
|
||||
strncpy(lorig, orig, 256);
|
||||
char deststr[UTF_BUFFER_BYTESIZE(36)];
|
||||
char deststr[36 + 1];
|
||||
TruncateString(deststr, ldest, 36, 8);
|
||||
|
||||
// moving only for regular FAT drives (= not alias drives)
|
||||
if (move && !(ddrvtype & odrvtype & DRV_STDFAT)) {
|
||||
ShowPrompt(false, "%s", STR_ERROR_ONLY_FAT_FILES_CAN_BE_MOVED);
|
||||
ShowPrompt(false, "Error: Only FAT files can be moved");
|
||||
return false;
|
||||
}
|
||||
|
||||
// is destination part of origin?
|
||||
u32 olen = strnlen(lorig, 255);
|
||||
if ((strncasecmp(ldest, lorig, olen) == 0) && (ldest[olen] == '/')) {
|
||||
ShowPrompt(false, "%s\n%s", deststr, STR_ERROR_DESTINATION_IS_PART_OF_ORIGIN);
|
||||
ShowPrompt(false, "%s\nError: Destination is part of origin", deststr);
|
||||
return false;
|
||||
}
|
||||
|
||||
@ -634,7 +632,7 @@ bool PathMoveCopy(const char* dest, const char* orig, u32* flags, bool move) {
|
||||
|
||||
// check & fix destination == origin
|
||||
while (strncasecmp(ldest, lorig, 255) == 0) {
|
||||
if (!ShowKeyboardOrPrompt(dname, 255 - (dname - ldest), "%s\n%s", deststr, STR_ERROR_DESTINATION_EQUALS_ORIGIN_CHOOSE_ANOTHER_NAME))
|
||||
if (!ShowKeyboardOrPrompt(dname, 255 - (dname - ldest), "%s\nDestination equals origin\nChoose another name?", deststr))
|
||||
return false;
|
||||
}
|
||||
|
||||
@ -645,11 +643,12 @@ bool PathMoveCopy(const char* dest, const char* orig, u32* flags, bool move) {
|
||||
return true;
|
||||
}
|
||||
const char* optionstr[5] =
|
||||
{STR_CHOOSE_NEW_NAME, STR_OVERWRITE_FILES, STR_SKIP_FILES, STR_OVERWRITE_ALL, STR_SKIP_ALL};
|
||||
u32 user_select = ShowSelectPrompt((*flags & ASK_ALL) ? 5 : 3, optionstr, STR_DESTINATION_ALREADY_EXISTS, deststr);
|
||||
{"Choose new name", "Overwrite file(s)", "Skip file(s)", "Overwrite all", "Skip all"};
|
||||
u32 user_select = ShowSelectPrompt((*flags & ASK_ALL) ? 5 : 3, optionstr,
|
||||
"Destination already exists:\n%s", deststr);
|
||||
if (user_select == 1) {
|
||||
do {
|
||||
if (!ShowKeyboardOrPrompt(dname, 255 - (dname - ldest), "%s", STR_CHOOSE_NEW_DESTINATION_NAME))
|
||||
if (!ShowKeyboardOrPrompt(dname, 255 - (dname - ldest), "Choose new destination name"))
|
||||
return false;
|
||||
} while (fa_stat(ldest, NULL) == FR_OK);
|
||||
} else if (user_select == 2) {
|
||||
@ -673,7 +672,7 @@ bool PathMoveCopy(const char* dest, const char* orig, u32* flags, bool move) {
|
||||
// setup buffer
|
||||
u8* buffer = (u8*) malloc(STD_BUFFER_SIZE);
|
||||
if (!buffer) {
|
||||
ShowPrompt(false, "%s", STR_OUT_OF_MEMORY);
|
||||
ShowPrompt(false, "Out of memory.");
|
||||
return false;
|
||||
}
|
||||
|
||||
@ -699,20 +698,20 @@ bool PathMoveCopy(const char* dest, const char* orig, u32* flags, bool move) {
|
||||
|
||||
// prevent illegal operations
|
||||
if (force_unmount && (odrvtype & ddrvtype & (DRV_SYSNAND|DRV_EMUNAND|DRV_IMAGE))) {
|
||||
ShowPrompt(false, "%s", STR_COPY_OPERATION_IS_NOT_ALLOWED);
|
||||
ShowPrompt(false, "Copy operation is not allowed");
|
||||
return false;
|
||||
}
|
||||
|
||||
// check destination == origin
|
||||
if (strncasecmp(ldest, lorig, 255) == 0) {
|
||||
ShowPrompt(false, "%s\n%s", deststr, STR_DESTINATION_EQUALS_ORIGIN);
|
||||
ShowPrompt(false, "%s\nDestination equals origin", deststr);
|
||||
return false;
|
||||
}
|
||||
|
||||
// setup buffer
|
||||
u8* buffer = (u8*) malloc(STD_BUFFER_SIZE);
|
||||
if (!buffer) {
|
||||
ShowPrompt(false, "%s", STR_OUT_OF_MEMORY);
|
||||
ShowPrompt(false, "Out of memory.");
|
||||
return false;
|
||||
}
|
||||
|
||||
@ -731,7 +730,7 @@ bool PathCopy(const char* destdir, const char* orig, u32* flags) {
|
||||
char dest[256]; // maximum path name length in FAT
|
||||
char* oname = strrchr(orig, '/');
|
||||
if (oname == NULL) return false; // not a proper origin path
|
||||
snprintf(dest, sizeof(dest), "%s/%s", destdir, (++oname));
|
||||
snprintf(dest, 255, "%s/%s", destdir, (++oname));
|
||||
|
||||
// virtual destination special handling
|
||||
if (GetVirtualSource(destdir) & ~VRT_BDRI) {
|
||||
@ -745,12 +744,12 @@ bool PathCopy(const char* destdir, const char* orig, u32* flags) {
|
||||
if (!ReadVirtualDir(&dvfile, &vdir)) return false;
|
||||
if (dvfile.size == osize) break; // file found
|
||||
}
|
||||
if (!ShowPrompt(true, STR_ENTRY_NOT_FOUND_PATH_INJECT_INTO_PATH_INSTEAD, dest, dvfile.name))
|
||||
if (!ShowPrompt(true, "Entry not found: %s\nInject into %s instead?", dest, dvfile.name))
|
||||
return false;
|
||||
snprintf(dest, sizeof(dest), "%s/%s", destdir, dvfile.name);
|
||||
snprintf(dest, 255, "%s/%s", destdir, dvfile.name);
|
||||
} else if (osize < dvfile.size) { // if origin is smaller than destination...
|
||||
char deststr[UTF_BUFFER_BYTESIZE(36)];
|
||||
char origstr[UTF_BUFFER_BYTESIZE(36)];
|
||||
char deststr[36 + 1];
|
||||
char origstr[36 + 1];
|
||||
char osizestr[32];
|
||||
char dsizestr[32];
|
||||
TruncateString(deststr, dest, 36, 8);
|
||||
@ -758,7 +757,7 @@ bool PathCopy(const char* destdir, const char* orig, u32* flags) {
|
||||
FormatBytes(osizestr, osize);
|
||||
FormatBytes(dsizestr, dvfile.size);
|
||||
if (dvfile.size > osize) {
|
||||
if (!ShowPrompt(true, STR_FILE_SMALLER_THAN_SPACE_SIZES_CONTINUE, origstr, osizestr, deststr, dsizestr))
|
||||
if (!ShowPrompt(true, "File smaller than available space:\n%s (%s)\n%s (%s)\nContinue?", origstr, osizestr, deststr, dsizestr))
|
||||
return false;
|
||||
}
|
||||
}
|
||||
@ -772,7 +771,7 @@ bool PathMove(const char* destdir, const char* orig, u32* flags) {
|
||||
char dest[256]; // maximum path name length in FAT
|
||||
char* oname = strrchr(orig, '/');
|
||||
if (oname == NULL) return false; // not a proper origin path
|
||||
snprintf(dest, sizeof(dest), "%s/%s", destdir, (++oname));
|
||||
snprintf(dest, 255, "%s/%s", destdir, (++oname));
|
||||
|
||||
return PathMoveCopy(dest, orig, flags, true);
|
||||
}
|
||||
@ -822,7 +821,7 @@ bool FileSelectorWorker(char* result, const char* text, const char* path, const
|
||||
GetDirContents(contents, path_local);
|
||||
|
||||
while (pos < contents->n_entries) {
|
||||
char opt_names[_MAX_FS_OPT+1][UTF_BUFFER_BYTESIZE(32)];
|
||||
char opt_names[_MAX_FS_OPT+1][32+1];
|
||||
DirEntry* res_entry[MAX_DIR_ENTRIES+1] = { NULL };
|
||||
u32 n_opt = 0;
|
||||
for (; pos < contents->n_entries; pos++) {
|
||||
@ -832,13 +831,13 @@ bool FileSelectorWorker(char* result, const char* text, const char* path, const
|
||||
(entry->type == T_DOTDOT) || (strncmp(entry->name, "._", 2) == 0))
|
||||
continue;
|
||||
if (!new_style && n_opt == _MAX_FS_OPT) {
|
||||
snprintf(opt_names[n_opt++], 32, "%s", STR_BRACKET_MORE);
|
||||
snprintf(opt_names[n_opt++], 32, "[more...]");
|
||||
break;
|
||||
}
|
||||
|
||||
if (!new_style) {
|
||||
char temp_str[256];
|
||||
snprintf(temp_str, sizeof(temp_str), "%s", entry->name);
|
||||
snprintf(temp_str, 256, "%s", entry->name);
|
||||
if (hide_ext && (entry->type == T_FILE)) {
|
||||
char* dot = strrchr(temp_str, '.');
|
||||
if (dot) *dot = '\0';
|
||||
@ -849,7 +848,7 @@ bool FileSelectorWorker(char* result, const char* text, const char* path, const
|
||||
n_found++;
|
||||
}
|
||||
if ((pos >= contents->n_entries) && (n_opt < n_found) && !new_style)
|
||||
snprintf(opt_names[n_opt++], 32, "%s", STR_BRACKET_MORE);
|
||||
snprintf(opt_names[n_opt++], 32, "[more...]");
|
||||
if (!n_opt) break;
|
||||
|
||||
const char* optionstr[_MAX_FS_OPT+1] = { NULL };
|
||||
@ -872,9 +871,9 @@ bool FileSelectorWorker(char* result, const char* text, const char* path, const
|
||||
}
|
||||
}
|
||||
if (!n_found) { // not a single matching entry found
|
||||
char pathstr[UTF_BUFFER_BYTESIZE(32)];
|
||||
char pathstr[32+1];
|
||||
TruncateString(pathstr, path_local, 32, 8);
|
||||
ShowPrompt(false, "%s\n%s", pathstr, STR_NO_USABLE_ENTRIES_FOUND);
|
||||
ShowPrompt(false, "%s\nNo usable entries found.", pathstr);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
@ -7,13 +7,12 @@
|
||||
#define NO_CANCEL (1UL<<1)
|
||||
#define SILENT (1UL<<2)
|
||||
#define CALC_SHA (1UL<<3)
|
||||
#define USE_SHA1 (1UL<<4)
|
||||
#define BUILD_PATH (1UL<<5)
|
||||
#define ALLOW_EXPAND (1UL<<6)
|
||||
#define ASK_ALL (1UL<<7)
|
||||
#define SKIP_ALL (1UL<<8)
|
||||
#define OVERWRITE_ALL (1UL<<9)
|
||||
#define APPEND_ALL (1UL<<10)
|
||||
#define BUILD_PATH (1UL<<4)
|
||||
#define ALLOW_EXPAND (1UL<<5)
|
||||
#define ASK_ALL (1UL<<6)
|
||||
#define SKIP_ALL (1UL<<7)
|
||||
#define OVERWRITE_ALL (1UL<<8)
|
||||
#define APPEND_ALL (1UL<<9)
|
||||
|
||||
// file selector flags
|
||||
#define NO_DIRS (1UL<<0)
|
||||
@ -44,7 +43,7 @@ size_t FileGetData(const char* path, void* data, size_t size, size_t foffset);
|
||||
size_t FileGetSize(const char* path);
|
||||
|
||||
/** Get SHA-256 of file **/
|
||||
bool FileGetSha(const char* path, u8* hash, u64 offset, u64 size, bool sha1);
|
||||
bool FileGetSha256(const char* path, u8* sha256, u64 offset, u64 size);
|
||||
|
||||
/** Find data in file **/
|
||||
u32 FileFindData(const char* path, u8* data, u32 size_data, u32 offset_file);
|
||||
|
||||
@ -276,7 +276,7 @@ bool SetupNandSdDrive(const char* path, const char* sd_path, const char* movable
|
||||
// build the alias path (id0)
|
||||
u32 sha256sum[8];
|
||||
sha_quick(sha256sum, sd_keyy[num], 0x10, SHA256_MODE);
|
||||
snprintf(alias, sizeof(alias), "%s/Nintendo 3DS/%08lX%08lX%08lX%08lX",
|
||||
snprintf(alias, 127, "%s/Nintendo 3DS/%08lX%08lX%08lX%08lX",
|
||||
sd_path, sha256sum[0], sha256sum[1], sha256sum[2], sha256sum[3]);
|
||||
|
||||
// find the alias path (id1)
|
||||
|
||||
@ -17,7 +17,7 @@ bool CheckSupportFile(const char* fname)
|
||||
const char* base_paths[] = { SUPPORT_FILE_PATHS };
|
||||
for (u32 i = 0; i < countof(base_paths); i++) {
|
||||
char path[256];
|
||||
snprintf(path, sizeof(path), "%s/%s", base_paths[i], fname);
|
||||
snprintf(path, 256, "%s/%s", base_paths[i], fname);
|
||||
if (fvx_stat(path, NULL) == FR_OK)
|
||||
return true;
|
||||
}
|
||||
@ -40,7 +40,7 @@ size_t LoadSupportFile(const char* fname, void* buffer, size_t max_len)
|
||||
for (u32 i = 0; i < countof(base_paths); i++) {
|
||||
UINT len32;
|
||||
char path[256];
|
||||
snprintf(path, sizeof(path), "%s/%s", base_paths[i], fname);
|
||||
snprintf(path, 256, "%s/%s", base_paths[i], fname);
|
||||
if (fvx_qread(path, buffer, 0, max_len, &len32) == FR_OK)
|
||||
return len32;
|
||||
}
|
||||
@ -68,7 +68,7 @@ bool SaveSupportFile(const char* fname, void* buffer, size_t len)
|
||||
// write support file
|
||||
if (idx >= 0) {
|
||||
char path[256];
|
||||
snprintf(path, sizeof(path), "%s/%s", base_paths[idx], fname);
|
||||
snprintf(path, 256, "%s/%s", base_paths[idx], fname);
|
||||
fvx_unlink(path);
|
||||
if (fvx_qwrite(path, buffer, 0, len, NULL) == FR_OK)
|
||||
return true;
|
||||
|
||||
@ -3,9 +3,7 @@
|
||||
#include "common.h"
|
||||
|
||||
// scripts / payloads dir names
|
||||
#define LANGUAGES_DIR "languages"
|
||||
#define SCRIPTS_DIR "scripts"
|
||||
#define LUASCRIPTS_DIR "luascripts"
|
||||
#define PAYLOADS_DIR "payloads"
|
||||
|
||||
bool CheckSupportFile(const char* fname);
|
||||
@ -13,6 +11,5 @@ size_t LoadSupportFile(const char* fname, void* buffer, size_t max_len);
|
||||
bool SaveSupportFile(const char* fname, void* buffer, size_t len);
|
||||
bool SetAsSupportFile(const char* fname, const char* source);
|
||||
|
||||
bool GetSupportDir(char* path, const char* dname);
|
||||
bool CheckSupportDir(const char* fpath);
|
||||
bool FileSelectorSupport(char* result, const char* text, const char* dname, const char* pattern);
|
||||
|
||||
@ -8,7 +8,6 @@
|
||||
|
||||
#define fvx_tell(fp) ((fp)->fptr)
|
||||
#define fvx_size(fp) ((fp)->obj.objsize)
|
||||
#define fvx_eof(fp) (fvx_tell(fp) == fvx_size(fp))
|
||||
|
||||
#define FN_ANY 0x00
|
||||
#define FN_HIGHEST 0x01
|
||||
|
||||
@ -2,7 +2,6 @@
|
||||
#include "vff.h"
|
||||
|
||||
#define FAT_ENTRY_SIZE 2 * sizeof(u32)
|
||||
#define REPLACE_SIZE_MISMATCH 2
|
||||
|
||||
#define getfatflag(uv) (((uv) & 0x80000000UL) != 0)
|
||||
#define getfatindex(uv) ((uv) & 0x7FFFFFFFUL)
|
||||
@ -370,8 +369,7 @@ static u32 AddBDRIEntry(const BDRIFsHeader* fs_header, const u32 fs_header_offse
|
||||
|
||||
// If an entry for the tid already existed that is already the specified size and replace was specified, just replace the existing entry
|
||||
if (memcmp(title_id_be, file_entry.title_id, 8) == 0) {
|
||||
if (!replace) return 1;
|
||||
else if (file_entry.size != size) return REPLACE_SIZE_MISMATCH;
|
||||
if (!replace || (file_entry.size != size)) return 1;
|
||||
else {
|
||||
do_replace = true;
|
||||
break;
|
||||
@ -866,15 +864,10 @@ u32 AddTicketToDB(const char* path, const u8* title_id, const Ticket* ticket, bo
|
||||
|
||||
bdrifp = &file;
|
||||
|
||||
u32 add_bdri_res = 0;
|
||||
|
||||
if ((BDRIRead(0, sizeof(TickDBPreHeader), &pre_header) != FR_OK) ||
|
||||
!CheckDBMagic((u8*) &pre_header, true) ||
|
||||
((add_bdri_res = AddBDRIEntry(&(pre_header.fs_header), sizeof(TickDBPreHeader) - sizeof(BDRIFsHeader), title_id,
|
||||
(const u8*) te, entry_size, replace)) == 1) ||
|
||||
(add_bdri_res == REPLACE_SIZE_MISMATCH && ((RemoveBDRIEntry(&(pre_header.fs_header), sizeof(TickDBPreHeader) - sizeof(BDRIFsHeader), title_id) != 0) ||
|
||||
(AddBDRIEntry(&(pre_header.fs_header), sizeof(TickDBPreHeader) - sizeof(BDRIFsHeader), title_id,
|
||||
(const u8*) te, entry_size, replace) != 0)))) {
|
||||
(const u8*) te, entry_size, replace) != 0)) {
|
||||
free(te);
|
||||
fvx_close(bdrifp);
|
||||
bdrifp = NULL;
|
||||
|
||||
@ -18,7 +18,6 @@
|
||||
|
||||
#include <libgen.h>
|
||||
|
||||
#include "language.h"
|
||||
#include "common.h"
|
||||
#include "timer.h"
|
||||
#include "crc32.h"
|
||||
@ -144,18 +143,18 @@ static bool BEAT_UpdateProgress(const BEAT_Context *ctx)
|
||||
static const char *BEAT_ErrString(int error)
|
||||
{ // Get an error description string
|
||||
switch(error) {
|
||||
case BEAT_OK: return STR_BEAT_NO_ERROR;
|
||||
case BEAT_EOAL: return STR_BEAT_END_OF_ACTION_LIST;
|
||||
case BEAT_ABORTED: return STR_BEAT_ABORTED_BY_USER;
|
||||
case BEAT_IO_ERROR: return STR_BEAT_FAILED_TO_READ_WRITE_FILE;
|
||||
case BEAT_OVERFLOW: return STR_BEAT_ATTEMPTED_TO_WRITE_BEYOND_EOF;
|
||||
case BEAT_BADPATCH: return STR_BEAT_INVALID_PATCH_FILE;
|
||||
case BEAT_BADINPUT: return STR_BEAT_INVALID_INPUT_FILE;
|
||||
case BEAT_BADOUTPUT: return STR_BEAT_OUTPUT_FILE_CHECKSUM_MISMATCH;
|
||||
case BEAT_BADCHKSUM: return STR_BEAT_FILE_CHECKSUM_FAILED;
|
||||
case BEAT_PATCH_EXPECT: return STR_BEAT_EXPECTED_MORE_PATCH_DATA;
|
||||
case BEAT_OUT_OF_MEMORY: return STR_BEAT_OUT_OF_MEMORY;
|
||||
default: return STR_BEAT_UNKNOWN_ERROR;
|
||||
case BEAT_OK: return "No error";
|
||||
case BEAT_EOAL: return "End of action list";
|
||||
case BEAT_ABORTED: return "Aborted by user";
|
||||
case BEAT_IO_ERROR: return "Failed to read/write file";
|
||||
case BEAT_OVERFLOW: return "Attempted to write beyond end of file";
|
||||
case BEAT_BADPATCH: return "Invalid patch file";
|
||||
case BEAT_BADINPUT: return "Invalid input file";
|
||||
case BEAT_BADOUTPUT: return "Output file checksum mismatch";
|
||||
case BEAT_BADCHKSUM: return "File checksum failed";
|
||||
case BEAT_PATCH_EXPECT: return "Expected more patch data";
|
||||
case BEAT_OUT_OF_MEMORY: return "Out of memory";
|
||||
default: return "Unknown error";
|
||||
}
|
||||
}
|
||||
|
||||
@ -222,7 +221,7 @@ static s32 BEAT_DecodeSigned(u32 val) // Extract the signed number
|
||||
static int BEAT_RunActions(BEAT_Context *ctx, const BEAT_Action *acts)
|
||||
{ // Parses an action list and runs commands specified in `acts`
|
||||
u32 vli, len;
|
||||
int cmd, res = BEAT_OK;
|
||||
int cmd, res;
|
||||
|
||||
while((res == BEAT_OK) &&
|
||||
(ctx->foff[BEAT_PF] < (BEAT_RANGE(ctx, BEAT_PF) - ctx->eoal_offset))) {
|
||||
@ -661,18 +660,19 @@ static int BEAT_Run(const char *p, const char *s, const char *d, bool bpm)
|
||||
progress_timer = timer_start();
|
||||
res = (bpm ? BPM_InitCTX : BPS_InitCTX)(&ctx, p, s, d);
|
||||
if (res != BEAT_OK) {
|
||||
ShowPrompt(false, bpm ? STR_FAILED_TO_INITIALIZE_BPM_FILE : STR_FAILED_TO_INITIALIZE_BPS_FILE, BEAT_ErrString(res));
|
||||
ShowPrompt(false, "Failed to initialize %s file:\n%s",
|
||||
bpm ? "BPM" : "BPS", BEAT_ErrString(res));
|
||||
} else {
|
||||
res = (bpm ? BPM_RunActions : BPS_RunActions)(&ctx);
|
||||
switch(res) {
|
||||
case BEAT_OK:
|
||||
ShowPrompt(false, "%s", STR_PATCH_SUCCESSFULLY_APPLIED);
|
||||
ShowPrompt(false, "Patch successfully applied");
|
||||
break;
|
||||
case BEAT_ABORTED:
|
||||
ShowPrompt(false, "%s", STR_PATCHING_ABORTED_BY_USER);
|
||||
ShowPrompt(false, "Patching aborted by user");
|
||||
break;
|
||||
default:
|
||||
ShowPrompt(false, STR_FAILED_TO_RUN_PATCH, BEAT_ErrString(res));
|
||||
ShowPrompt(false, "Failed to run patch:\n%s", BEAT_ErrString(res));
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
@ -1,23 +0,0 @@
|
||||
#pragma once
|
||||
|
||||
#include "common.h"
|
||||
|
||||
#define CIFINISH_MAGIC "CIFINISH"
|
||||
#define CIFINISH_TITLE_MAGIC "TITLE"
|
||||
#define CIFINISH_SIZE(c) (sizeof(CifinishHeader) + ((((CifinishHeader*)(c))->n_entries) * sizeof(CifinishTitle)))
|
||||
|
||||
// see: https://github.com/ihaveamac/custom-install/blob/ac0be9d61d7ebef9356df23036dc53e8e862011a/custominstall.py#L163
|
||||
typedef struct {
|
||||
char magic[8];
|
||||
u32 version;
|
||||
u32 n_entries;
|
||||
} __attribute__((packed, aligned(4))) CifinishHeader;
|
||||
|
||||
typedef struct {
|
||||
char magic[5];
|
||||
u8 padding0;
|
||||
u8 has_seed; // 1 if it does, otherwise 0
|
||||
u8 padding1;
|
||||
u64 title_id;
|
||||
u8 seed[16];
|
||||
} __attribute__((packed, aligned(4))) CifinishTitle;
|
||||
@ -1,5 +1,4 @@
|
||||
#include "codelzss.h"
|
||||
#include "language.h"
|
||||
#include "ui.h"
|
||||
|
||||
#define CODE_COMP_SIZE(f) ((f)->off_size_comp & 0xFFFFFF)
|
||||
@ -46,10 +45,10 @@ u32 DecompressCodeLzss(u8* code, u32* code_size, u32 max_size) {
|
||||
|
||||
// main decompression loop
|
||||
while ((ptr_in > comp_start) && (ptr_out > comp_start)) {
|
||||
if (!ShowProgress(data_end - ptr_out, data_end - data_start, STR_DECOMPRESSING_DOT_CODE)) {
|
||||
if (ShowPrompt(true, "%s", STR_DECOMPRESSING_DOT_CODE_B_DETECTED_CANCEL)) return 1;
|
||||
ShowProgress(0, data_end - data_start, STR_DECOMPRESSING_DOT_CODE);
|
||||
ShowProgress(data_end - ptr_out, data_end - data_start, STR_DECOMPRESSING_DOT_CODE);
|
||||
if (!ShowProgress(data_end - ptr_out, data_end - data_start, "Decompressing .code...")) {
|
||||
if (ShowPrompt(true, "Decompressing .code...\nB button detected. Cancel?")) return 1;
|
||||
ShowProgress(0, data_end - data_start, "Decompressing .code...");
|
||||
ShowProgress(data_end - ptr_out, data_end - data_start, "Decompressing .code...");
|
||||
}
|
||||
|
||||
// sanity check
|
||||
@ -243,13 +242,13 @@ bool CompressCodeLzss(const u8* a_pUncompressed, u32 a_uUncompressedSize, u8* a_
|
||||
u8* pDest = a_pCompressed + a_uUncompressedSize;
|
||||
|
||||
while (pSrc - a_pUncompressed > 0 && pDest - a_pCompressed > 0) {
|
||||
if (!ShowProgress((u32)(a_pUncompressed + a_uUncompressedSize - pSrc), a_uUncompressedSize, STR_COMPRESSING_DOT_CODE)) {
|
||||
if (ShowPrompt(true, "%s", STR_COMPRESSING_DOT_CODE_B_DETECTED_CANCEL)) {
|
||||
if (!ShowProgress((u32)(a_pUncompressed + a_uUncompressedSize - pSrc), a_uUncompressedSize, "Compressing .code...")) {
|
||||
if (ShowPrompt(true, "Compressing .code...\nB button detected. Cancel?")) {
|
||||
bResult = false;
|
||||
break;
|
||||
}
|
||||
ShowProgress(0, a_uUncompressedSize, STR_COMPRESSING_DOT_CODE);
|
||||
ShowProgress((u32)(a_pUncompressed + a_uUncompressedSize - pSrc), a_uUncompressedSize, STR_COMPRESSING_DOT_CODE);
|
||||
ShowProgress(0, a_uUncompressedSize, "Compressing .code...");
|
||||
ShowProgress((u32)(a_pUncompressed + a_uUncompressedSize - pSrc), a_uUncompressedSize, "Compressing .code...");
|
||||
}
|
||||
|
||||
u8* pFlag = --pDest;
|
||||
|
||||
@ -12,19 +12,18 @@
|
||||
// valid addresses for FIRM section loading
|
||||
// pairs of start / end address, provided by Wolfvak
|
||||
#define FIRM_VALID_ADDRESS \
|
||||
0x08000040, 0x08100000, \
|
||||
0x18000000, 0x18600000, \
|
||||
0x1FF00000, 0x1FFFFC00
|
||||
|
||||
// valid addresses (installable) for FIRM section loading
|
||||
#define FIRM_VALID_ADDRESS_INSTALL \
|
||||
FIRM_VALID_ADDRESS, \
|
||||
0x08000040, 0x080F7FFF, \
|
||||
0x10000000, 0x10200000
|
||||
|
||||
// valid addresses (bootable) for FIRM section loading
|
||||
#define FIRM_VALID_ADDRESS_BOOT \
|
||||
FIRM_VALID_ADDRESS, \
|
||||
0x08000040, 0x08100000, \
|
||||
0x20000000, 0x27FFFA00
|
||||
|
||||
static const u32 whitelist_boot[] = { FIRM_VALID_ADDRESS_BOOT };
|
||||
|
||||
@ -20,4 +20,3 @@
|
||||
#include "bdri.h"
|
||||
#include "ticketdb.h"
|
||||
#include "ncchinfo.h"
|
||||
#include "cifinish.h"
|
||||
|
||||
@ -87,17 +87,3 @@ u32 ValidateAgbHeader(AgbHeader* agb) {
|
||||
|
||||
return 0;
|
||||
} */
|
||||
|
||||
// see: http://problemkaputt.de/gbatek.htm#gbacartridgeheader
|
||||
const char* AgbDestStr(const char* code) {
|
||||
switch(code[3]) {
|
||||
case 'J': return STR_REGION_JAPAN;
|
||||
case 'E': return STR_REGION_AMERICAS;
|
||||
case 'P': return STR_REGION_EUROPE;
|
||||
case 'D': return STR_REGION_GERMANY;
|
||||
case 'F': return STR_REGION_FRANCE;
|
||||
case 'I': return STR_REGION_ITALY;
|
||||
case 'S': return STR_REGION_SPAIN;
|
||||
default: return STR_REGION_UNKNOWN;
|
||||
}
|
||||
}
|
||||
|
||||
@ -1,7 +1,6 @@
|
||||
#pragma once
|
||||
|
||||
#include "common.h"
|
||||
#include "language.h"
|
||||
|
||||
#define GBAVC_MAGIC '.', 'C', 'A', 'A'
|
||||
#define AGBSAVE_MAGIC '.', 'S', 'A', 'V'
|
||||
@ -29,6 +28,16 @@
|
||||
((size) == GBASAVE_FLASH_64K) || \
|
||||
((size) == GBASAVE_FLASH_128K))
|
||||
|
||||
// see: http://problemkaputt.de/gbatek.htm#gbacartridgeheader
|
||||
#define AGB_DESTSTR(code) \
|
||||
(((code)[3] == 'J') ? "Japan" : \
|
||||
((code)[3] == 'E') ? "USA/English" : \
|
||||
((code)[3] == 'P') ? "Europe/Elsewhere" : \
|
||||
((code)[3] == 'D') ? "German" : \
|
||||
((code)[3] == 'F') ? "French" : \
|
||||
((code)[3] == 'I') ? "Italian" : \
|
||||
((code)[3] == 'S') ? "Spanish" : "Unknown")
|
||||
|
||||
|
||||
// see: http://3dbrew.org/wiki/3DS_Virtual_Console#Footer
|
||||
// still a lot of unknowns in here, also redundant stuff left out
|
||||
@ -80,8 +89,5 @@ typedef struct {
|
||||
} __attribute__((packed, aligned(16))) AgbHeader;
|
||||
|
||||
|
||||
|
||||
u32 ValidateAgbSaveHeader(AgbSaveHeader* header);
|
||||
u32 ValidateAgbHeader(AgbHeader* agb);
|
||||
|
||||
const char* AgbDestStr(const char* code);
|
||||
|
||||
@ -5,7 +5,6 @@
|
||||
#include "ips.h"
|
||||
#include "common.h"
|
||||
#include "fsperm.h"
|
||||
#include "language.h"
|
||||
#include "ui.h"
|
||||
#include "vff.h"
|
||||
|
||||
@ -31,21 +30,21 @@ char errName[256];
|
||||
int displayError(int errcode) {
|
||||
switch(errcode) {
|
||||
case IPS_NOTTHIS:
|
||||
ShowPrompt(false, "%s\n%s", errName, STR_PATCH_MOST_LIKELY_NOT_FOR_THIS_FILE); break;
|
||||
ShowPrompt(false, "%s\nThe patch is most likely not intended for this file.", errName); break;
|
||||
case IPS_THISOUT:
|
||||
ShowPrompt(false, "%s\n%s", errName, STR_YOU_MOST_LIKELY_APPLIED_PATCH_ON_OUTPUT); break;
|
||||
ShowPrompt(false, "%s\nYou most likely applied the patch on the output file.", errName); break;
|
||||
case IPS_SCRAMBLED:
|
||||
ShowPrompt(false, "%s\n%s", errName, STR_PATCH_TECHNICALLY_VALID_BUT_SEEMS_SCRAMBLED); break;
|
||||
ShowPrompt(false, "%s\nThe patch is technically valid,\nbut seems scrambled or malformed.", errName); break;
|
||||
case IPS_INVALID:
|
||||
ShowPrompt(false, "%s\n%s", errName, STR_PATCH_IS_INVALID); break;
|
||||
ShowPrompt(false, "%s\nThe patch is invalid.", errName); break;
|
||||
case IPS_16MB:
|
||||
ShowPrompt(false, "%s\n%s", errName, STR_FILES_BIGGER_THAN_16MB_IPS_DOESNT_SUPPORT_THAT); break;
|
||||
ShowPrompt(false, "%s\nOne or both files is bigger than 16MB.\nThe IPS format doesn't support that.", errName); break;
|
||||
case IPS_INVALID_FILE_PATH:
|
||||
ShowPrompt(false, "%s\n%s", errName, STR_REQUESTED_FILE_PATH_WAS_INVALID); break;
|
||||
ShowPrompt(false, "%s\nThe requested file path was invalid.", errName); break;
|
||||
case IPS_CANCELED:
|
||||
ShowPrompt(false, "%s\n%s", errName, STR_PATCHING_CANCELED); break;
|
||||
ShowPrompt(false, "%s\nPatching canceled.", errName); break;
|
||||
case IPS_MEMORY:
|
||||
ShowPrompt(false, "%s\n%s", errName, STR_NOT_ENOUGH_MEMORY); break;
|
||||
ShowPrompt(false, "%s\nNot enough memory.", errName); break;
|
||||
}
|
||||
fvx_close(&patchFile);
|
||||
fvx_close(&inFile);
|
||||
@ -113,7 +112,7 @@ UINT read24() {
|
||||
int ApplyIPSPatch(const char* patchName, const char* inName, const char* outName) {
|
||||
int error = IPS_INVALID;
|
||||
UINT outlen_min, outlen_max, outlen_min_mem;
|
||||
snprintf(errName, sizeof(errName), "%s", patchName);
|
||||
snprintf(errName, 256, "%s", patchName);
|
||||
|
||||
if (fvx_open(&patchFile, patchName, FA_READ) != FR_OK) return displayError(IPS_INVALID_FILE_PATH);
|
||||
patchSize = fvx_size(&patchFile);
|
||||
@ -141,7 +140,7 @@ int ApplyIPSPatch(const char* patchName, const char* inName, const char* outName
|
||||
while (offset != 0x454F46) // 454F46=EOF
|
||||
{
|
||||
if (!ShowProgress(patchOffset, patchSize, patchName)) {
|
||||
if (ShowPrompt(true, "%s\n%s", patchName, STR_B_DETECTED_CANCEL)) return displayError(IPS_CANCELED);
|
||||
if (ShowPrompt(true, "%s\nB button detected. Cancel?", patchName)) return displayError(IPS_CANCELED);
|
||||
ShowProgress(0, patchSize, patchName);
|
||||
ShowProgress(patchOffset, patchSize, patchName);
|
||||
}
|
||||
@ -212,7 +211,7 @@ int ApplyIPSPatch(const char* patchName, const char* inName, const char* outName
|
||||
while (offset != 0x454F46)
|
||||
{
|
||||
if (!ShowProgress(offset, outSize, outName)) {
|
||||
if (ShowPrompt(true, "%s\n%s", outName, STR_B_DETECTED_CANCEL)) return displayError(IPS_CANCELED);
|
||||
if (ShowPrompt(true, "%s\nB button detected. Cancel?", outName)) return displayError(IPS_CANCELED);
|
||||
ShowProgress(0, outSize, outName);
|
||||
ShowProgress(offset, outSize, outName);
|
||||
}
|
||||
|
||||
@ -55,24 +55,20 @@ u32 BuildTwlSaveHeader(void* sav, u32 size) {
|
||||
u16 n_sct = 1;
|
||||
u16 sct_track = 1;
|
||||
u16 sct_heads = 1;
|
||||
u16 n_sct_next = 0;
|
||||
while (n_sct_next <= n_sct_max) {
|
||||
n_sct_next = sct_track * (sct_heads + 1) * (sct_heads + 1);
|
||||
if (n_sct_next <= n_sct_max) {
|
||||
while (true) {
|
||||
if (sct_heads < sct_track) {
|
||||
u16 n_sct_next = sct_track * (sct_heads+1) * (sct_heads+1);
|
||||
if (n_sct_next < n_sct_max) {
|
||||
sct_heads++;
|
||||
n_sct = n_sct_next;
|
||||
|
||||
sct_track++;
|
||||
n_sct_next = sct_track * sct_heads * sct_heads;
|
||||
if (n_sct_next <= n_sct_max) {
|
||||
n_sct = n_sct_next;
|
||||
}
|
||||
}
|
||||
}
|
||||
n_sct_next = (sct_track + 1) * sct_heads * sct_heads;
|
||||
if (n_sct_next <= n_sct_max) {
|
||||
} else break;
|
||||
} else {
|
||||
u16 n_sct_next = (sct_track+1) * sct_heads * sct_heads;
|
||||
if (n_sct_next < n_sct_max) {
|
||||
sct_track++;
|
||||
n_sct = n_sct_next;
|
||||
} else break;
|
||||
}
|
||||
}
|
||||
|
||||
// sectors per cluster (should be identical to Nintendo)
|
||||
@ -147,19 +143,11 @@ u32 GetTwlIcon(u16* icon, const TwlIconData* twl_icon) {
|
||||
u32 ix = x + (i & 0x7);
|
||||
u32 iy = y + (i >> 3);
|
||||
|
||||
int palette_index = ((i%2) ? (*pix4 >> 4) : *pix4) & 0xF;
|
||||
if (palette_index) {
|
||||
pix555 = palette[palette_index];
|
||||
pix555 = palette[((i%2) ? (*pix4 >> 4) : *pix4) & 0xF];
|
||||
r = pix555 & 0x1F;
|
||||
g = ((pix555 >> 5) & 0x1F) << 1;
|
||||
g |= (g >> 1) & 1;
|
||||
b = (pix555 >> 10) & 0x1F;
|
||||
} else {
|
||||
// Set transparent pixels to white
|
||||
r = 31;
|
||||
g = 63;
|
||||
b = 31;
|
||||
}
|
||||
icon[(iy * w) + ix] = (r << 11) | (g << 5) | b;
|
||||
if (i % 2) pix4++;
|
||||
}
|
||||
|
||||
@ -1,5 +1,4 @@
|
||||
#include "common.h"
|
||||
#include "language.h"
|
||||
#include "region.h"
|
||||
|
||||
// Names of system regions, short form.
|
||||
@ -13,16 +12,13 @@ const char* const g_regionNamesShort[SMDH_NUM_REGIONS] = {
|
||||
"TWN",
|
||||
};
|
||||
|
||||
// Names of system regions, long form and translatable.
|
||||
const char* regionNameLong(int region) {
|
||||
switch(region) {
|
||||
case REGION_JPN: return STR_REGION_JAPAN;
|
||||
case REGION_USA: return STR_REGION_AMERICAS;
|
||||
case REGION_EUR: return STR_REGION_EUROPE;
|
||||
case REGION_AUS: return STR_REGION_AUSTRALIA;
|
||||
case REGION_CHN: return STR_REGION_CHINA;
|
||||
case REGION_KOR: return STR_REGION_KOREA;
|
||||
case REGION_TWN: return STR_REGION_TAIWAN;
|
||||
default: return STR_REGION_UNKNOWN;
|
||||
}
|
||||
// Names of system regions, long form.
|
||||
const char* const g_regionNamesLong[SMDH_NUM_REGIONS] = {
|
||||
"Japan",
|
||||
"Americas",
|
||||
"Europe",
|
||||
"Australia",
|
||||
"China",
|
||||
"Korea",
|
||||
"Taiwan",
|
||||
};
|
||||
|
||||
@ -27,5 +27,5 @@
|
||||
|
||||
// Names of system regions, short form.
|
||||
extern const char* const g_regionNamesShort[SMDH_NUM_REGIONS];
|
||||
// Names of system regions, long form and translatable.
|
||||
const char* regionNameLong(int region);
|
||||
// Names of system regions, long form.
|
||||
extern const char* const g_regionNamesLong[SMDH_NUM_REGIONS];
|
||||
|
||||
@ -41,91 +41,28 @@ u32 ValidateTicketSignature(Ticket* ticket) {
|
||||
return ret;
|
||||
}
|
||||
|
||||
u32 BuildVariableFakeTicket(Ticket** ticket, u32* ticket_size, const u8* title_id, u32 index_max) {
|
||||
if (!ticket || !ticket_size)
|
||||
return 1;
|
||||
|
||||
u32 BuildFakeTicket(Ticket* ticket, u8* title_id) {
|
||||
static const u8 sig_type[4] = { TICKET_SIG_TYPE }; // RSA_2048 SHA256
|
||||
|
||||
// calculate sizes and determine pointers to use
|
||||
u32 rights_field_count = (min(index_max, 0x10000) + 1023) >> 10; // round up to 1024 and cap at 65536, and div by 1024
|
||||
u32 content_index_size = sizeof(TicketContentIndexMainHeader) + sizeof(TicketContentIndexDataHeader) + sizeof(TicketRightsField) * rights_field_count;
|
||||
u32 _ticket_size = sizeof(Ticket) + content_index_size;
|
||||
Ticket *_ticket;
|
||||
|
||||
if (*ticket) { // if a pointer was pregiven
|
||||
if (*ticket_size < _ticket_size) { // then check given boundary size
|
||||
*ticket_size = _ticket_size; // if not enough, inform the actual needed size
|
||||
return 2; // indicate a size error
|
||||
}
|
||||
_ticket = *ticket; // get the pointer if we good to go
|
||||
} else // if not pregiven, allocate one
|
||||
_ticket = (Ticket*)malloc(_ticket_size);
|
||||
|
||||
if (!_ticket)
|
||||
return 1;
|
||||
|
||||
static const u8 ticket_cnt_index[] = { // whatever this is
|
||||
0x00, 0x01, 0x00, 0x14, 0x00, 0x00, 0x00, 0xAC, 0x00, 0x00, 0x00, 0x14, 0x00, 0x01, 0x00, 0x14,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x84,
|
||||
0x00, 0x00, 0x00, 0x84, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
|
||||
};
|
||||
// set ticket all zero for a clean start
|
||||
memset(_ticket, 0x00, _ticket_size);
|
||||
memset(ticket, 0x00, TICKET_COMMON_SIZE); // 0xAC being size of this fake ticket's content index
|
||||
// fill ticket values
|
||||
memcpy(_ticket->sig_type, sig_type, 4);
|
||||
memset(_ticket->signature, 0xFF, 0x100);
|
||||
snprintf((char*) _ticket->issuer, 0x40, IS_DEVKIT ? TICKET_ISSUER_DEV : TICKET_ISSUER);
|
||||
memset(_ticket->ecdsa, 0xFF, 0x3C);
|
||||
_ticket->version = 0x01;
|
||||
memset(_ticket->titlekey, 0xFF, 16);
|
||||
if (title_id) memcpy(_ticket->title_id, title_id, 8);
|
||||
_ticket->commonkey_idx = 0x00; // eshop
|
||||
_ticket->audit = 0x01; // whatever
|
||||
memcpy(ticket->sig_type, sig_type, 4);
|
||||
memset(ticket->signature, 0xFF, 0x100);
|
||||
snprintf((char*) ticket->issuer, 0x40, IS_DEVKIT ? TICKET_ISSUER_DEV : TICKET_ISSUER);
|
||||
memset(ticket->ecdsa, 0xFF, 0x3C);
|
||||
ticket->version = 0x01;
|
||||
memset(ticket->titlekey, 0xFF, 16);
|
||||
memcpy(ticket->title_id, title_id, 8);
|
||||
ticket->commonkey_idx = 0x00; // eshop
|
||||
ticket->audit = 0x01; // whatever
|
||||
memcpy(ticket->content_index, ticket_cnt_index, sizeof(ticket_cnt_index));
|
||||
memset(&ticket->content_index[sizeof(ticket_cnt_index)], 0xFF, 0x80); // 1024 content indexes
|
||||
|
||||
// fill in rights
|
||||
TicketContentIndexMainHeader* mheader = (TicketContentIndexMainHeader*)&_ticket->content_index[0];
|
||||
TicketContentIndexDataHeader* dheader = (TicketContentIndexDataHeader*)&_ticket->content_index[0x14];
|
||||
TicketRightsField* rights = (TicketRightsField*)&_ticket->content_index[0x28];
|
||||
|
||||
// first main data header
|
||||
mheader->unk1[1] = 0x1; mheader->unk2[1] = 0x14;
|
||||
mheader->content_index_size[3] = (u8)(content_index_size >> 0);
|
||||
mheader->content_index_size[2] = (u8)(content_index_size >> 8);
|
||||
mheader->content_index_size[1] = (u8)(content_index_size >> 16);
|
||||
mheader->content_index_size[0] = (u8)(content_index_size >> 24);
|
||||
mheader->data_header_relative_offset[3] = 0x14; // relative offset for TicketContentIndexDataHeader
|
||||
mheader->unk3[1] = 0x1; mheader->unk4[1] = 0x14;
|
||||
|
||||
// then the data header
|
||||
dheader->data_relative_offset[3] = 0x28; // relative offset for TicketRightsField
|
||||
dheader->max_entry_count[3] = (u8)(rights_field_count >> 0);
|
||||
dheader->max_entry_count[2] = (u8)(rights_field_count >> 8);
|
||||
dheader->max_entry_count[1] = (u8)(rights_field_count >> 16);
|
||||
dheader->max_entry_count[0] = (u8)(rights_field_count >> 24);
|
||||
dheader->size_per_entry[3] = (u8)sizeof(TicketRightsField); // sizeof should be 0x84
|
||||
dheader->total_size_used[3] = (u8)((sizeof(TicketRightsField) * rights_field_count) >> 0);
|
||||
dheader->total_size_used[2] = (u8)((sizeof(TicketRightsField) * rights_field_count) >> 8);
|
||||
dheader->total_size_used[1] = (u8)((sizeof(TicketRightsField) * rights_field_count) >> 16);
|
||||
dheader->total_size_used[0] = (u8)((sizeof(TicketRightsField) * rights_field_count) >> 24);
|
||||
dheader->data_type[1] = 3; // right fields
|
||||
|
||||
// now the right fields
|
||||
// indexoffets must be in accending order to have the desired effect
|
||||
for (u32 i = 0; i < rights_field_count; ++i) {
|
||||
rights[i].indexoffset[1] = (u8)((1024 * i) >> 0);
|
||||
rights[i].indexoffset[0] = (u8)((1024 * i) >> 8);
|
||||
memset(&rights[i].rightsbitfield[0], 0xFF, sizeof(rights[0].rightsbitfield));
|
||||
}
|
||||
|
||||
*ticket = _ticket;
|
||||
*ticket_size = _ticket_size;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
u32 BuildFakeTicket(Ticket* ticket, const u8* title_id) {
|
||||
Ticket* tik = NULL;
|
||||
u32 ticket_size = sizeof(TicketCommon);
|
||||
u32 res = BuildVariableFakeTicket(&tik, &ticket_size, title_id, TICKET_MAX_CONTENTS);
|
||||
if (res != 0) return res;
|
||||
memcpy(ticket, tik, ticket_size);
|
||||
free(tik);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
@ -1,14 +1,11 @@
|
||||
#pragma once
|
||||
|
||||
#include "common.h"
|
||||
#include "tmd.h"
|
||||
|
||||
#define TICKET_COMMON_SIZE sizeof(TicketCommon)
|
||||
#define TICKET_MINIMUM_SIZE sizeof(TicketMinimum)
|
||||
#define TICKET_TWL_SIZE sizeof(Ticket)
|
||||
#define TICKET_CDNCERT_SIZE 0x700
|
||||
#define TICKET_MAX_CONTENTS TITLE_MAX_CONTENTS // should be TMD_MAX_CONTENTS
|
||||
#define TICKET_COMMON_CNT_INDEX_SIZE (0x28 + (((TICKET_MAX_CONTENTS + 1023) >> 10) * 0x84))
|
||||
|
||||
#define TICKET_ISSUER "Root-CA00000003-XS0000000c"
|
||||
#define TICKET_ISSUER_DEV "Root-CA00000004-XS00000009"
|
||||
@ -57,7 +54,7 @@ typedef struct {
|
||||
|
||||
typedef struct {
|
||||
TICKETBASE;
|
||||
u8 content_index[TICKET_COMMON_CNT_INDEX_SIZE];
|
||||
u8 content_index[0xAC];
|
||||
} PACKED_STRUCT TicketCommon;
|
||||
|
||||
// minimum allowed content_index is 0x14
|
||||
@ -100,7 +97,7 @@ typedef struct {
|
||||
u32 ValidateTicket(Ticket* ticket);
|
||||
u32 ValidateTwlTicket(Ticket* ticket);
|
||||
u32 ValidateTicketSignature(Ticket* ticket);
|
||||
u32 BuildFakeTicket(Ticket* ticket, const u8* title_id);
|
||||
u32 BuildFakeTicket(Ticket* ticket, u8* title_id);
|
||||
u32 GetTicketContentIndexSize(const Ticket* ticket);
|
||||
u32 GetTicketSize(const Ticket* ticket);
|
||||
u32 BuildTicketCert(u8* tickcert);
|
||||
|
||||
@ -105,11 +105,11 @@ u32 FindTicket(Ticket** ticket, u8* title_id, bool force_legit, bool emunand) {
|
||||
|
||||
u32 FindTitleKey(Ticket* ticket, u8* title_id) {
|
||||
bool found = false;
|
||||
TitleKeysInfo* tikdb = (TitleKeysInfo*) malloc(STD_BUFFER_SIZE); // more than enough
|
||||
if (!tikdb) return 1;
|
||||
|
||||
// search for a titlekey inside encTitleKeys.bin / decTitleKeys.bin
|
||||
// when found, add it to the ticket
|
||||
TitleKeysInfo* tikdb = (TitleKeysInfo*) malloc(STD_BUFFER_SIZE); // more than enough
|
||||
if (!tikdb) return 1;
|
||||
for (u32 enc = 0; (enc <= 1) && !found; enc++) {
|
||||
u32 len = LoadSupportFile((enc) ? TIKDB_NAME_ENC : TIKDB_NAME_DEC, tikdb, STD_BUFFER_SIZE);
|
||||
|
||||
@ -128,17 +128,8 @@ u32 FindTitleKey(Ticket* ticket, u8* title_id) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
free(tikdb);
|
||||
|
||||
// desperate measures - search in the internal ticket database
|
||||
Ticket* ticket_tmp = NULL;
|
||||
if (FindTicket(&ticket_tmp, title_id, false, false) == 0) {
|
||||
memcpy(ticket->titlekey, ticket_tmp->titlekey, 16);
|
||||
ticket->commonkey_idx = ticket_tmp->commonkey_idx;
|
||||
free(ticket_tmp);
|
||||
found = true;
|
||||
}
|
||||
|
||||
return (found) ? 0 : 1;
|
||||
}
|
||||
|
||||
|
||||
@ -2,7 +2,7 @@
|
||||
|
||||
#include "common.h"
|
||||
|
||||
#define TMD_MAX_CONTENTS TITLE_MAX_CONTENTS // 1024 // 383 // theme CIAs contain maximum 100 themes + 1 index content
|
||||
#define TMD_MAX_CONTENTS 1000 // 383 // theme CIAs contain maximum 100 themes + 1 index content
|
||||
|
||||
#define TMD_SIZE_MIN sizeof(TitleMetaData)
|
||||
#define TMD_SIZE_MAX (sizeof(TitleMetaData) + (TMD_MAX_CONTENTS*sizeof(TmdContentChunk)))
|
||||
|
||||
@ -88,9 +88,6 @@ const CardSPITypeData flashTypes[] = {
|
||||
|
||||
// This is the most common type of flash 3DS cartridges. Not normally found in DS ones, but check anyway. (Custom MXIC chips)
|
||||
{ CardSPIEnableWriting_regular, CardSPIReadSaveData_24bit, CardSPIWriteSaveData_24bit_erase_program, CardSPIEraseSector_real, 0xC222, 0, 4096, 32, 4096, SPI_FLASH_CMD_PW, SPI_CMD_PP, SPI_FLASH_CMD_MXIC_SE },
|
||||
|
||||
// Found this in some copies of ArtAcademy, I think it's something from MXIC (Thank you for the help @FerozElMejor on Discord)
|
||||
{ CardSPIEnableWriting_regular, CardSPIReadSaveData_24bit, CardSPIWriteSaveData_24bit_erase_program, CardSPIEraseSector_real, 0xC220, 0, 4096, 32, 4096, SPI_FLASH_CMD_PW, SPI_CMD_PP, SPI_FLASH_CMD_MXIC_SE },
|
||||
};
|
||||
|
||||
const CardSPITypeData * const FLASH_CTR_GENERIC = flashTypes + 5;
|
||||
@ -170,7 +167,7 @@ int _SPIWriteTransaction(CardSPIType type, void* cmd, u32 cmdSize, const void* d
|
||||
int res;
|
||||
if ((res = CardSPIEnableWriting(type))) return res;
|
||||
if ((res = CardSPIWriteRead(type.infrared, cmd, cmdSize, NULL, 0, (void*) ((u8*) data), dataSize))) return res;
|
||||
return CardSPIWaitWriteEnd(type.infrared, 10000);
|
||||
return CardSPIWaitWriteEnd(type.infrared, 1000);
|
||||
}
|
||||
|
||||
int CardSPIReadJEDECIDAndStatusReg(bool infrared, u32* id, u8* statusReg) {
|
||||
|
||||
@ -27,7 +27,7 @@ void CTR_CmdReadData(u32 sector, u32 length, u32 blocks, void* buffer)
|
||||
(u32)((sector << 9) & 0xFFFFFFFF),
|
||||
0x00000000, 0x00000000
|
||||
};
|
||||
CTR_SendCommand(read_cmd, length, blocks, 0x104822C, buffer); // Clock divider 5 (13.4 MHz). Same as Process9.
|
||||
CTR_SendCommand(read_cmd, length, blocks, 0x704822C, buffer);
|
||||
}
|
||||
|
||||
void CTR_CmdReadHeader(void* buffer)
|
||||
|
||||
@ -64,11 +64,6 @@ u32 GetCartName(char* name, CartData* cdata) {
|
||||
|
||||
u32 GetCartInfoString(char* info, size_t info_size, CartData* cdata) {
|
||||
size_t info_index = 0;
|
||||
u8 padding;
|
||||
|
||||
// read the last byte of the cart storage, but ignore the result
|
||||
ReadCartBytes(&padding, cdata->cart_size - 1, 1, cdata, false);
|
||||
|
||||
if (cdata->cart_type & CART_CTR) {
|
||||
CartDataCtr* cdata_i = (CartDataCtr*)cdata;
|
||||
NcsdHeader* ncsd = &(cdata_i->ncsd);
|
||||
@ -105,17 +100,14 @@ u32 GetCartInfoString(char* info, size_t info_size, CartData* cdata) {
|
||||
u32 jedecid = 0;
|
||||
if (CardSPIReadJEDECIDAndStatusReg(cdata->spi_save_type.infrared, &jedecid, NULL) == 0) {
|
||||
info_index += snprintf(info + info_index, info_size - info_index,
|
||||
"Save chip ID : %06lX\n",
|
||||
"Save chip ID : 0x%06lX\n",
|
||||
jedecid);
|
||||
}
|
||||
} else info_index += snprintf(info + info_index, info_size - info_index,
|
||||
"Save chip ID : <none>\n");
|
||||
}
|
||||
|
||||
info_index += snprintf(info + info_index, info_size - info_index,
|
||||
"Padding Byte : %02X\n"
|
||||
"Timestamp : 20%02X-%02X-%02X %02X:%02X:%02X\n"
|
||||
"GM9 Version : %s\n",
|
||||
padding,
|
||||
init_time.bcd_Y, init_time.bcd_M, init_time.bcd_D,
|
||||
init_time.bcd_h, init_time.bcd_m, init_time.bcd_s,
|
||||
VERSION);
|
||||
@ -273,15 +265,6 @@ u32 InitCartRead(CartData* cdata) {
|
||||
NTR_CmdReadHeader(cdata->storage);
|
||||
if (!NTR_Secure_Init(cdata->storage, NULL, Cart_GetID(), 1)) return 1;
|
||||
}
|
||||
} else {
|
||||
// Check if immediately after the reported cart size
|
||||
// is the magic number string 'ac' (auth code).
|
||||
// If found, add 0x88 bytes for the download play RSA key.
|
||||
u16 rsaMagic;
|
||||
ReadCartBytes(&rsaMagic, cdata->data_size, 2, cdata, false);
|
||||
if(rsaMagic == 0x6361) {
|
||||
cdata->data_size += 0x88;
|
||||
}
|
||||
}
|
||||
|
||||
// store encrypted secure area
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@ -1,188 +0,0 @@
|
||||
#include "language.h"
|
||||
#include "fsdrive.h"
|
||||
#include "fsutil.h"
|
||||
#include "support.h"
|
||||
#include "ui.h"
|
||||
|
||||
#define STRING(what, def) const char* STR_##what = NULL;
|
||||
#include "language.inl"
|
||||
#undef STRING
|
||||
|
||||
static const char** translation_ptrs[] = {
|
||||
#define STRING(what, def) &STR_##what,
|
||||
#include "language.inl"
|
||||
#undef STRING
|
||||
};
|
||||
|
||||
static const char* translation_fallbacks[] = {
|
||||
#define STRING(what, def) def,
|
||||
#include "language.inl"
|
||||
#undef STRING
|
||||
};
|
||||
|
||||
static char* translation_data = NULL;
|
||||
|
||||
typedef struct {
|
||||
char name[32];
|
||||
char path[256];
|
||||
} Language;
|
||||
|
||||
typedef struct {
|
||||
char chunk_id[4]; // NOT null terminated
|
||||
u32 size;
|
||||
} RiffChunkHeader;
|
||||
|
||||
typedef struct {
|
||||
u32 version;
|
||||
u32 count;
|
||||
char languageName[32];
|
||||
} LanguageMeta;
|
||||
STATIC_ASSERT(sizeof(LanguageMeta) == 40);
|
||||
|
||||
bool SetLanguage(const void* translation, u32 translation_size) {
|
||||
u32 str_count;
|
||||
const void* ptr = translation;
|
||||
const RiffChunkHeader* riff_header;
|
||||
const RiffChunkHeader* chunk_header;
|
||||
|
||||
// Free old translation data
|
||||
if (translation_data) {
|
||||
free(translation_data);
|
||||
translation_data = NULL;
|
||||
}
|
||||
|
||||
if ((ptr = GetLanguage(translation, translation_size, NULL, &str_count, NULL))) {
|
||||
// load total size
|
||||
riff_header = translation;
|
||||
|
||||
while ((u32)(ptr - translation) < riff_header->size + sizeof(RiffChunkHeader)) {
|
||||
chunk_header = ptr;
|
||||
|
||||
if (memcmp(chunk_header->chunk_id, "SDAT", 4) == 0) { // string data
|
||||
if (chunk_header->size > 0) {
|
||||
translation_data = malloc(chunk_header->size);
|
||||
if (!translation_data) goto fallback;
|
||||
|
||||
memcpy(translation_data, ptr + sizeof(RiffChunkHeader), chunk_header->size);
|
||||
}
|
||||
} else if (memcmp(chunk_header->chunk_id, "SMAP", 4) == 0) { // string map
|
||||
// string data must come before the map
|
||||
if (!translation_data && str_count > 0) goto fallback;
|
||||
|
||||
u16* string_map = (u16*)(ptr + sizeof(RiffChunkHeader));
|
||||
|
||||
// Load all the strings
|
||||
for (u32 i = 0; i < countof(translation_ptrs); i++) {
|
||||
if (i < str_count) {
|
||||
*translation_ptrs[i] = (translation_data + string_map[i]);
|
||||
} else {
|
||||
*translation_ptrs[i] = translation_fallbacks[i];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
ptr += sizeof(RiffChunkHeader) + chunk_header->size;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
fallback:
|
||||
if (translation_data) {
|
||||
free(translation_data);
|
||||
translation_data = NULL;
|
||||
}
|
||||
|
||||
for (u32 i = 0; i < countof(translation_ptrs); i++) {
|
||||
*translation_ptrs[i] = translation_fallbacks[i];
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
const void* GetLanguage(const void* riff, const u32 riff_size, u32* version, u32* count, char* language_name) {
|
||||
const void* ptr = riff;
|
||||
const RiffChunkHeader* riff_header;
|
||||
const RiffChunkHeader* chunk_header;
|
||||
|
||||
// check header magic and load size
|
||||
if (!ptr) return NULL;
|
||||
riff_header = ptr;
|
||||
if (memcmp(riff_header->chunk_id, "RIFF", 4) != 0) return NULL;
|
||||
|
||||
// ensure enough space is allocated
|
||||
if (riff_header->size > riff_size) return NULL;
|
||||
|
||||
ptr += sizeof(RiffChunkHeader);
|
||||
|
||||
while ((u32)(ptr - riff) < riff_header->size + sizeof(RiffChunkHeader)) {
|
||||
chunk_header = ptr;
|
||||
|
||||
// check for and load META section
|
||||
if (memcmp(chunk_header->chunk_id, "META", 4) == 0) {
|
||||
if (chunk_header->size != sizeof(LanguageMeta)) return NULL;
|
||||
|
||||
const LanguageMeta *meta = ptr + sizeof(RiffChunkHeader);
|
||||
if (meta->version != TRANSLATION_VER || meta->count > countof(translation_ptrs)) return NULL;
|
||||
|
||||
// all good
|
||||
if (version) *version = meta->version;
|
||||
if (count) *count = meta->count;
|
||||
if (language_name) strcpy(language_name, meta->languageName);
|
||||
return ptr;
|
||||
}
|
||||
|
||||
ptr += sizeof(RiffChunkHeader) + chunk_header->size;
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
int compLanguage(const void* e1, const void* e2) {
|
||||
const Language* entry2 = (const Language*) e2;
|
||||
const Language* entry1 = (const Language*) e1;
|
||||
return strncasecmp(entry1->name, entry2->name, 32);
|
||||
}
|
||||
|
||||
bool LanguageMenu(char* result, const char* title) {
|
||||
DirStruct* langDir = (DirStruct*)malloc(sizeof(DirStruct));
|
||||
if (!langDir) return false;
|
||||
|
||||
char path[256];
|
||||
if (!GetSupportDir(path, LANGUAGES_DIR)) return false;
|
||||
GetDirContents(langDir, path);
|
||||
|
||||
char* header = (char*)malloc(0x2C0);
|
||||
Language* langs = (Language*)malloc(langDir->n_entries * sizeof(Language));
|
||||
int langCount = 0;
|
||||
|
||||
// Find all valid files and get their language names
|
||||
for (u32 i = 0; i < langDir->n_entries; i++) {
|
||||
if (langDir->entry[i].type == T_FILE) {
|
||||
size_t fsize = FileGetSize(langDir->entry[i].path);
|
||||
FileGetData(langDir->entry[i].path, header, 0x2C0, 0);
|
||||
if (GetLanguage(header, fsize, NULL, NULL, langs[langCount].name)) {
|
||||
memcpy(langs[langCount].path, langDir->entry[i].path, 256);
|
||||
langCount++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
free(langDir);
|
||||
free(header);
|
||||
|
||||
qsort(langs, langCount, sizeof(Language), compLanguage);
|
||||
|
||||
// Make an array of just the names for the select promt
|
||||
const char* langNames[langCount];
|
||||
for (int i = 0; i < langCount; i++) {
|
||||
langNames[i] = langs[i].name;
|
||||
}
|
||||
|
||||
u32 selected = ShowSelectPrompt(langCount, langNames, "%s", title);
|
||||
if (selected > 0 && result) {
|
||||
memcpy(result, langs[selected - 1].path, 256);
|
||||
}
|
||||
|
||||
return selected > 0;
|
||||
}
|
||||
@ -1,12 +0,0 @@
|
||||
#pragma once
|
||||
|
||||
#include "common.h"
|
||||
|
||||
#define STRING(what, def) extern const char* STR_##what;
|
||||
#include "language.inl"
|
||||
#undef STRING
|
||||
|
||||
bool SetLanguage(const void* translation, u32 translation_size);
|
||||
const void* GetLanguage(const void* riff, u32 riff_size, u32* version, u32* count, char* language_name);
|
||||
|
||||
bool LanguageMenu(char* result, const char* title);
|
||||
@ -1,14 +0,0 @@
|
||||
This is Lua 5.4.7 with a few modifications:
|
||||
* Patches made to silence warnings: https://github.com/ihaveamac/GodMode9/commit/9905b939b26aae3422c906c7858d8852764fa279
|
||||
* lua.c, luac.c, lua.hpp removed (not useful in GodMode9)
|
||||
* liolib.c, loslib.c removed (replaced with custom implementations)
|
||||
|
||||
## License of Lua 5.4.7
|
||||
|
||||
Copyright © 1994–2024 Lua.org, PUC-Rio.
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
@ -1,800 +0,0 @@
|
||||
#ifndef NO_LUA
|
||||
#include "gm9internalfs.h"
|
||||
#include "fs.h"
|
||||
#include "ui.h"
|
||||
#include "utils.h"
|
||||
#include "sha.h"
|
||||
#include "nand.h"
|
||||
#include "language.h"
|
||||
#include "hid.h"
|
||||
#include "game.h"
|
||||
#include "gamecart.h"
|
||||
|
||||
#define _MAX_FOR_DEPTH 16
|
||||
|
||||
static u8 no_data_hash_256[32] = { SHA256_EMPTY_HASH };
|
||||
static u8 no_data_hash_1[32] = { SHA1_EMPTY_HASH };
|
||||
|
||||
static bool PathIsDirectory(const char* path) {
|
||||
FRESULT res;
|
||||
FILINFO fno;
|
||||
res = fvx_stat(path, &fno);
|
||||
if (res != FR_OK) return false;
|
||||
return fno.fattrib & AM_DIR;
|
||||
}
|
||||
|
||||
static void CreateStatTable(lua_State* L, FILINFO* fno) {
|
||||
lua_createtable(L, 0, 4); // create nested table
|
||||
lua_pushstring(L, fno->fname);
|
||||
lua_setfield(L, -2, "name");
|
||||
lua_pushstring(L, (fno->fattrib & AM_DIR) ? "dir" : "file");
|
||||
lua_setfield(L, -2, "type");
|
||||
lua_pushinteger(L, fno->fsize);
|
||||
lua_setfield(L, -2, "size");
|
||||
lua_pushboolean(L, fno->fattrib & AM_RDO);
|
||||
lua_setfield(L, -2, "read_only");
|
||||
// ... and leave this table on the stack for the caller to deal with
|
||||
}
|
||||
|
||||
static int internalfs_move(lua_State* L) {
|
||||
bool extra = CheckLuaArgCountPlusExtra(L, 2, "_fs.move");
|
||||
const char* path_src = luaL_checkstring(L, 1);
|
||||
const char* path_dst = luaL_checkstring(L, 2);
|
||||
FILINFO fno;
|
||||
|
||||
CheckWritePermissionsLuaError(L, path_src);
|
||||
CheckWritePermissionsLuaError(L, path_dst);
|
||||
|
||||
u32 flags = BUILD_PATH;
|
||||
if (extra) {
|
||||
flags = GetFlagsFromTable(L, 3, flags, NO_CANCEL | SILENT | OVERWRITE_ALL | SKIP_ALL);
|
||||
}
|
||||
|
||||
if (!(flags & OVERWRITE_ALL) && (fvx_stat(path_dst, &fno) == FR_OK)) {
|
||||
return luaL_error(L, "destination already exists on %s -> %s and {overwrite=true} was not used", path_src, path_dst);
|
||||
}
|
||||
|
||||
if (!(PathMoveCopy(path_dst, path_src, &flags, true))) {
|
||||
return luaL_error(L, "PathMoveCopy failed on %s -> %s", path_src, path_dst);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int internalfs_remove(lua_State* L) {
|
||||
bool extra = CheckLuaArgCountPlusExtra(L, 1, "_fs.remove");
|
||||
const char* path = luaL_checkstring(L, 1);
|
||||
|
||||
CheckWritePermissionsLuaError(L, path);
|
||||
|
||||
u32 flags = 0;
|
||||
if (extra) {
|
||||
flags = GetFlagsFromTable(L, 2, flags, RECURSIVE);
|
||||
}
|
||||
|
||||
if (!(flags & RECURSIVE)) {
|
||||
if (PathIsDirectory(path)) {
|
||||
return luaL_error(L, "requested directory remove without {recursive=true} on %s", path);
|
||||
}
|
||||
}
|
||||
|
||||
if (!(PathDelete(path))) {
|
||||
return luaL_error(L, "PathDelete failed on %s", path);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int internalfs_copy(lua_State* L) {
|
||||
bool extra = CheckLuaArgCountPlusExtra(L, 2, "_fs.copy");
|
||||
const char* path_src = luaL_checkstring(L, 1);
|
||||
const char* path_dst = luaL_checkstring(L, 2);
|
||||
FILINFO fno;
|
||||
|
||||
CheckWritePermissionsLuaError(L, path_dst);
|
||||
|
||||
u32 flags = BUILD_PATH;
|
||||
if (extra) {
|
||||
flags = GetFlagsFromTable(L, 3, flags, CALC_SHA | USE_SHA1 | NO_CANCEL | SILENT | OVERWRITE_ALL | SKIP_ALL | APPEND_ALL | RECURSIVE);
|
||||
}
|
||||
|
||||
if (!(flags & RECURSIVE)) {
|
||||
if (PathIsDirectory(path_src)) {
|
||||
return luaL_error(L, "requested directory copy without {recursive=true} on %s -> %s", path_src, path_dst);
|
||||
}
|
||||
}
|
||||
|
||||
if (!(flags & OVERWRITE_ALL) && (fvx_stat(path_dst, &fno) == FR_OK)) {
|
||||
return luaL_error(L, "destination already exists on %s -> %s and {overwrite=true} was not used", path_src, path_dst);
|
||||
}
|
||||
|
||||
if (!(PathMoveCopy(path_dst, path_src, &flags, false))) {
|
||||
return luaL_error(L, "PathMoveCopy failed on %s -> %s", path_src, path_dst);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int internalfs_mkdir(lua_State* L) {
|
||||
CheckLuaArgCount(L, 1, "_fs.mkdir");
|
||||
const char* path = luaL_checkstring(L, 1);
|
||||
|
||||
CheckWritePermissionsLuaError(L, path);
|
||||
|
||||
FRESULT res = fvx_rmkdir(path);
|
||||
if (res != FR_OK) {
|
||||
return luaL_error(L, "could not mkdir %s (%d)", path, res);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int internalfs_list_dir(lua_State* L) {
|
||||
CheckLuaArgCount(L, 1, "_fs.list_dir");
|
||||
const char* path = luaL_checkstring(L, 1);
|
||||
lua_newtable(L);
|
||||
|
||||
DIR dir;
|
||||
FILINFO fno;
|
||||
|
||||
FRESULT res = fvx_opendir(&dir, path);
|
||||
if (res != FR_OK) {
|
||||
lua_pop(L, 1); // remove final table from stack
|
||||
return luaL_error(L, "could not opendir %s (%d)", path, res);
|
||||
}
|
||||
|
||||
for (int i = 1; true; i++) {
|
||||
res = fvx_readdir(&dir, &fno);
|
||||
if (res != FR_OK) {
|
||||
fvx_closedir(&dir);
|
||||
lua_pop(L, 1); // remove final table from stack
|
||||
return luaL_error(L, "could not readdir %s (%d)", path, res);
|
||||
}
|
||||
if (fno.fname[0] == 0) break;
|
||||
CreateStatTable(L, &fno);
|
||||
lua_seti(L, -2, i); // add nested table to final table
|
||||
}
|
||||
fvx_closedir(&dir);
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int internalfs_stat(lua_State* L) {
|
||||
CheckLuaArgCount(L, 1, "_fs.stat");
|
||||
const char* path = luaL_checkstring(L, 1);
|
||||
FILINFO fno;
|
||||
|
||||
FRESULT res = fvx_stat(path, &fno);
|
||||
if (res != FR_OK) {
|
||||
return luaL_error(L, "could not stat %s (%d)", path, res);
|
||||
}
|
||||
CreateStatTable(L, &fno);
|
||||
return 1;
|
||||
}
|
||||
|
||||
// TODO: make this manually check for permissions recursively
|
||||
static int internalfs_fix_cmacs(lua_State* L) {
|
||||
CheckLuaArgCount(L, 1, "_fs.fix_cmacs");
|
||||
const char* path = luaL_checkstring(L, 1);
|
||||
|
||||
ShowString("%s", STR_FIXING_CMACS_PLEASE_WAIT);
|
||||
if (RecursiveFixFileCmac(path) != 0) {
|
||||
return luaL_error(L, "fixcmac failed");
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int internalfs_stat_fs(lua_State* L) {
|
||||
CheckLuaArgCount(L, 1, "_fs.stat_fs");
|
||||
const char* path = luaL_checkstring(L, 1);
|
||||
|
||||
u64 freespace = GetFreeSpace(path);
|
||||
u64 totalspace = GetTotalSpace(path);
|
||||
u64 usedspace = totalspace - freespace;
|
||||
|
||||
lua_createtable(L, 0, 3);
|
||||
lua_pushinteger(L, freespace);
|
||||
lua_setfield(L, -2, "free");
|
||||
lua_pushinteger(L, totalspace);
|
||||
lua_setfield(L, -2, "total");
|
||||
lua_pushinteger(L, usedspace);
|
||||
lua_setfield(L, -2, "used");
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int internalfs_dir_info(lua_State* L) {
|
||||
CheckLuaArgCount(L, 1, "_fs.dir_info");
|
||||
const char* path = luaL_checkstring(L, 1);
|
||||
|
||||
u64 tsize = 0;
|
||||
u32 tdirs = 0;
|
||||
u32 tfiles = 0;
|
||||
if (!DirInfo(path, &tsize, &tdirs, &tfiles)) {
|
||||
return luaL_error(L, "error when running DirInfo");
|
||||
}
|
||||
|
||||
lua_createtable(L, 0, 3);
|
||||
lua_pushinteger(L, tsize);
|
||||
lua_setfield(L, -2, "size");
|
||||
lua_pushinteger(L, tdirs);
|
||||
lua_setfield(L, -2, "dirs");
|
||||
lua_pushinteger(L, tfiles);
|
||||
lua_setfield(L, -2, "files");
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int FileDirSelector(lua_State* L, const char* path_orig, const char* prompt, bool is_dir, bool include_dirs, bool explorer) {
|
||||
bool ret;
|
||||
char path[_VAR_CNT_LEN] = { 0 };
|
||||
char choice[_VAR_CNT_LEN] = { 0 };
|
||||
strncpy(path, path_orig, _VAR_CNT_LEN);
|
||||
if (strncmp(path, "Z:", 2) == 0) {
|
||||
return luaL_error(L, "forbidden drive");
|
||||
} else if (!is_dir) {
|
||||
u32 flags_ext = include_dirs ? 0 : NO_DIRS;
|
||||
char *npattern = strrchr(path, '/');
|
||||
if (!npattern) {
|
||||
return luaL_error(L, "invalid path");
|
||||
}
|
||||
*(npattern++) = '\0';
|
||||
ret = FileSelector(choice, prompt, path, npattern, flags_ext, explorer);
|
||||
} else {
|
||||
ret = FileSelector(choice, prompt, path, NULL, NO_FILES | SELECT_DIRS, explorer);
|
||||
}
|
||||
|
||||
if (ret) {
|
||||
lua_pushstring(L, choice);
|
||||
} else {
|
||||
lua_pushnil(L);
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int internalfs_ask_select_file(lua_State* L) {
|
||||
bool extra = CheckLuaArgCountPlusExtra(L, 2, "_fs.ask_select_file");
|
||||
const char* prompt = luaL_checkstring(L, 1);
|
||||
const char* path = luaL_checkstring(L, 2);
|
||||
|
||||
u32 flags = 0;
|
||||
if (extra) {
|
||||
flags = GetFlagsFromTable(L, 3, flags, INCLUDE_DIRS | EXPLORER);
|
||||
};
|
||||
|
||||
return FileDirSelector(L, path, prompt, false, (flags & INCLUDE_DIRS), (flags & EXPLORER));
|
||||
}
|
||||
|
||||
static int internalfs_ask_select_dir(lua_State* L) {
|
||||
bool extra = CheckLuaArgCountPlusExtra(L, 2, "_fs.ask_select_dir");
|
||||
const char* prompt = luaL_checkstring(L, 1);
|
||||
const char* path = luaL_checkstring(L, 2);
|
||||
|
||||
u32 flags = 0;
|
||||
if (extra) {
|
||||
flags = GetFlagsFromTable(L, 3, flags, EXPLORER);
|
||||
};
|
||||
|
||||
return FileDirSelector(L, path, prompt, true, true, (flags & EXPLORER));
|
||||
}
|
||||
|
||||
static int internalfs_find(lua_State* L) {
|
||||
bool extra = CheckLuaArgCountPlusExtra(L, 1, "_fs.find");
|
||||
const char* pattern = luaL_checkstring(L, 1);
|
||||
char path[_VAR_CNT_LEN] = { 0 };
|
||||
|
||||
u32 flags = 0;
|
||||
if (extra) {
|
||||
flags = GetFlagsFromTable(L, 2, flags, FIND_FIRST);
|
||||
}
|
||||
|
||||
u8 mode = (flags & FIND_FIRST) ? FN_LOWEST : FN_HIGHEST;
|
||||
FRESULT res = fvx_findpath(path, pattern, mode);
|
||||
if (res == FR_NO_PATH) {
|
||||
lua_pushnil(L);
|
||||
} else if (res != FR_OK) {
|
||||
return luaL_error(L, "failed to find %s (%d)", pattern, res);
|
||||
} else {
|
||||
lua_pushstring(L, path);
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
// this should probably be rewritten
|
||||
static int internalfs_find_all(lua_State* L) {
|
||||
bool extra = CheckLuaArgCountPlusExtra(L, 2, "_fs.find_all");
|
||||
const char* dir = luaL_checkstring(L, 1);
|
||||
const char* pattern = luaL_checkstring(L, 2);
|
||||
|
||||
u32 flags = 0;
|
||||
if (extra) {
|
||||
flags = GetFlagsFromTable(L, 3, flags, RECURSIVE);
|
||||
}
|
||||
|
||||
char forpath[_VAR_CNT_LEN] = { 0 };
|
||||
|
||||
// without re-implementing for_handler, i need to give it a "*" pattern
|
||||
// and then manually compare each filename to see if it matches
|
||||
// so that a recursive search actually works
|
||||
bool forstatus = for_handler(NULL, dir, "*", flags & RECURSIVE);
|
||||
if (!forstatus) {
|
||||
return luaL_error(L, "could not open directory");
|
||||
}
|
||||
|
||||
lua_newtable(L);
|
||||
int i = 1;
|
||||
char* slash;
|
||||
|
||||
while (true) {
|
||||
forstatus = for_handler(forpath, NULL, NULL, false);
|
||||
if (!forstatus) {
|
||||
forpath[0] = '\0';
|
||||
}
|
||||
if (!forpath[0]) {
|
||||
// finish for_handler
|
||||
for_handler(NULL, NULL, NULL, false);
|
||||
break;
|
||||
} else {
|
||||
slash = strrchr(forpath, '/');
|
||||
if (!slash) bkpt; // this should never, ever happen
|
||||
if (fvx_match_name(slash+1, pattern) == FR_OK) {
|
||||
lua_pushstring(L, forpath);
|
||||
lua_seti(L, -2, i++);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int internalfs_find_not(lua_State* L) {
|
||||
CheckLuaArgCount(L, 1, "_fs.find_not");
|
||||
const char* pattern = luaL_checkstring(L, 1);
|
||||
char path[_VAR_CNT_LEN] = { 0 };
|
||||
|
||||
FRESULT res = fvx_findnopath(path, pattern);
|
||||
if (res != FR_OK) {
|
||||
return luaL_error(L, "failed to find %s (%d)", pattern, res);
|
||||
}
|
||||
|
||||
lua_pushstring(L, path);
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int internalfs_exists(lua_State* L) {
|
||||
CheckLuaArgCount(L, 1, "_fs.exists");
|
||||
const char* path = luaL_checkstring(L, 1);
|
||||
FILINFO fno;
|
||||
|
||||
lua_pushboolean(L, (fvx_stat(path, &fno) == FR_OK));
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int internalfs_is_dir(lua_State* L) {
|
||||
CheckLuaArgCount(L, 1, "_fs.is_dir");
|
||||
const char* path = luaL_checkstring(L, 1);
|
||||
|
||||
lua_pushboolean(L, PathIsDirectory(path));
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int internalfs_is_file(lua_State* L) {
|
||||
CheckLuaArgCount(L, 1, "_fs.is_file");
|
||||
const char* path = luaL_checkstring(L, 1);
|
||||
FILINFO fno;
|
||||
|
||||
FRESULT res = fvx_stat(path, &fno);
|
||||
if (res != FR_OK) {
|
||||
lua_pushboolean(L, false);
|
||||
} else {
|
||||
lua_pushboolean(L, !(fno.fattrib & AM_DIR));
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int internalfs_read_file(lua_State* L) {
|
||||
CheckLuaArgCount(L, 3, "_fs.read_file");
|
||||
const char* path = luaL_checkstring(L, 1);
|
||||
lua_Integer offset = luaL_checkinteger(L, 2);
|
||||
lua_Integer size = luaL_checkinteger(L, 3);
|
||||
|
||||
char *buf = malloc(size);
|
||||
if (!buf) {
|
||||
return luaL_error(L, "could not allocate memory to read file");
|
||||
}
|
||||
UINT bytes_read = 0;
|
||||
FRESULT res = fvx_qread(path, buf, offset, size, &bytes_read);
|
||||
if (res != FR_OK) {
|
||||
free(buf);
|
||||
return luaL_error(L, "could not read %s (%d)", path, res);
|
||||
}
|
||||
lua_pushlstring(L, buf, bytes_read);
|
||||
free(buf);
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int internalfs_write_file(lua_State* L) {
|
||||
CheckLuaArgCount(L, 3, "_fs.write_file");
|
||||
const char* path = luaL_checkstring(L, 1);
|
||||
lua_Integer offset = luaL_checkinteger(L, 2);
|
||||
size_t data_length = 0;
|
||||
const char* data = luaL_checklstring(L, 3, &data_length);
|
||||
|
||||
CheckWritePermissionsLuaError(L, path);
|
||||
|
||||
UINT bytes_written = 0;
|
||||
FRESULT res = fvx_qwrite(path, data, offset, data_length, &bytes_written);
|
||||
if (res != FR_OK) {
|
||||
return luaL_error(L, "error writing %s (%d)", path, res);
|
||||
}
|
||||
|
||||
lua_pushinteger(L, bytes_written);
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int internalfs_fill_file(lua_State* L) {
|
||||
bool extra = CheckLuaArgCountPlusExtra(L, 4, "_fs.fill_file");
|
||||
const char* path = luaL_checkstring(L, 1);
|
||||
lua_Integer offset = luaL_checkinteger(L, 2);
|
||||
lua_Integer size = luaL_checkinteger(L, 3);
|
||||
lua_Integer byte = luaL_checkinteger(L, 4);
|
||||
|
||||
u8 real_byte = byte & 0xFF;
|
||||
|
||||
u32 flags = ALLOW_EXPAND;
|
||||
if (extra) {
|
||||
flags = GetFlagsFromTable(L, 4, flags, NO_CANCEL);
|
||||
};
|
||||
|
||||
if ((byte < 0) || (byte > 0xFF)) {
|
||||
return luaL_error(L, "byte is not between 0x00 and 0xFF (got: %I)", byte);
|
||||
}
|
||||
|
||||
CheckWritePermissionsLuaError(L, path);
|
||||
|
||||
if (!(FileSetByte(path, offset, size, real_byte, &flags))) {
|
||||
return luaL_error(L, "FileSetByte failed on %s", path);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int internalfs_make_dummy_file(lua_State* L) {
|
||||
CheckLuaArgCount(L, 2, "_fs.make_dummy_file");
|
||||
const char* path = luaL_checkstring(L, 1);
|
||||
lua_Integer size = luaL_checkinteger(L, 2);
|
||||
|
||||
CheckWritePermissionsLuaError(L, path);
|
||||
|
||||
if (!(FileCreateDummy(path, NULL, size))) {
|
||||
return luaL_error(L, "FileCreateDummy failed on %s", path);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int internalfs_truncate(lua_State* L) {
|
||||
CheckLuaArgCount(L, 2, "_fs.truncate");
|
||||
const char* path = luaL_checkstring(L, 1);
|
||||
lua_Integer size = luaL_checkinteger(L, 2);
|
||||
FIL fp;
|
||||
FRESULT res;
|
||||
|
||||
CheckWritePermissionsLuaError(L, path);
|
||||
|
||||
res = f_open(&fp, path, FA_READ | FA_WRITE);
|
||||
if (res != FR_OK) {
|
||||
return luaL_error(L, "failed to open %s (note: this only works on FAT filesystems, not virtual)", path);
|
||||
}
|
||||
|
||||
res = f_lseek(&fp, size);
|
||||
if (res != FR_OK) {
|
||||
f_close(&fp);
|
||||
return luaL_error(L, "failed to seek on %s", path);
|
||||
}
|
||||
|
||||
res = f_truncate(&fp);
|
||||
if (res != FR_OK) {
|
||||
f_close(&fp);
|
||||
return luaL_error(L, "failed to truncate %s", path);
|
||||
}
|
||||
|
||||
f_close(&fp);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int internalfs_img_mount(lua_State* L) {
|
||||
CheckLuaArgCount(L, 1, "_fs.img_mount");
|
||||
const char* path = luaL_checkstring(L, 1);
|
||||
|
||||
bool res = InitImgFS(path);
|
||||
if (!res) {
|
||||
return luaL_error(L, "failed to mount %s", path);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int internalfs_img_umount(lua_State* L) {
|
||||
CheckLuaArgCount(L, 0, "_fs.img_umount");
|
||||
|
||||
InitImgFS(NULL);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int internalfs_get_img_mount(lua_State* L) {
|
||||
CheckLuaArgCount(L, 0, "_fs.get_img_mount");
|
||||
|
||||
char path[256] = { 0 };
|
||||
strncpy(path, GetMountPath(), 256);
|
||||
if (path[0] == 0) {
|
||||
// since lua treats "" as true, return a nil to make if/else easier
|
||||
lua_pushnil(L);
|
||||
} else {
|
||||
lua_pushstring(L, path);
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
// TODO: what if someone does offset != 0 but size = 0 (end of file)?
|
||||
static int internalfs_hash_file(lua_State* L) {
|
||||
bool extra = CheckLuaArgCountPlusExtra(L, 3, "_fs.hash_file");
|
||||
const char* path = luaL_checkstring(L, 1);
|
||||
lua_Integer offset = luaL_checkinteger(L, 2);
|
||||
lua_Integer size = luaL_checkinteger(L, 3);
|
||||
FRESULT res;
|
||||
FILINFO fno;
|
||||
|
||||
if (size == 0) {
|
||||
res = fvx_stat(path, &fno);
|
||||
if (res != FR_OK) {
|
||||
return luaL_error(L, "failed to stat %s", path);
|
||||
}
|
||||
|
||||
size = fno.fsize;
|
||||
}
|
||||
|
||||
u32 flags = 0;
|
||||
if (extra) {
|
||||
flags = GetFlagsFromTable(L, 4, flags, USE_SHA1);
|
||||
}
|
||||
|
||||
const u8 hashlen = (flags & USE_SHA1) ? 20 : 32;
|
||||
u8 hash_fil[0x20];
|
||||
|
||||
if (size == 0) {
|
||||
// shortcut by just returning the hash of empty data
|
||||
memcpy(hash_fil, (flags & USE_SHA1) ? no_data_hash_1 : no_data_hash_256, hashlen);
|
||||
} else if (!(FileGetSha(path, hash_fil, offset, size, (flags & USE_SHA1)))) {
|
||||
return luaL_error(L, "FileGetSha failed on %s", path);
|
||||
}
|
||||
|
||||
lua_pushlstring(L, (char*)hash_fil, hashlen);
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int internalfs_hash_data(lua_State* L) {
|
||||
bool extra = CheckLuaArgCountPlusExtra(L, 1, "_fs.hash_data");
|
||||
size_t data_length = 0;
|
||||
const char* data = luaL_checklstring(L, 1, &data_length);
|
||||
|
||||
u32 flags = 0;
|
||||
if (extra) {
|
||||
flags = GetFlagsFromTable(L, 2, flags, USE_SHA1);
|
||||
}
|
||||
|
||||
const u8 hashlen = (flags & USE_SHA1) ? 20 : 32;
|
||||
u8 hash_fil[0x20];
|
||||
|
||||
if (data_length == 0) {
|
||||
// shortcut by just returning the hash of empty data
|
||||
memcpy(hash_fil, (flags & USE_SHA1) ? no_data_hash_1 : no_data_hash_256, hashlen);
|
||||
} else {
|
||||
sha_quick(hash_fil, data, data_length, (flags & USE_SHA1) ? SHA1_MODE : SHA256_MODE);
|
||||
}
|
||||
|
||||
lua_pushlstring(L, (char*)hash_fil, hashlen);
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int internalfs_allow(lua_State* L) {
|
||||
bool extra = CheckLuaArgCountPlusExtra(L, 1, "_fs.allow");
|
||||
const char* path = luaL_checkstring(L, 1);
|
||||
u32 flags = 0;
|
||||
bool allowed;
|
||||
if (extra) {
|
||||
flags = GetFlagsFromTable(L, 2, 0, ASK_ALL);
|
||||
}
|
||||
|
||||
if (flags & ASK_ALL) {
|
||||
allowed = CheckDirWritePermissions(path);
|
||||
} else {
|
||||
allowed = CheckWritePermissions(path);
|
||||
}
|
||||
lua_pushboolean(L, allowed);
|
||||
return 1;
|
||||
};
|
||||
|
||||
static int internalfs_verify(lua_State* L) {
|
||||
CheckLuaArgCount(L, 1, "_fs.verify");
|
||||
const char* path = luaL_checkstring(L, 1);
|
||||
bool res;
|
||||
|
||||
u64 filetype = IdentifyFileType(path);
|
||||
if (filetype & IMG_NAND) res = (ValidateNandDump(path) == 0);
|
||||
else res = (VerifyGameFile(path) == 0);
|
||||
|
||||
lua_pushboolean(L, res);
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int internalfs_sd_is_mounted(lua_State* L) {
|
||||
CheckLuaArgCount(L, 0, "_fs.sd_is_mounted");
|
||||
|
||||
lua_pushboolean(L, CheckSDMountState());
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int internalfs_sd_switch(lua_State* L) {
|
||||
bool extra = CheckLuaArgCountPlusExtra(L, 0, "_fs.sd_switch");
|
||||
const char* message;
|
||||
|
||||
if (extra) {
|
||||
message = luaL_checkstring(L, 1);
|
||||
} else {
|
||||
message = "Please switch the SD card now.";
|
||||
}
|
||||
|
||||
bool ret;
|
||||
|
||||
DeinitExtFS();
|
||||
if (!(ret = CheckSDMountState())) {
|
||||
return luaL_error(L, "%s", STR_SCRIPTERR_SD_NOT_MOUNTED);
|
||||
}
|
||||
|
||||
u32 pad_state;
|
||||
DeinitSDCardFS();
|
||||
ShowString("%s\n \n%s", message, STR_EJECT_SD_CARD);
|
||||
while (!((pad_state = InputWait(0)) & (BUTTON_B|SD_EJECT)));
|
||||
if (pad_state & SD_EJECT) {
|
||||
ShowString("%s\n \n%s", message, STR_INSERT_SD_CARD);
|
||||
while (!((pad_state = InputWait(0)) & (BUTTON_B|SD_INSERT)));
|
||||
}
|
||||
if (pad_state & BUTTON_B) {
|
||||
return luaL_error(L, "user canceled");
|
||||
}
|
||||
|
||||
InitSDCardFS();
|
||||
AutoEmuNandBase(true);
|
||||
InitExtFS();
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int internalfs_key_dump(lua_State* L) {
|
||||
bool extra = CheckLuaArgCountPlusExtra(L, 1, "_fs.key_dump");
|
||||
const char* opts[] = {SEEDINFO_NAME, TIKDB_NAME_ENC, TIKDB_NAME_DEC, NULL};
|
||||
int opt = luaL_checkoption(L, 1, NULL, opts);
|
||||
bool ret = false;
|
||||
|
||||
u32 flags = 0;
|
||||
if (extra) {
|
||||
flags = GetFlagsFromTable(L, 2, 0, OVERWRITE_ALL);
|
||||
}
|
||||
|
||||
if (opt == 1 || opt == 2) {
|
||||
bool tik_dec = opt == 2;
|
||||
if (flags & OVERWRITE_ALL) fvx_unlink(tik_dec ? OUTPUT_PATH "/" TIKDB_NAME_DEC : OUTPUT_PATH "/" TIKDB_NAME_ENC);
|
||||
if (BuildTitleKeyInfo(NULL, tik_dec, false) == 0) {
|
||||
ShowString(STR_BUILDING_TO_OUT_ARG, OUTPUT_PATH, opts[opt]);
|
||||
if (((BuildTitleKeyInfo("1:/dbs/ticket.db", tik_dec, false) == 0) ||
|
||||
(BuildTitleKeyInfo("4:/dbs/ticket.db", tik_dec, false) == 0)) &&
|
||||
(BuildTitleKeyInfo(NULL, tik_dec, true) == 0))
|
||||
ret = true;
|
||||
}
|
||||
} else if (opt == 0) {
|
||||
if (flags & OVERWRITE_ALL) fvx_unlink(OUTPUT_PATH "/" SEEDINFO_NAME);
|
||||
if (BuildSeedInfo(NULL, false) == 0) {
|
||||
ShowString(STR_BUILDING_TO_OUT_ARG, OUTPUT_PATH, opts[opt]);
|
||||
if (((BuildSeedInfo("1:", false) == 0) ||
|
||||
(BuildSeedInfo("4:", false) == 0)) &&
|
||||
(BuildSeedInfo(NULL, true) == 0))
|
||||
ret = true;
|
||||
}
|
||||
}
|
||||
|
||||
if (!ret) {
|
||||
return luaL_error(L, "building %s failed", opts[opt]);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int internalfs_cart_dump(lua_State* L) {
|
||||
bool extra = CheckLuaArgCountPlusExtra(L, 2, "_fs.cart_dump");
|
||||
const char* path = luaL_checkstring(L, 1);
|
||||
u64 fsize = (u64)luaL_checkinteger(L, 2);
|
||||
bool ret = false;
|
||||
const char* errstr = "";
|
||||
|
||||
u32 flags = 0;
|
||||
if (extra) {
|
||||
flags = GetFlagsFromTable(L, 3, flags, ENCRYPTED);
|
||||
}
|
||||
|
||||
CartData* cdata = (CartData*) malloc(sizeof(CartData));
|
||||
u8* buf = (u8*) malloc(STD_BUFFER_SIZE);
|
||||
ret = false;
|
||||
if (!cdata || !buf) {
|
||||
errstr = "out of memory";
|
||||
} else if (InitCartRead(cdata) != 0){
|
||||
errstr = "cart init fail";
|
||||
} else {
|
||||
SetSecureAreaEncryption(flags & ENCRYPTED);
|
||||
fvx_unlink(path);
|
||||
ret = true;
|
||||
errstr = "cart dump failed or canceled";
|
||||
for (u64 p = 0; p < fsize; p += STD_BUFFER_SIZE) {
|
||||
u64 len = min((fsize - p), STD_BUFFER_SIZE);
|
||||
ShowProgress(p, fsize, path);
|
||||
if (!ShowProgress(p, fsize, path) ||
|
||||
(ReadCartBytes(buf, p, len, cdata, false) != 0) ||
|
||||
(fvx_qwrite(path, buf, p, len, NULL) != FR_OK)) {
|
||||
ret = false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
free(buf);
|
||||
free(cdata);
|
||||
|
||||
if (!ret) {
|
||||
return luaL_error(L, "%s", errstr);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static const luaL_Reg internalfs_lib[] = {
|
||||
{"move", internalfs_move},
|
||||
{"remove", internalfs_remove},
|
||||
{"copy", internalfs_copy},
|
||||
{"mkdir", internalfs_mkdir},
|
||||
{"list_dir", internalfs_list_dir},
|
||||
{"stat", internalfs_stat},
|
||||
{"stat_fs", internalfs_stat_fs},
|
||||
{"dir_info", internalfs_dir_info},
|
||||
{"ask_select_file", internalfs_ask_select_file},
|
||||
{"ask_select_dir", internalfs_ask_select_dir},
|
||||
{"find", internalfs_find},
|
||||
{"find_all", internalfs_find_all},
|
||||
{"find_not", internalfs_find_not},
|
||||
{"exists", internalfs_exists},
|
||||
{"is_dir", internalfs_is_dir},
|
||||
{"is_file", internalfs_is_file},
|
||||
{"read_file", internalfs_read_file},
|
||||
{"write_file", internalfs_write_file},
|
||||
{"fill_file", internalfs_fill_file},
|
||||
{"make_dummy_file", internalfs_make_dummy_file},
|
||||
{"truncate", internalfs_truncate},
|
||||
{"img_mount", internalfs_img_mount},
|
||||
{"img_umount", internalfs_img_umount},
|
||||
{"get_img_mount", internalfs_get_img_mount},
|
||||
{"hash_file", internalfs_hash_file},
|
||||
{"hash_data", internalfs_hash_data},
|
||||
{"verify", internalfs_verify},
|
||||
{"allow", internalfs_allow},
|
||||
{"sd_is_mounted", internalfs_sd_is_mounted},
|
||||
{"sd_switch", internalfs_sd_switch},
|
||||
{"fix_cmacs", internalfs_fix_cmacs},
|
||||
{"key_dump", internalfs_key_dump},
|
||||
{"cart_dump", internalfs_cart_dump},
|
||||
{NULL, NULL}
|
||||
};
|
||||
|
||||
int gm9lua_open_internalfs(lua_State* L) {
|
||||
luaL_newlib(L, internalfs_lib);
|
||||
return 1;
|
||||
}
|
||||
#endif
|
||||
@ -1,23 +0,0 @@
|
||||
#pragma once
|
||||
#include "gm9lua.h"
|
||||
|
||||
#define GM9LUA_INTERNALFSLIBNAME "_fs"
|
||||
|
||||
#define SHA256_EMPTY_HASH \
|
||||
0xE3, 0xB0, 0xC4, 0x42, \
|
||||
0x98, 0xFC, 0x1C, 0x14, \
|
||||
0x9A, 0xFB, 0xF4, 0xC8, \
|
||||
0x99, 0x6F, 0xB9, 0x24, \
|
||||
0x27, 0xAE, 0x41, 0xE4, \
|
||||
0x64, 0x9B, 0x93, 0x4C, \
|
||||
0xA4, 0x95, 0x99, 0x1B, \
|
||||
0x78, 0x52, 0xB8, 0x55
|
||||
|
||||
#define SHA1_EMPTY_HASH \
|
||||
0xDA, 0x39, 0xA3, 0xEE, \
|
||||
0x5E, 0x6B, 0x4B, 0x0D, \
|
||||
0x32, 0x55, 0xBF, 0xEF, \
|
||||
0x95, 0x60, 0x18, 0x90, \
|
||||
0xAF, 0xD8, 0x07, 0x09
|
||||
|
||||
int gm9lua_open_internalfs(lua_State* L);
|
||||
@ -1,181 +0,0 @@
|
||||
#ifndef NO_LUA
|
||||
#include "gm9internalsys.h"
|
||||
#include "bootfirm.h"
|
||||
#include "fs.h"
|
||||
#include "pxi.h"
|
||||
#include "game.h"
|
||||
#include "power.h"
|
||||
#include "sha.h"
|
||||
#include "nand.h"
|
||||
#include "utils.h"
|
||||
#include "ui.h"
|
||||
#include "rtc.h"
|
||||
#include "godmode.h"
|
||||
|
||||
#define UNUSED(x) ((void)(x))
|
||||
|
||||
static int internalsys_boot(lua_State* L) {
|
||||
CheckLuaArgCount(L, 1, "_sys.boot");
|
||||
const char* path = lua_tostring(L, 1);
|
||||
|
||||
u8* firm = (u8*) malloc(FIRM_MAX_SIZE);
|
||||
if (!firm) {
|
||||
return luaL_error(L, "out of memory");
|
||||
}
|
||||
|
||||
size_t firm_size = FileGetData(path, firm, FIRM_MAX_SIZE, 0);
|
||||
if (!(firm_size && IsBootableFirm(firm, firm_size))) {
|
||||
return luaL_error(L, "not a bootable firm");
|
||||
}
|
||||
|
||||
char fixpath[256] = { 0 };
|
||||
if ((*path == '0') || (*path == '1'))
|
||||
snprintf(fixpath, sizeof(fixpath), "%s%s", (*path == '0') ? "sdmc" : "nand", path + 1);
|
||||
else strncpy(fixpath, path, 256);
|
||||
fixpath[255] = '\0';
|
||||
DeinitExtFS();
|
||||
DeinitSDCardFS();
|
||||
PXI_DoCMD(PXICMD_LEGACY_BOOT, NULL, 0);
|
||||
PXI_Barrier(PXI_FIRMLAUNCH_BARRIER);
|
||||
BootFirm((FirmHeader*)(void*)firm, fixpath);
|
||||
while(1);
|
||||
}
|
||||
|
||||
static int internalsys_reboot(lua_State* L) {
|
||||
CheckLuaArgCount(L, 0, "_sys.reboot");
|
||||
DeinitExtFS();
|
||||
DeinitSDCardFS();
|
||||
Reboot();
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int internalsys_power_off(lua_State* L) {
|
||||
CheckLuaArgCount(L, 0, "_sys.power_off");
|
||||
DeinitExtFS();
|
||||
DeinitSDCardFS();
|
||||
PowerOff();
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int internalsys_get_id0(lua_State* L) {
|
||||
CheckLuaArgCount(L, 1, "_sys.get_id0");
|
||||
const char* path = lua_tostring(L, 1);
|
||||
|
||||
char env_id0[32+1];
|
||||
u8 sd_keyy[0x10] __attribute__((aligned(4)));
|
||||
if (FileGetData(path, sd_keyy, 0x10, 0x110) == 0x10) {
|
||||
u32 sha256sum[8];
|
||||
sha_quick(sha256sum, sd_keyy, 0x10, SHA256_MODE);
|
||||
snprintf(env_id0, sizeof(env_id0), "%08lx%08lx%08lx%08lx",
|
||||
sha256sum[0], sha256sum[1], sha256sum[2], sha256sum[3]);
|
||||
lua_pushstring(L, env_id0);
|
||||
} else {
|
||||
lua_pushnil(L);
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int internalsys_next_emu(lua_State* L) {
|
||||
CheckLuaArgCount(L, 0, "_sys.next_emu");
|
||||
|
||||
DismountDriveType(DRV_EMUNAND);
|
||||
AutoEmuNandBase(false);
|
||||
InitExtFS();
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int internalsys_get_emu_base(lua_State* L) {
|
||||
CheckLuaArgCount(L, 0, "_sys.get_emu_base");
|
||||
|
||||
lua_pushinteger(L, GetEmuNandBase());
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int internalsys_check_embedded_backup(lua_State* L) {
|
||||
CheckLuaArgCount(L, 0, "_sys.check_embedded_backup");
|
||||
|
||||
if (PathExist("S:/essential.exefs")) {
|
||||
lua_pushboolean(L, true);
|
||||
return 1;
|
||||
}
|
||||
|
||||
bool ncsd_check = CheckGenuineNandNcsd();
|
||||
if (!ncsd_check) {
|
||||
lua_pushnil(L);
|
||||
return 1;
|
||||
}
|
||||
|
||||
bool ret = false;
|
||||
|
||||
if (ncsd_check && ShowPrompt(true, "%s", STR_ESSENTIAL_BACKUP_NOT_FOUND_CREATE_NOW)) {
|
||||
if (EmbedEssentialBackup("S:/nand.bin") == 0) {
|
||||
u32 flags = BUILD_PATH | SKIP_ALL;
|
||||
PathCopy(OUTPUT_PATH, "S:/essential.exefs", &flags);
|
||||
ShowPrompt(false, STR_BACKUP_EMBEDDED_WRITTEN_TO_OUT, OUTPUT_PATH);
|
||||
ret = true;
|
||||
} else {
|
||||
ret = false;
|
||||
}
|
||||
} else {
|
||||
ret = false;
|
||||
}
|
||||
|
||||
lua_pushboolean(L, ret);
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int internalsys_check_raw_rtc(lua_State* L) {
|
||||
CheckLuaArgCount(L, 0, "_sys.check_raw_rtc");
|
||||
|
||||
bool result = false;
|
||||
|
||||
DsTime dstime;
|
||||
get_dstime(&dstime);
|
||||
if (DSTIMEGET(&dstime, bcd_Y) >= 18) {
|
||||
result = true;
|
||||
} else if (ShowPrompt(true, "%s", STR_RTC_DATE_TIME_SEEMS_TO_BE_WRONG_SET_NOW) &&
|
||||
ShowRtcSetterPrompt(&dstime, "%s", STR_TITLE_SET_RTC_DATE_TIME)) {
|
||||
//char timestr[UTF_BUFFER_BYTESIZE(32)];
|
||||
set_dstime(&dstime);
|
||||
// this is only in godmode.h
|
||||
//GetTimeString(timestr, true, true);
|
||||
// ShowPrompt(false, STR_NEW_RTC_DATE_TIME_IS_TIME, timestr);
|
||||
result = true;
|
||||
}
|
||||
|
||||
lua_pushboolean(L, result);
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int internalsys_global_bkpt(lua_State* L) {
|
||||
UNUSED(L);
|
||||
bkpt;
|
||||
while(1);
|
||||
}
|
||||
|
||||
static const luaL_Reg internalsys_lib[] = {
|
||||
{"boot", internalsys_boot},
|
||||
{"reboot", internalsys_reboot},
|
||||
{"power_off", internalsys_power_off},
|
||||
{"get_id0", internalsys_get_id0},
|
||||
{"next_emu", internalsys_next_emu},
|
||||
{"get_emu_base", internalsys_get_emu_base},
|
||||
{"check_embedded_backup", internalsys_check_embedded_backup},
|
||||
{"check_raw_rtc", internalsys_check_raw_rtc},
|
||||
{NULL, NULL}
|
||||
};
|
||||
|
||||
static const luaL_Reg internalsys_global_lib[] = {
|
||||
{"bkpt", internalsys_global_bkpt},
|
||||
{NULL, NULL}
|
||||
};
|
||||
|
||||
int gm9lua_open_internalsys(lua_State* L) {
|
||||
luaL_newlib(L, internalsys_lib);
|
||||
lua_pushglobaltable(L); // push global table to stack
|
||||
luaL_setfuncs(L, internalsys_global_lib, 0); // set global funcs
|
||||
lua_pop(L, 1); // pop global table from stack
|
||||
return 1;
|
||||
}
|
||||
#endif
|
||||
@ -1,6 +0,0 @@
|
||||
#pragma once
|
||||
#include "gm9lua.h"
|
||||
|
||||
#define GM9LUA_INTERNALSYSLIBNAME "_sys"
|
||||
|
||||
int gm9lua_open_internalsys(lua_State* L);
|
||||
@ -1,128 +0,0 @@
|
||||
#ifndef NO_LUA
|
||||
#include "gm9loader.h"
|
||||
#include "gm9lua.h"
|
||||
#include "vff.h"
|
||||
#include "ui.h"
|
||||
|
||||
// a lot of this code is based on stuff in loadlib.c but adapted for GM9
|
||||
|
||||
// similar to readable
|
||||
static int Readable(const char* filename) {
|
||||
FIL f;
|
||||
FRESULT res = fvx_open(&f, filename, FA_READ | FA_OPEN_EXISTING);
|
||||
if (res != FR_OK) return 0;
|
||||
fvx_close(&f);
|
||||
return 1;
|
||||
}
|
||||
|
||||
// similar to getnextfilename
|
||||
static const char* GetNextFileName(char** path, char* end) {
|
||||
char *sep;
|
||||
char *name = *path;
|
||||
if (name == end)
|
||||
return NULL; /* no more names */
|
||||
else if (*name == '\0') { /* from previous iteration? */
|
||||
*name = *LUA_PATH_SEP; /* restore separator */
|
||||
name++; /* skip it */
|
||||
}
|
||||
sep = strchr(name, *LUA_PATH_SEP); /* find next separator */
|
||||
if (sep == NULL) /* separator not found? */
|
||||
sep = end; /* name goes until the end */
|
||||
*sep = '\0'; /* finish file name */
|
||||
*path = sep; /* will start next search from here */
|
||||
return name;
|
||||
}
|
||||
|
||||
// similar to pusherrornotfound
|
||||
static void PushErrorNotFound(lua_State* L, const char* path) {
|
||||
luaL_Buffer b;
|
||||
luaL_buffinit(L, &b);
|
||||
luaL_addstring(&b, "no file '");
|
||||
luaL_addgsub(&b, path, LUA_PATH_SEP, "'\n\tno file '");
|
||||
luaL_addstring(&b, "'");
|
||||
luaL_pushresult(&b);
|
||||
}
|
||||
|
||||
// similar to searchpath
|
||||
static const char* SearchPath(lua_State* L, const char* name, const char* path, const char* sep) {
|
||||
luaL_Buffer buff;
|
||||
char* pathname;
|
||||
char* endpathname;
|
||||
const char* filename;
|
||||
if (*sep != '\0' && strchr(name, *sep) != NULL)
|
||||
name = luaL_gsub(L, name, sep, "/");
|
||||
|
||||
luaL_buffinit(L, &buff);
|
||||
// add path to the buffer, replacing marks ('?') with the file name
|
||||
luaL_addgsub(&buff, path, LUA_PATH_MARK, name);
|
||||
luaL_addchar(&buff, '\0');
|
||||
pathname = luaL_buffaddr(&buff);
|
||||
endpathname = pathname + luaL_bufflen(&buff) + 1;
|
||||
while ((filename = GetNextFileName(&pathname, endpathname)) != NULL) {
|
||||
if (Readable(filename))
|
||||
return lua_pushstring(L, filename);
|
||||
}
|
||||
luaL_pushresult(&buff);
|
||||
PushErrorNotFound(L, lua_tostring(L, -1));
|
||||
return NULL;
|
||||
}
|
||||
|
||||
// similar to findfile
|
||||
static const char* FindLuaFile(lua_State* L, const char* name, const char* pname) {
|
||||
const char* path;
|
||||
lua_getfield(L, lua_upvalueindex(1), pname); // gets 'package' table
|
||||
path = lua_tostring(L, -1);
|
||||
if (path == NULL) luaL_error(L, "'package.%s' must be a string", pname);
|
||||
return SearchPath(L, name, path, ".");
|
||||
}
|
||||
|
||||
// similar to checkload
|
||||
static int CheckLoad(lua_State* L, int stat, const char* filename) {
|
||||
if (stat) {
|
||||
lua_pushstring(L, filename);
|
||||
return 2; // return open function and filename
|
||||
} else {
|
||||
return luaL_error(L, "error loading module '%s' from file '%s':\n\t%s",
|
||||
lua_tostring(L, 1), filename, lua_tostring(L, -1));
|
||||
}
|
||||
}
|
||||
|
||||
// similar to searcher_Lua
|
||||
static int PackageSearcher(lua_State* L) {
|
||||
const char *filename;
|
||||
const char *name = luaL_checkstring(L, 1);
|
||||
|
||||
filename = FindLuaFile(L, name, "path");
|
||||
|
||||
if (filename == NULL) return 1; // module not found in this path
|
||||
return CheckLoad(L, (LoadLuaFile(L, filename) == LUA_OK), filename);
|
||||
}
|
||||
|
||||
void ResetPackageSearchersAndPath(lua_State* L) {
|
||||
// get package module
|
||||
lua_getglobal(L, "package");
|
||||
|
||||
// the default package.path only makes sense on a full OS
|
||||
// maybe this should include the lua script's current directory somehow...
|
||||
lua_pushliteral(L, GM9LUA_DEFAULT_PATH);
|
||||
lua_setfield(L, -2, "path");
|
||||
|
||||
// package.cpath is for loading binary modules, useless on GM9
|
||||
lua_pushliteral(L, "");
|
||||
lua_setfield(L, -2, "cpath");
|
||||
|
||||
// the default package searchers only make sense on a full OS
|
||||
// so here we replace the lua loader with a custom one, and remove the C/Croot loaders
|
||||
// leaving the initial one (preload)
|
||||
lua_getfield(L, -1, "searchers");
|
||||
lua_pushvalue(L, -2); // copy 'package' to the top of the stack, to set 'package' as upvalue for all searchers
|
||||
lua_pushcclosure(L, PackageSearcher, 1); // push PackageSearcher with one upvalue being the "packages" module/table
|
||||
lua_rawseti(L, -2, 2); // replace default lua loader
|
||||
lua_pushnil(L);
|
||||
lua_rawseti(L, -2, 3); // remove C loader
|
||||
lua_pushnil(L);
|
||||
lua_rawseti(L, -2, 4); // remove C root loader
|
||||
lua_pop(L, 1); // remove "searchers"
|
||||
lua_pop(L, 1); // remove "packages"
|
||||
}
|
||||
#endif
|
||||
@ -1,15 +0,0 @@
|
||||
#include "gm9lua.h"
|
||||
|
||||
/*
|
||||
* 0:/gm9/luapackages/?.lua;
|
||||
* 0:/gm9/luapackages/?/init.lua;
|
||||
* V:/luapackages/?.lua;
|
||||
* V:/luapackages/?/init.lua
|
||||
*/
|
||||
#define GM9LUA_DEFAULT_PATH \
|
||||
"0:/gm9/luapackages/"LUA_PATH_MARK".lua" LUA_PATH_SEP \
|
||||
"0:/gm9/luapackages/"LUA_PATH_MARK"/init.lua" LUA_PATH_SEP \
|
||||
"V:/luapackages/"LUA_PATH_MARK".lua" LUA_PATH_SEP \
|
||||
"V:/luapackages/"LUA_PATH_MARK"/init.lua"
|
||||
|
||||
void ResetPackageSearchersAndPath(lua_State* L);
|
||||
@ -1,216 +0,0 @@
|
||||
#include "gm9lua.h"
|
||||
#include "ui.h"
|
||||
#include "language.h"
|
||||
#ifndef NO_LUA
|
||||
#include "fs.h"
|
||||
#include "ff.h"
|
||||
#include "vff.h"
|
||||
#include "fsutil.h"
|
||||
#include "unittype.h"
|
||||
#include "nand.h"
|
||||
#include "gm9loader.h"
|
||||
#include "gm9os.h"
|
||||
#include "gm9ui.h"
|
||||
#include "gm9title.h"
|
||||
#include "gm9internalfs.h"
|
||||
#include "gm9internalsys.h"
|
||||
|
||||
#define DEBUGSP(x) ShowPrompt(false, (x))
|
||||
|
||||
typedef struct GM9LuaLoadF {
|
||||
int n; // pre-read characters
|
||||
FIL f;
|
||||
FRESULT res;
|
||||
char buff[BUFSIZ];
|
||||
} GM9LuaLoadF;
|
||||
|
||||
// similar to "getF" in lauxlib.c
|
||||
static const char* GetF(lua_State* L, void* ud, size_t* size) {
|
||||
GM9LuaLoadF* lf = (GM9LuaLoadF*)ud;
|
||||
UINT br = 0;
|
||||
(void)L; // unused
|
||||
if (lf->n > 0) { // check for pre-read characters
|
||||
*size = lf->n; // return those
|
||||
lf->n = 0;
|
||||
} else {
|
||||
if (fvx_eof(&lf->f)) return NULL;
|
||||
lf->res = fvx_read(&lf->f, lf->buff, BUFSIZ, &br);
|
||||
*size = (size_t)br;
|
||||
if (lf->res != FR_OK) return NULL;
|
||||
}
|
||||
return lf->buff;
|
||||
}
|
||||
|
||||
// similar to "errfile" in lauxlib.c
|
||||
static int ErrFile(lua_State* L, const char* what, int fnameindex, FRESULT res) {
|
||||
const char* filename = lua_tostring(L, fnameindex) + 1;
|
||||
lua_pushfstring(L, "cannot %s %s:\nfatfs error %d", what, filename, res);
|
||||
lua_remove(L, fnameindex);
|
||||
return LUA_ERRFILE;
|
||||
}
|
||||
|
||||
int LoadLuaFile(lua_State* L, const char* filename) {
|
||||
GM9LuaLoadF lf;
|
||||
lf.n = 0;
|
||||
int status;
|
||||
int fnameindex = lua_gettop(L) + 1; // index of filename on the stack
|
||||
lua_pushfstring(L, "@%s", filename);
|
||||
lf.res = fvx_open(&lf.f, filename, FA_READ | FA_OPEN_EXISTING);
|
||||
if (lf.res != FR_OK) return ErrFile(L, "open", fnameindex, lf.res);
|
||||
|
||||
status = lua_load(L, GetF, &lf, lua_tostring(L, -1), NULL);
|
||||
fvx_close(&lf.f);
|
||||
if (lf.res != FR_OK) {
|
||||
lua_settop(L, fnameindex);
|
||||
return ErrFile(L, "read", fnameindex, lf.res);
|
||||
}
|
||||
lua_remove(L, fnameindex);
|
||||
return status;
|
||||
}
|
||||
|
||||
u32 GetFlagsFromTable(lua_State* L, int pos, u32 flags_ext_starter, u32 allowed_flags) {
|
||||
char types[FLAGS_COUNT][14] = { FLAGS_STR };
|
||||
int types_int[FLAGS_COUNT] = { FLAGS_CONSTS };
|
||||
u32 flags_ext = flags_ext_starter;
|
||||
|
||||
for (int i = 0; i < FLAGS_COUNT; i++) {
|
||||
if (!(allowed_flags & types_int[i])) continue;
|
||||
lua_getfield(L, pos, types[i]);
|
||||
if (lua_toboolean(L, -1)) flags_ext |= types_int[i];
|
||||
lua_pop(L, 1);
|
||||
}
|
||||
|
||||
return flags_ext;
|
||||
}
|
||||
|
||||
void CheckWritePermissionsLuaError(lua_State* L, const char* path) {
|
||||
if (!CheckWritePermissions(path)) {
|
||||
luaL_error(L, "writing not allowed: %s", path);
|
||||
}
|
||||
}
|
||||
|
||||
static const luaL_Reg gm9lualibs[] = {
|
||||
// built-ins
|
||||
{LUA_GNAME, luaopen_base},
|
||||
{LUA_LOADLIBNAME, luaopen_package},
|
||||
{LUA_COLIBNAME, luaopen_coroutine},
|
||||
{LUA_TABLIBNAME, luaopen_table},
|
||||
{LUA_STRLIBNAME, luaopen_string},
|
||||
{LUA_MATHLIBNAME, luaopen_math},
|
||||
{LUA_UTF8LIBNAME, luaopen_utf8},
|
||||
{LUA_DBLIBNAME, luaopen_debug},
|
||||
|
||||
// gm9 custom
|
||||
{GM9LUA_OSLIBNAME, gm9lua_open_os},
|
||||
{GM9LUA_UILIBNAME, gm9lua_open_ui},
|
||||
{GM9LUA_TITLELIBNAME, gm9lua_open_title},
|
||||
|
||||
// gm9 custom internals (usually wrapped by a pure lua module)
|
||||
{GM9LUA_INTERNALFSLIBNAME, gm9lua_open_internalfs},
|
||||
{GM9LUA_INTERNALSYSLIBNAME, gm9lua_open_internalsys},
|
||||
|
||||
{NULL, NULL}
|
||||
};
|
||||
|
||||
static void loadlibs(lua_State* L) {
|
||||
const luaL_Reg* lib;
|
||||
for (lib = gm9lualibs; lib->func; lib++) {
|
||||
luaL_requiref(L, lib->name, lib->func, 1);
|
||||
lua_pop(L, 1); // remove lib from stack
|
||||
}
|
||||
}
|
||||
|
||||
static bool RunFile(lua_State* L, const char* file) {
|
||||
int result = LoadLuaFile(L, file);
|
||||
if (result != LUA_OK) {
|
||||
char errstr[BUFSIZ] = {0};
|
||||
strlcpy(errstr, lua_tostring(L, -1), BUFSIZ);
|
||||
WordWrapString(errstr, 0);
|
||||
ShowPrompt(false, "Error during loading:\n%s", errstr);
|
||||
return false;
|
||||
}
|
||||
|
||||
if (lua_pcall(L, 0, LUA_MULTRET, 0) != LUA_OK) {
|
||||
char errstr[BUFSIZ] = {0};
|
||||
strlcpy(errstr, lua_tostring(L, -1), BUFSIZ);
|
||||
WordWrapString(errstr, 0);
|
||||
ShowPrompt(false, "Error during execution:\n%s", errstr);
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
// this is also taken from scripting.c
|
||||
static inline bool isntrboot(void) {
|
||||
// taken over from Luma 3DS:
|
||||
// https://github.com/AuroraWright/Luma3DS/blob/bb5518b0f68d89bcd8efaf326355a770d5e57856/source/main.c#L58-L62
|
||||
const vu8 *bootMediaStatus = (const vu8 *) 0x1FFFE00C;
|
||||
const vu32 *bootPartitionsStatus = (const vu32 *) 0x1FFFE010;
|
||||
|
||||
// shell closed, no error booting NTRCARD, NAND partitions not even considered
|
||||
return (bootMediaStatus[3] == 2) && !bootMediaStatus[1] && !bootPartitionsStatus[0] && !bootPartitionsStatus[1];
|
||||
}
|
||||
|
||||
bool ExecuteLuaScript(const char* path_script) {
|
||||
lua_State* L = luaL_newstate();
|
||||
loadlibs(L);
|
||||
|
||||
ResetPackageSearchersAndPath(L);
|
||||
ClearOutputBuffer();
|
||||
|
||||
// current path
|
||||
char curr_dir[_VAR_CNT_LEN];
|
||||
if (path_script) {
|
||||
strncpy(curr_dir, path_script, _VAR_CNT_LEN);
|
||||
curr_dir[_VAR_CNT_LEN-1] = '\0';
|
||||
char* slash = strrchr(curr_dir, '/');
|
||||
if (slash) *slash = '\0';
|
||||
|
||||
lua_pushstring(L, curr_dir);
|
||||
} else {
|
||||
lua_pushnil(L);
|
||||
}
|
||||
lua_setglobal(L, "CURRDIR");
|
||||
|
||||
lua_pushliteral(L, VERSION);
|
||||
lua_setglobal(L, "GM9VER");
|
||||
|
||||
lua_pushstring(L, path_script);
|
||||
lua_setglobal(L, "SCRIPT");
|
||||
|
||||
lua_pushliteral(L, OUTPUT_PATH);
|
||||
lua_setglobal(L, "GM9OUT");
|
||||
|
||||
lua_pushstring(L, IS_UNLOCKED ? (isntrboot() ? "ntrboot" : "sighax") : "");
|
||||
lua_setglobal(L, "HAX");
|
||||
|
||||
lua_pushinteger(L, GetNandSizeSectors(NAND_SYSNAND) * 0x200);
|
||||
lua_setglobal(L, "NANDSIZE");
|
||||
|
||||
lua_pushboolean(L, IS_DEVKIT);
|
||||
lua_setglobal(L, "IS_DEVKIT");
|
||||
|
||||
lua_pushstring(L, IS_O3DS ? "O3DS" : "N3DS");
|
||||
lua_setglobal(L, "CONSOLE_TYPE");
|
||||
|
||||
bool result = RunFile(L, "V:/preload.lua");
|
||||
if (!result) {
|
||||
ShowPrompt(false, "A fatal error happened in GodMode9's preload script.\n \nThis is not an error with your code, but with\nGodMode9. Please report it on GitHub.");
|
||||
lua_close(L);
|
||||
return false;
|
||||
}
|
||||
|
||||
RunFile(L, path_script);
|
||||
|
||||
lua_close(L);
|
||||
return true;
|
||||
}
|
||||
#else
|
||||
// No-Lua version
|
||||
bool ExecuteLuaScript(const char* path_script) {
|
||||
(void)path_script; // unused
|
||||
ShowPrompt(false, "%s", STR_LUA_NOT_INCLUDED);
|
||||
return false;
|
||||
}
|
||||
#endif
|
||||
@ -1,47 +0,0 @@
|
||||
#pragma once
|
||||
#include "common.h"
|
||||
#include "lua.h"
|
||||
#include "lauxlib.h"
|
||||
#include "lualib.h"
|
||||
#include "scripting.h"
|
||||
|
||||
// this should probably go in filesys/fsutil.h
|
||||
#define RECURSIVE (1UL<<11)
|
||||
#define TO_EMUNAND (1UL<<12)
|
||||
#define LEGIT (1UL<<13)
|
||||
#define FIND_FIRST (1UL<<14)
|
||||
#define INCLUDE_DIRS (1UL<<15)
|
||||
#define EXPLORER (1UL<<16)
|
||||
#define ENCRYPTED (1UL<<17)
|
||||
|
||||
#define FLAGS_STR "no_cancel", "silent", "calc_sha", "sha1", "skip", "overwrite", "append", "all", "recursive", "to_emunand", "legit", "first", "include_dirs", "explorer", "encrypted"
|
||||
#define FLAGS_CONSTS NO_CANCEL, SILENT, CALC_SHA, USE_SHA1, SKIP_ALL, OVERWRITE_ALL, APPEND_ALL, ASK_ALL, RECURSIVE, TO_EMUNAND, LEGIT, FIND_FIRST, INCLUDE_DIRS, EXPLORER, ENCRYPTED
|
||||
#define FLAGS_COUNT 15
|
||||
|
||||
#define LUASCRIPT_EXT "lua"
|
||||
#define LUASCRIPT_MAX_SIZE STD_BUFFER_SIZE
|
||||
|
||||
// taken from arm9/source/utils/scripting.c
|
||||
#define _VAR_CNT_LEN 256
|
||||
|
||||
#ifndef NO_LUA
|
||||
static inline void CheckLuaArgCount(lua_State* L, int argcount, const char* cmd) {
|
||||
int args = lua_gettop(L);
|
||||
if (args != argcount) {
|
||||
luaL_error(L, "bad number of arguments passed to '%s' (expected %d, got %d)", cmd, argcount, args);
|
||||
}
|
||||
}
|
||||
// this is used in cases where a function accepts a flags table or something else
|
||||
static inline bool CheckLuaArgCountPlusExtra(lua_State* L, int argcount, const char* cmd) {
|
||||
int args = lua_gettop(L);
|
||||
if (args != argcount && args != argcount + 1) {
|
||||
luaL_error(L, "bad number of arguments passed to '%s' (expected %d or %d, got %d)", cmd, argcount, argcount + 1, args);
|
||||
}
|
||||
return args == argcount + 1;
|
||||
}
|
||||
|
||||
int LoadLuaFile(lua_State* L, const char* filename);
|
||||
u32 GetFlagsFromTable(lua_State* L, int pos, u32 flags_ext_starter, u32 allowed_flags);
|
||||
void CheckWritePermissionsLuaError(lua_State* L, const char* path);
|
||||
#endif
|
||||
bool ExecuteLuaScript(const char* path_script);
|
||||
@ -1,686 +0,0 @@
|
||||
#ifndef NO_LUA
|
||||
#include "gm9os.h"
|
||||
#include "timer.h"
|
||||
#include "rtc.h"
|
||||
#include "ui.h"
|
||||
|
||||
u64 osclock;
|
||||
|
||||
static inline bool isLeapYear(u32 year) {
|
||||
return (year % 4 == 0 && (year % 100 != 0 || year % 400 == 0));
|
||||
}
|
||||
|
||||
size_t getWeekday(bool abbreviated, char* out, u8 weekday) {
|
||||
if (abbreviated) {
|
||||
switch(weekday) {
|
||||
case 1:
|
||||
strcat(out, "Mon");
|
||||
break;
|
||||
case 2:
|
||||
strcat(out, "Tue");
|
||||
break;
|
||||
case 3:
|
||||
strcat(out, "Wed");
|
||||
break;
|
||||
case 4:
|
||||
strcat(out, "Thu");
|
||||
break;
|
||||
case 5:
|
||||
strcpy(out, "Fri");
|
||||
break;
|
||||
case 6:
|
||||
strcat(out, "Sat");
|
||||
break;
|
||||
case 0:
|
||||
case 7:
|
||||
strcat(out, "Sun");
|
||||
break;
|
||||
default:
|
||||
strcat(out, "");
|
||||
return 0;
|
||||
}
|
||||
return 3;
|
||||
}
|
||||
switch(weekday) {
|
||||
case 1:
|
||||
strcat(out, "Monday");
|
||||
return 6;
|
||||
case 2:
|
||||
strcat(out, "Tuesday");
|
||||
return 7;
|
||||
case 3:
|
||||
strcat(out, "Wednesday");
|
||||
return 9;
|
||||
case 4:
|
||||
strcat(out, "Thursday");
|
||||
return 8;
|
||||
case 5:
|
||||
strcpy(out, "Friday");
|
||||
return 6;
|
||||
case 6:
|
||||
strcat(out, "Saturday");
|
||||
return 8;
|
||||
case 7:
|
||||
case 0:
|
||||
strcat(out, "Sunday");
|
||||
return 6;
|
||||
default:
|
||||
strcat(out, "");
|
||||
return 0;
|
||||
}
|
||||
return 0;
|
||||
|
||||
}
|
||||
|
||||
size_t getMonthName(bool abbreviated, char* out, u8 month) {
|
||||
if (abbreviated) {
|
||||
switch(month) {
|
||||
case 1:
|
||||
strcat(out, "Jan");
|
||||
break;
|
||||
case 2:
|
||||
strcat(out, "Feb");
|
||||
break;
|
||||
case 3:
|
||||
strcat(out, "Mar");
|
||||
break;
|
||||
case 4:
|
||||
strcat(out, "Apr");
|
||||
break;
|
||||
case 5:
|
||||
strcat(out, "May");
|
||||
break;
|
||||
case 6:
|
||||
strcat(out, "Jun");
|
||||
break;
|
||||
case 7:
|
||||
strcat(out, "Jul");
|
||||
break;
|
||||
case 8:
|
||||
strcat(out, "Aug");
|
||||
break;
|
||||
case 9:
|
||||
strcat(out, "Sep");
|
||||
break;
|
||||
case 10:
|
||||
strcat(out, "Oct");
|
||||
break;
|
||||
case 11:
|
||||
strcat(out, "Nov");
|
||||
break;
|
||||
case 12:
|
||||
strcat(out, "Dec");
|
||||
break;
|
||||
default:
|
||||
strcat(out, "");
|
||||
return 0;
|
||||
}
|
||||
return 3;
|
||||
}
|
||||
switch(month) {
|
||||
case 1:
|
||||
strcat(out, "January");
|
||||
return 7;
|
||||
case 2:
|
||||
strcat(out, "February");
|
||||
return 8;
|
||||
case 3:
|
||||
strcat(out, "March");
|
||||
return 5;
|
||||
case 4:
|
||||
strcat(out, "April");
|
||||
return 5;
|
||||
case 5:
|
||||
strcat(out, "May");
|
||||
return 3;
|
||||
case 6:
|
||||
strcat(out, "Juny");
|
||||
return 4;
|
||||
case 7:
|
||||
strcat(out, "July");
|
||||
return 4;
|
||||
case 8:
|
||||
strcat(out, "August");
|
||||
return 6;
|
||||
case 9:
|
||||
strcat(out, "September");
|
||||
return 9;
|
||||
case 10:
|
||||
strcat(out, "October");
|
||||
return 7;
|
||||
case 11:
|
||||
strcat(out, "November");
|
||||
return 8;
|
||||
case 12:
|
||||
strcat(out, "December");
|
||||
return 8;
|
||||
default:
|
||||
strcat(out, "");
|
||||
return 0;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
u16 getDaysMonths(u32 months, u8 years) {
|
||||
u8 daysInMonth[12] = {31, isLeapYear(2000 + years) ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}; //is this ?: bad practice?
|
||||
u16 ret;
|
||||
for (u32 month = 0; month < months - 1; month++) {
|
||||
ret += daysInMonth[month];
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
u64 calcUnixTime(u8 years, u8 months, u8 days, u8 hours, u8 minutes, u8 seconds) {
|
||||
u8 daysInMonth[12] = {31, isLeapYear(2000 + years) ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}; //is this ?: bad practice?
|
||||
u32 curdays;
|
||||
u64 ret = 0;
|
||||
|
||||
ret += seconds;
|
||||
ret += minutes * 60;
|
||||
ret += hours * 60 * 60;
|
||||
ret += (days - 1) * 24 * 60 * 60;
|
||||
|
||||
for (u16 year = 0; year < years + 30; year++) { //+30 because unix time starting in 1970 but rtc starts in 2000
|
||||
if (isLeapYear(2000 + year)) {
|
||||
curdays = 366;
|
||||
} else {
|
||||
curdays = 365;
|
||||
}
|
||||
ret += curdays * 24 * 60 * 60;
|
||||
}
|
||||
|
||||
for (u16 month = 0; month < months - 1; month++) {
|
||||
ret += daysInMonth[month] * 24 * 60 * 60;
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
u64 getUnixTimeFromRtc(DsTime *dstime) {
|
||||
|
||||
u8
|
||||
seconds = DSTIMEGET(dstime, bcd_s),
|
||||
minutes = DSTIMEGET(dstime, bcd_m),
|
||||
hours = DSTIMEGET(dstime, bcd_h),
|
||||
days = DSTIMEGET(dstime, bcd_D),
|
||||
months = DSTIMEGET(dstime, bcd_M),
|
||||
years = DSTIMEGET(dstime, bcd_Y);
|
||||
return calcUnixTime(years, months, days, hours, minutes, seconds);
|
||||
|
||||
}
|
||||
|
||||
u64 timer_usec( u64 start_time ) {
|
||||
return timer_ticks( start_time ) / (TICKS_PER_SEC/1000000);
|
||||
}
|
||||
|
||||
void weekdayfix(DsTime *dstime) {
|
||||
int days = getUnixTimeFromRtc(dstime) / 86400; //days since thursday 1 1 1970
|
||||
u8 weekday = (days + 5) % 7;
|
||||
dstime->weekday = NUM2BCD(weekday);
|
||||
}
|
||||
|
||||
void unixtodstime(u64 unixtime, DsTime *dstime) {
|
||||
u32 seconds, minutes, hours, days, year, month;
|
||||
seconds = unixtime;
|
||||
minutes = seconds / 60;
|
||||
seconds %= 60;
|
||||
hours = minutes / 60;
|
||||
minutes %= 60;
|
||||
days = hours / 24;
|
||||
hours %= 24;
|
||||
year = 1970;
|
||||
|
||||
while(true)
|
||||
{
|
||||
bool leapYear = (year % 4 == 0 && (year % 100 != 0 || year % 400 == 0));
|
||||
u16 daysInYear = leapYear ? 366 : 365;
|
||||
if(days >= daysInYear)
|
||||
{
|
||||
days -= daysInYear;
|
||||
++year;
|
||||
}
|
||||
else
|
||||
{
|
||||
static const u8 daysInMonth[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
|
||||
for(month = 0; month < 12; ++month)
|
||||
{
|
||||
u8 dim = daysInMonth[month];
|
||||
|
||||
if (month == 1 && leapYear)
|
||||
++dim;
|
||||
|
||||
if (days >= dim)
|
||||
days -= dim;
|
||||
else
|
||||
break;
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
days++;
|
||||
month++;
|
||||
u8 bcd_year = year-2000;
|
||||
dstime->bcd_Y = NUM2BCD(bcd_year);
|
||||
dstime->bcd_M = NUM2BCD(month);
|
||||
dstime->bcd_D = NUM2BCD(days);
|
||||
dstime->bcd_h = NUM2BCD(hours);
|
||||
dstime->bcd_m = NUM2BCD(minutes);
|
||||
dstime->bcd_s = NUM2BCD(seconds);
|
||||
dstime->weekday = 0;
|
||||
}
|
||||
|
||||
bool my_strftime(char* _out, size_t _maxsize, const char* str, DsTime *dstime) { //my refers to github.com/Gruetzig
|
||||
weekdayfix(dstime);
|
||||
size_t strl = strlen(str);
|
||||
size_t outpos = 0;
|
||||
char out[_maxsize+10];
|
||||
memset(out, 0, _maxsize+10);
|
||||
u8 minute, hour, day, month, year, weekday, second, weeknumber;
|
||||
u16 currentday, nextsunday, fyear;
|
||||
char numbuf[3], numbuf2[5], numbuf3[9], numnum1[3], numnum2[3], numnum3[3];
|
||||
if (!is_valid_dstime(dstime)) {
|
||||
return false;
|
||||
}
|
||||
for (size_t i = 0;i<strl;i++) {
|
||||
if (str[i] == '%') {
|
||||
i++;
|
||||
switch(str[i]) {
|
||||
case 'a':
|
||||
outpos += getWeekday(true, out, DSTIMEGET(dstime, weekday));
|
||||
break;
|
||||
case 'A':
|
||||
outpos += getWeekday(false, out, DSTIMEGET(dstime, weekday));
|
||||
break;
|
||||
case 'b':
|
||||
outpos += getMonthName(true, out, DSTIMEGET(dstime, bcd_M));
|
||||
break;
|
||||
case 'B':
|
||||
outpos += getMonthName(false, out, DSTIMEGET(dstime, bcd_M));
|
||||
break;
|
||||
case 'c':
|
||||
char buf[100];
|
||||
my_strftime(buf, _maxsize-outpos-10, "%a %b %d %X %Y", dstime);
|
||||
strcat(out, buf);
|
||||
outpos += strlen(buf);
|
||||
break;
|
||||
case 'd':
|
||||
day = DSTIMEGET(dstime, bcd_D);
|
||||
if (day < 10) {
|
||||
sprintf(numbuf, "0%d", day);
|
||||
} else {
|
||||
sprintf(numbuf, "%d", day);
|
||||
}
|
||||
strcat(out, numbuf);
|
||||
outpos += 2;
|
||||
break;
|
||||
case 'H':
|
||||
hour = DSTIMEGET(dstime, bcd_h);
|
||||
if (day < 10) {
|
||||
sprintf(numbuf, "0%d", hour);
|
||||
} else {
|
||||
sprintf(numbuf, "%d", hour);
|
||||
}
|
||||
strcat(out, numbuf);
|
||||
outpos += 2;
|
||||
break;
|
||||
case 'I':
|
||||
hour = DSTIMEGET(dstime, bcd_h);
|
||||
if (hour > 12) {
|
||||
hour = hour - 12;
|
||||
}
|
||||
if (!hour) {
|
||||
hour = 12;
|
||||
}
|
||||
if (hour < 10) {
|
||||
sprintf(numbuf, "0%d", hour);
|
||||
} else {
|
||||
sprintf(numbuf, "%d", hour);
|
||||
}
|
||||
strcat(out, numbuf);
|
||||
outpos += 2;
|
||||
break;
|
||||
case 'j':
|
||||
currentday = getDaysMonths(DSTIMEGET(dstime, bcd_M), DSTIMEGET(dstime, bcd_Y))+DSTIMEGET(dstime, bcd_D);
|
||||
if (currentday < 10) {
|
||||
sprintf(numbuf, "00%d", currentday);
|
||||
} else if (currentday < 100) {
|
||||
sprintf(numbuf, "0%d", currentday);
|
||||
} else {
|
||||
sprintf(numbuf, "%d", currentday);
|
||||
}
|
||||
strcat(out, numbuf);
|
||||
outpos += 3;
|
||||
break;
|
||||
case 'm':
|
||||
month = DSTIMEGET(dstime, bcd_M);
|
||||
if (month < 10) {
|
||||
sprintf(numbuf, "0%d", month);
|
||||
} else {
|
||||
sprintf(numbuf, "%d", month);
|
||||
}
|
||||
strcat(out, numbuf);
|
||||
outpos += 2;
|
||||
break;
|
||||
case 'M':
|
||||
minute = DSTIMEGET(dstime, bcd_m);
|
||||
if (minute < 10) {
|
||||
sprintf(numbuf, "0%d", minute);
|
||||
} else {
|
||||
sprintf(numbuf, "%d", minute);
|
||||
}
|
||||
strcat(out, numbuf);
|
||||
outpos += 2;
|
||||
break;
|
||||
case 'p':
|
||||
hour = DSTIMEGET(dstime, bcd_h);
|
||||
if (hour >= 12) {
|
||||
strcat(out, "PM");
|
||||
} else {
|
||||
strcat(out, "AM");
|
||||
}
|
||||
outpos += 2;
|
||||
break;
|
||||
case 'S':
|
||||
second = DSTIMEGET(dstime, bcd_m);
|
||||
if (second < 10) {
|
||||
sprintf(numbuf, "0%d", second);
|
||||
} else {
|
||||
sprintf(numbuf, "%d", second);
|
||||
}
|
||||
strcat(out, numbuf);
|
||||
outpos += 2;
|
||||
break;
|
||||
case 'U':
|
||||
currentday = getDaysMonths(DSTIMEGET(dstime, bcd_M), DSTIMEGET(dstime, bcd_Y))+DSTIMEGET(dstime, bcd_D);
|
||||
weekday = DSTIMEGET(dstime, weekday);
|
||||
nextsunday = ((7-weekday)+currentday);
|
||||
weeknumber = (nextsunday/7)+1;
|
||||
if (weeknumber < 10) {
|
||||
sprintf(numbuf, "0%d", weeknumber);
|
||||
} else {
|
||||
sprintf(numbuf, "%d", weeknumber);
|
||||
}
|
||||
strcat(out, numbuf);
|
||||
outpos += 2;
|
||||
break;
|
||||
case 'w':
|
||||
weekday = DSTIMEGET(dstime, weekday);
|
||||
if (weekday == 7) {
|
||||
weekday = 0;
|
||||
}
|
||||
sprintf(out, "%d", weekday);
|
||||
strcat(out, numbuf);
|
||||
outpos++;
|
||||
break;
|
||||
case 'W':
|
||||
currentday = getDaysMonths(DSTIMEGET(dstime, bcd_M), DSTIMEGET(dstime, bcd_Y))+DSTIMEGET(dstime, bcd_D);
|
||||
weekday = DSTIMEGET(dstime, weekday);
|
||||
nextsunday = ((8-weekday)+currentday);
|
||||
weeknumber = (nextsunday/7);
|
||||
if (weeknumber < 10) {
|
||||
sprintf(numbuf, "0%d", weeknumber);
|
||||
} else {
|
||||
sprintf(numbuf, "%d", weeknumber);
|
||||
}
|
||||
strcat(out, numbuf);
|
||||
outpos += 2;
|
||||
break;
|
||||
case 'x':
|
||||
month = DSTIMEGET(dstime, bcd_M);
|
||||
day = DSTIMEGET(dstime, bcd_D);
|
||||
year = DSTIMEGET(dstime, bcd_Y);
|
||||
|
||||
if (month < 10) {
|
||||
sprintf(numnum1, "0%d", month);
|
||||
} else {
|
||||
sprintf(numnum1, "%d", month);
|
||||
}
|
||||
|
||||
if (day < 10) {
|
||||
sprintf(numnum2, "0%d", day);
|
||||
} else {
|
||||
sprintf(numnum2, "%d", day);
|
||||
}
|
||||
|
||||
if (year < 10) {
|
||||
sprintf(numnum3, "0%d", year);
|
||||
} else {
|
||||
sprintf(numnum3, "%d", year);
|
||||
}
|
||||
sprintf(numbuf3, "%s/%s/%s", numnum1, numnum2, numnum3);
|
||||
strcat(out, numbuf3);
|
||||
outpos += 8;
|
||||
break;
|
||||
case 'X':
|
||||
hour = DSTIMEGET(dstime, bcd_h);
|
||||
minute = DSTIMEGET(dstime, bcd_m);
|
||||
second = DSTIMEGET(dstime, bcd_s);
|
||||
|
||||
if (hour < 10) {
|
||||
sprintf(numnum1, "0%d", hour);
|
||||
} else {
|
||||
sprintf(numnum1, "%d", hour);
|
||||
}
|
||||
|
||||
if (minute < 10) {
|
||||
sprintf(numnum2, "0%d", minute);
|
||||
} else {
|
||||
sprintf(numnum2, "%d", minute);
|
||||
}
|
||||
|
||||
if (second < 10) {
|
||||
sprintf(numnum3, "0%d", second);
|
||||
} else {
|
||||
sprintf(numnum3, "%d", second);
|
||||
}
|
||||
sprintf(numbuf3, "%s:%s:%s", numnum1, numnum2, numnum3);
|
||||
strcat(out, numbuf3);
|
||||
outpos += 8;
|
||||
break;
|
||||
case 'y':
|
||||
year = DSTIMEGET(dstime, bcd_Y);
|
||||
if (year < 10) {
|
||||
sprintf(numbuf, "0%d", year);
|
||||
} else {
|
||||
sprintf(numbuf, "%d", year);
|
||||
}
|
||||
strcat(out, numbuf);
|
||||
outpos += 2;
|
||||
break;
|
||||
case 'Y':
|
||||
fyear = DSTIMEGET(dstime, bcd_Y);
|
||||
fyear += 2000;
|
||||
sprintf(numbuf2, "%d", fyear);
|
||||
strcat(out, numbuf2);
|
||||
outpos += 4;
|
||||
break;
|
||||
case '%':
|
||||
strcat(out, "%");
|
||||
outpos++;
|
||||
break;
|
||||
default:
|
||||
break; //not implemented
|
||||
|
||||
|
||||
}
|
||||
|
||||
} else {
|
||||
out[outpos] = str[i];
|
||||
outpos++;
|
||||
}
|
||||
if (outpos > _maxsize) {
|
||||
break;
|
||||
}
|
||||
|
||||
}
|
||||
strncpy(_out, out, _maxsize);
|
||||
return true;
|
||||
}
|
||||
|
||||
static int os_time(lua_State *L) {
|
||||
int args = lua_gettop(L);
|
||||
u64 unixtime;
|
||||
switch(args) {
|
||||
case 0:
|
||||
DsTime dstime;
|
||||
get_dstime(&dstime);
|
||||
unixtime = getUnixTimeFromRtc(&dstime);
|
||||
lua_pushinteger(L, unixtime);
|
||||
return 1;
|
||||
case 1:
|
||||
lua_geti(L, 1, 1);
|
||||
int year = lua_tointeger(L, -1);
|
||||
lua_pop(L, 1);
|
||||
if (year >= 2000) year -= 2000;
|
||||
|
||||
lua_geti(L, 1, 2);
|
||||
int month = lua_tointeger(L, -1);
|
||||
lua_pop(L, 1);
|
||||
|
||||
lua_geti(L, 1, 3);
|
||||
int day = lua_tointeger(L, -1);
|
||||
lua_pop(L, 1);
|
||||
|
||||
lua_geti(L, 1, 4);
|
||||
int hour = lua_tointeger(L, -1);
|
||||
lua_pop(L, 1);
|
||||
|
||||
lua_geti(L, 1, 5);
|
||||
int minute = lua_tointeger(L, -1);
|
||||
lua_pop(L, 1);
|
||||
|
||||
lua_geti(L, 1, 6);
|
||||
int second = lua_tointeger(L, -1);
|
||||
lua_pop(L, 1);
|
||||
|
||||
lua_pushinteger(L, calcUnixTime(year, month, day, hour, minute, second));
|
||||
|
||||
return 1;
|
||||
default:
|
||||
return luaL_error(L, "not a valid amount of arguments");
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
static int os_date(lua_State *L) {
|
||||
DsTime dstime;
|
||||
|
||||
get_dstime(&dstime);
|
||||
char retbuf[100];
|
||||
memset(retbuf, 0, 100);
|
||||
int args = lua_gettop(L);
|
||||
switch(args) {
|
||||
case 0:
|
||||
my_strftime(retbuf, 100, "%c", &dstime);
|
||||
lua_pushstring(L, retbuf);
|
||||
return 1;
|
||||
case 1:
|
||||
const char* str = lua_tostring(L, 1);
|
||||
if ((strcmp(str, "*t") == 0 || strcmp(str, "!*t") == 0)) {
|
||||
weekdayfix(&dstime);
|
||||
//return table with date values
|
||||
lua_newtable(L);
|
||||
//year
|
||||
lua_pushinteger(L, 2000+DSTIMEGET(&dstime, bcd_Y));
|
||||
lua_setfield(L, -2, "year");
|
||||
//month
|
||||
lua_pushinteger(L, DSTIMEGET(&dstime, bcd_M));
|
||||
lua_setfield(L, -2, "month");
|
||||
//wday (weekday)
|
||||
lua_pushinteger(L, DSTIMEGET(&dstime, weekday));
|
||||
lua_setfield(L, -2, "wday");
|
||||
//yday (yearday)
|
||||
lua_pushinteger(L, getDaysMonths(DSTIMEGET(&dstime, bcd_M), DSTIMEGET(&dstime, bcd_Y))+DSTIMEGET(&dstime, bcd_D));
|
||||
lua_setfield(L, -2, "yday");
|
||||
//day
|
||||
lua_pushinteger(L, DSTIMEGET(&dstime, bcd_D));
|
||||
lua_setfield(L, -2, "day");
|
||||
//hour
|
||||
lua_pushinteger(L, DSTIMEGET(&dstime, bcd_h));
|
||||
lua_setfield(L, -2, "hour");
|
||||
//minute
|
||||
lua_pushinteger(L, DSTIMEGET(&dstime, bcd_m));
|
||||
lua_setfield(L, -2, "min");
|
||||
//second
|
||||
lua_pushinteger(L, DSTIMEGET(&dstime, bcd_s));
|
||||
lua_setfield(L, -2, "sec");
|
||||
return 1;
|
||||
} else {
|
||||
my_strftime(retbuf, 100, lua_tostring(L, 1), &dstime);
|
||||
lua_pushstring(L, retbuf);
|
||||
return 1;
|
||||
}
|
||||
case 2:
|
||||
if (lua_tointeger(L, 2) < 946684800) { //unix timestamp is 01.01.2000 00:00:00, so everything before is previous century and not supported
|
||||
return luaL_error(L, "unix timestamp from before 2000 is not supported");
|
||||
}
|
||||
const char* str2 = lua_tostring(L, 1);
|
||||
if ((strcmp(str2, "*t") == 0 || strcmp(str2, "!*t") == 0)) {
|
||||
unixtodstime( lua_tointeger(L, 2) , &dstime);
|
||||
weekdayfix(&dstime);
|
||||
//return table with date values
|
||||
lua_newtable(L);
|
||||
//year
|
||||
lua_pushinteger(L, 2000+DSTIMEGET(&dstime, bcd_Y));
|
||||
lua_setfield(L, -2, "year");
|
||||
//month
|
||||
lua_pushinteger(L, DSTIMEGET(&dstime, bcd_M));
|
||||
lua_setfield(L, -2, "month");
|
||||
//wday (weekday)
|
||||
lua_pushinteger(L, DSTIMEGET(&dstime, weekday));
|
||||
lua_setfield(L, -2, "wday");
|
||||
//yday (yearday)
|
||||
lua_pushinteger(L, getDaysMonths(DSTIMEGET(&dstime, bcd_M), DSTIMEGET(&dstime, bcd_Y))+DSTIMEGET(&dstime, bcd_D));
|
||||
lua_setfield(L, -2, "yday");
|
||||
//day
|
||||
lua_pushinteger(L, DSTIMEGET(&dstime, bcd_D));
|
||||
lua_setfield(L, -2, "day");
|
||||
//hour
|
||||
lua_pushinteger(L, DSTIMEGET(&dstime, bcd_h));
|
||||
lua_setfield(L, -2, "hour");
|
||||
//minute
|
||||
lua_pushinteger(L, DSTIMEGET(&dstime, bcd_m));
|
||||
lua_setfield(L, -2, "min");
|
||||
//second
|
||||
lua_pushinteger(L, DSTIMEGET(&dstime, bcd_s));
|
||||
lua_setfield(L, -2, "sec");
|
||||
return 1;
|
||||
} else {
|
||||
unixtodstime( lua_tointeger(L, 2) , &dstime);
|
||||
my_strftime(retbuf, 100, str2, &dstime);
|
||||
lua_pushstring(L, retbuf);
|
||||
return 1;
|
||||
}
|
||||
|
||||
default:
|
||||
return luaL_error(L, "not a valid amount of arguments");
|
||||
}
|
||||
}
|
||||
|
||||
static int os_clock(lua_State *L) {
|
||||
lua_pushnumber(L, timer_usec(osclock)/10000000.0);
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int os_difftime(lua_State *L) {
|
||||
u64 t2 = lua_tointeger(L, 1);
|
||||
u64 t1 = lua_tointeger(L, 2);
|
||||
lua_pushinteger(L, t2-t1);
|
||||
return 1;
|
||||
}
|
||||
|
||||
// os.remove and os.rename are done in data/luapackages/fs.lua
|
||||
static const luaL_Reg os[] = {
|
||||
{"clock", os_clock},
|
||||
{"time", os_time},
|
||||
{"date", os_date},
|
||||
{"difftime", os_difftime},
|
||||
{NULL, NULL}
|
||||
};
|
||||
|
||||
int gm9lua_open_os(lua_State* L) {
|
||||
luaL_newlib(L, os);
|
||||
osclock = timer_start();
|
||||
return 1;
|
||||
}
|
||||
#endif
|
||||
@ -1,6 +0,0 @@
|
||||
#pragma once
|
||||
#include "gm9lua.h"
|
||||
|
||||
#define GM9LUA_OSLIBNAME "os"
|
||||
|
||||
int gm9lua_open_os(lua_State* L);
|
||||
@ -1,183 +0,0 @@
|
||||
#ifndef NO_LUA
|
||||
#include "gm9lua.h"
|
||||
#include "utils.h"
|
||||
#include "fs.h"
|
||||
#include "language.h"
|
||||
#include "ui.h"
|
||||
#include "game.h"
|
||||
#include "ips.h"
|
||||
#include "bps.h"
|
||||
|
||||
static int title_decrypt(lua_State* L) {
|
||||
CheckLuaArgCount(L, 1, "title.decrypt");
|
||||
const char* path = luaL_checkstring(L, 1);
|
||||
const char* whichfailed = "";
|
||||
|
||||
u64 filetype = IdentifyFileType(path);
|
||||
bool ret;
|
||||
if (filetype & BIN_KEYDB) {
|
||||
ret = (CryptAesKeyDb(path, true, false) == 0);
|
||||
whichfailed = "CryptAesKeyDb";
|
||||
} else {
|
||||
ret = (CryptGameFile(path, true, false) == 0);
|
||||
whichfailed = "CryptGameFile";
|
||||
}
|
||||
|
||||
if (!ret) {
|
||||
return luaL_error(L, "%s failed on %s", whichfailed, path);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int title_encrypt(lua_State* L) {
|
||||
CheckLuaArgCount(L, 1, "title.encrypt");
|
||||
const char* path = luaL_checkstring(L, 1);
|
||||
const char* whichfailed = "";
|
||||
|
||||
u64 filetype = IdentifyFileType(path);
|
||||
bool ret;
|
||||
if (filetype & BIN_KEYDB) {
|
||||
ret = (CryptAesKeyDb(path, true, true) == 0);
|
||||
whichfailed = "CryptAesKeyDb";
|
||||
} else {
|
||||
ret = (CryptGameFile(path, true, true) == 0);
|
||||
whichfailed = "CryptGameFile";
|
||||
}
|
||||
|
||||
if (!ret) {
|
||||
return luaL_error(L, "%s failed on %s", whichfailed, path);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int title_install(lua_State* L) {
|
||||
bool extra = CheckLuaArgCountPlusExtra(L, 1, "title.install");
|
||||
const char* path = luaL_checkstring(L, 1);
|
||||
|
||||
u32 flags = 0;
|
||||
if (extra) {
|
||||
flags = GetFlagsFromTable(L, 2, flags, TO_EMUNAND);
|
||||
};
|
||||
|
||||
bool ret = (InstallGameFile(path, (flags & TO_EMUNAND)) == 0);
|
||||
if (!ret) {
|
||||
return luaL_error(L, "InstallGameFile failed on %s", path);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int title_build_cia(lua_State* L) {
|
||||
bool extra = CheckLuaArgCountPlusExtra(L, 1, "title.build_cia");
|
||||
const char* path = luaL_checkstring(L, 1);
|
||||
|
||||
u32 flags = 0;
|
||||
if (extra) {
|
||||
flags = GetFlagsFromTable(L, 2, flags, LEGIT);
|
||||
};
|
||||
|
||||
bool ret = (BuildCiaFromGameFile(path, (flags & LEGIT)) == 0);
|
||||
if (!ret) {
|
||||
return luaL_error(L, "BuildCiaFromGameFile failed on %s", path);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int title_extract_code(lua_State* L) {
|
||||
CheckLuaArgCount(L, 2, "title.extract_code");
|
||||
const char* path_src = luaL_checkstring(L, 1);
|
||||
const char* path_dst = luaL_checkstring(L, 2);
|
||||
|
||||
u64 filetype = IdentifyFileType(path_src);
|
||||
if (!FTYPE_HASCODE(filetype)) {
|
||||
return luaL_error(L, "%s does not have code", path_src);
|
||||
} else {
|
||||
CheckWritePermissionsLuaError(L, path_dst);
|
||||
ShowString("%s", STR_EXTRACTING_DOT_CODE);
|
||||
bool ret = (ExtractCodeFromCxiFile(path_src, path_dst, NULL) == 0);
|
||||
if (!ret) {
|
||||
return luaL_error(L, "failed to extract code from %s", path_src);
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int title_compress_code(lua_State* L) {
|
||||
CheckLuaArgCount(L, 2, "title.compress_code");
|
||||
const char* path_src = luaL_checkstring(L, 1);
|
||||
const char* path_dst = luaL_checkstring(L, 2);
|
||||
|
||||
CheckWritePermissionsLuaError(L, path_dst);
|
||||
ShowString("%s", STR_COMPRESSING_DOT_CODE);
|
||||
bool ret = (CompressCode(path_src, path_dst) == 0);
|
||||
if (!ret) {
|
||||
return luaL_error(L, "failed to compress code from %s", path_src);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int title_apply_ips(lua_State* L) {
|
||||
CheckLuaArgCount(L, 3, "title.apply_ips");
|
||||
const char* path_patch = luaL_checkstring(L, 1);
|
||||
const char* path_src = luaL_checkstring(L, 2);
|
||||
const char* path_target = luaL_checkstring(L, 3);
|
||||
|
||||
bool ret = (ApplyIPSPatch(path_patch, path_src, path_target) == 0);
|
||||
if (!ret) {
|
||||
return luaL_error(L, "ApplyIPSPatch failed");
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int title_apply_bps(lua_State* L) {
|
||||
CheckLuaArgCount(L, 3, "title.apply_bps");
|
||||
const char* path_patch = luaL_checkstring(L, 1);
|
||||
const char* path_src = luaL_checkstring(L, 2);
|
||||
const char* path_target = luaL_checkstring(L, 3);
|
||||
|
||||
bool ret = (ApplyBPSPatch(path_patch, path_src, path_target) == 0);
|
||||
if (!ret) {
|
||||
return luaL_error(L, "ApplyBPSPatch failed");
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int title_apply_bpm(lua_State* L) {
|
||||
CheckLuaArgCount(L, 3, "title.apply_bpm");
|
||||
const char* path_patch = luaL_checkstring(L, 1);
|
||||
const char* path_src = luaL_checkstring(L, 2);
|
||||
const char* path_target = luaL_checkstring(L, 3);
|
||||
|
||||
bool ret = (ApplyBPMPatch(path_patch, path_src, path_target) == 0);
|
||||
if (!ret) {
|
||||
return luaL_error(L, "ApplyBPMPatch failed");
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static const luaL_Reg title_lib[] = {
|
||||
{"decrypt", title_decrypt},
|
||||
{"encrypt", title_encrypt},
|
||||
{"install", title_install},
|
||||
{"build_cia", title_build_cia},
|
||||
{"extract_code", title_extract_code},
|
||||
{"compress_code", title_compress_code},
|
||||
{"apply_ips", title_apply_ips},
|
||||
{"apply_bps", title_apply_bps},
|
||||
{"apply_bpm", title_apply_bpm},
|
||||
{NULL, NULL}
|
||||
};
|
||||
|
||||
int gm9lua_open_title(lua_State* L) {
|
||||
luaL_newlib(L, title_lib);
|
||||
return 1;
|
||||
}
|
||||
#endif
|
||||
@ -1,6 +0,0 @@
|
||||
#pragma once
|
||||
#include "gm9lua.h"
|
||||
|
||||
#define GM9LUA_TITLELIBNAME "title"
|
||||
|
||||
int gm9lua_open_title(lua_State* L);
|
||||
@ -1,360 +0,0 @@
|
||||
#ifndef NO_LUA
|
||||
#include "gm9ui.h"
|
||||
#include "ui.h"
|
||||
#include "fs.h"
|
||||
#include "png.h"
|
||||
#include "swkbd.h"
|
||||
#include "qrcodegen.h"
|
||||
#include "utils.h"
|
||||
#include "hid.h"
|
||||
|
||||
#define MAXOPTIONS 256
|
||||
#define MAXOPTIONS_STR "256"
|
||||
|
||||
#define OUTPUTMAXLINES 24
|
||||
#define OUTPUTMAXCHARSPERLINE 80 // make sure this includes space for '\0'
|
||||
|
||||
// this output buffer stuff is especially a test, it needs to take into account newlines and fonts that are not 8x10
|
||||
|
||||
char output_buffer[OUTPUTMAXLINES][OUTPUTMAXCHARSPERLINE]; // hold 24 lines
|
||||
|
||||
void ShiftOutputBufferUp(void) {
|
||||
for (int i = 0; i < OUTPUTMAXLINES - 1; i++) {
|
||||
memcpy(output_buffer[i], output_buffer[i + 1], OUTPUTMAXCHARSPERLINE);
|
||||
}
|
||||
}
|
||||
|
||||
void ClearOutputBuffer(void) {
|
||||
memset(output_buffer, 0, sizeof(output_buffer));
|
||||
}
|
||||
|
||||
void WriteToOutputBuffer(char* text) {
|
||||
strlcpy(output_buffer[OUTPUTMAXLINES - 1], text, OUTPUTMAXCHARSPERLINE);
|
||||
}
|
||||
|
||||
void RenderOutputBuffer(void) {
|
||||
ClearScreenF(false, true, COLOR_STD_BG);
|
||||
for (int i = 0; i < OUTPUTMAXLINES; i++) {
|
||||
DrawString(ALT_SCREEN, output_buffer[i], 0, i * 10, COLOR_STD_FONT, COLOR_TRANSPARENT);
|
||||
}
|
||||
}
|
||||
|
||||
static int ui_echo(lua_State* L) {
|
||||
CheckLuaArgCount(L, 1, "ui.echo");
|
||||
const char* text = lua_tostring(L, 1);
|
||||
|
||||
ShowPrompt(false, "%s", text);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int ui_ask(lua_State* L) {
|
||||
CheckLuaArgCount(L, 1, "ui.ask");
|
||||
const char* text = lua_tostring(L, 1);
|
||||
|
||||
bool ret = ShowPrompt(true, "%s", text);
|
||||
lua_pushboolean(L, ret);
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int ui_ask_hex(lua_State* L) {
|
||||
CheckLuaArgCount(L, 3, "ui.ask_hex");
|
||||
const char* text = lua_tostring(L, 1);
|
||||
u64 initial_hex = lua_tonumber(L, 2);
|
||||
u32 n_digits = lua_tonumber(L, 3);
|
||||
|
||||
u64 ret = ShowHexPrompt(initial_hex, n_digits, "%s", text);
|
||||
if (ret == (u64) -1) {
|
||||
lua_pushnil(L);
|
||||
} else {
|
||||
lua_pushnumber(L, ret);
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int ui_ask_number(lua_State* L) {
|
||||
CheckLuaArgCount(L, 2, "ui.ask_number");
|
||||
const char* text = lua_tostring(L, 1);
|
||||
u64 initial_num = lua_tonumber(L, 2);
|
||||
|
||||
u64 ret = ShowNumberPrompt(initial_num, "%s", text);
|
||||
if (ret == (u64) -1) {
|
||||
lua_pushnil(L);
|
||||
} else {
|
||||
lua_pushnumber(L, ret);
|
||||
}
|
||||
return 1;
|
||||
|
||||
}
|
||||
|
||||
static int ui_ask_text(lua_State* L) {
|
||||
CheckLuaArgCount(L, 3, "ui.ask_text");
|
||||
const char* prompt = lua_tostring(L, 1);
|
||||
const char* _initial_text = lua_tostring(L, 2);
|
||||
u32 initial_text_size = strlen(_initial_text)+1;
|
||||
char initial_text[initial_text_size];
|
||||
snprintf(initial_text, initial_text_size, "%s", _initial_text);
|
||||
u32 max_size = lua_tonumber(L, 3);
|
||||
bool result = ShowKeyboardOrPrompt(initial_text, max_size, "%s", prompt);
|
||||
if (result)
|
||||
lua_pushstring(L, initial_text);
|
||||
else
|
||||
lua_pushnil(L);
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int ui_clear(lua_State* L) {
|
||||
CheckLuaArgCount(L, 0, "ui.clear");
|
||||
|
||||
ClearScreen(ALT_SCREEN, COLOR_STD_BG);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int ui_show_png(lua_State* L) {
|
||||
CheckLuaArgCount(L, 1, "ui.show_png");
|
||||
const char* path = luaL_checkstring(L, 1);
|
||||
u16 *screen = ALT_SCREEN;
|
||||
u16 *bitmap = NULL;
|
||||
u8* png = (u8*) malloc(SCREEN_SIZE(screen));
|
||||
u32 bitmap_width, bitmap_height;
|
||||
if (png) {
|
||||
u32 png_size = FileGetData(path, png, SCREEN_SIZE(screen), 0);
|
||||
if (!png_size) {
|
||||
free(png);
|
||||
return luaL_error(L, "Could not read %s", path);
|
||||
}
|
||||
if (png_size && png_size < SCREEN_SIZE(screen)) {
|
||||
bitmap = PNG_Decompress(png, png_size, &bitmap_width, &bitmap_height);
|
||||
if (!bitmap) {
|
||||
free(png);
|
||||
return luaL_error(L, "Invalid PNG file");
|
||||
}
|
||||
}
|
||||
free(png);
|
||||
if (!bitmap) {
|
||||
return luaL_error(L, "PNG too large");
|
||||
} else if ((SCREEN_WIDTH(screen) < bitmap_width) || (SCREEN_HEIGHT < bitmap_height)) {
|
||||
free(bitmap);
|
||||
return luaL_error(L, "PNG too large");
|
||||
} else {
|
||||
ClearScreen(ALT_SCREEN, COLOR_STD_BG);
|
||||
DrawBitmap(
|
||||
screen, // screen
|
||||
-1, // x coordinate from argument
|
||||
-1, // y coordinate from argument
|
||||
bitmap_width, // width
|
||||
bitmap_height, // height
|
||||
bitmap // bitmap
|
||||
);
|
||||
free(bitmap);
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int ui_show_text(lua_State* L) {
|
||||
CheckLuaArgCount(L, 1, "ui.show_text");
|
||||
|
||||
const char* text = lua_tostring(L, 1);
|
||||
|
||||
ClearScreen(ALT_SCREEN, COLOR_STD_BG);
|
||||
DrawStringCenter(ALT_SCREEN, COLOR_STD_FONT, COLOR_STD_BG, "%s", text);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int ui_show_game_info(lua_State* L) {
|
||||
CheckLuaArgCount(L, 1, "ui.show_game_info");
|
||||
const char* path = luaL_checkstring(L, 1);
|
||||
|
||||
bool ret = (ShowGameFileIcon(path, ALT_SCREEN) == 0);
|
||||
if (!ret) {
|
||||
return luaL_error(L, "ShowGameFileIcon failed on %s", path);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int ui_show_qr(lua_State* L) {
|
||||
CheckLuaArgCount(L, 2, "ui.show_qr");
|
||||
size_t data_len;
|
||||
const char* text = luaL_checkstring(L, 1);
|
||||
const char* data = luaL_checklstring(L, 2, &data_len);
|
||||
|
||||
const u32 screen_size = SCREEN_SIZE(ALT_SCREEN);
|
||||
u8* screen_copy = (u8*) malloc(screen_size);
|
||||
u8 qrcode[qrcodegen_BUFFER_LEN_MAX];
|
||||
u8 temp[qrcodegen_BUFFER_LEN_MAX];
|
||||
bool ret = screen_copy && qrcodegen_encodeText(data, temp, qrcode, qrcodegen_Ecc_LOW,
|
||||
qrcodegen_VERSION_MIN, qrcodegen_VERSION_MAX, qrcodegen_Mask_AUTO, true);
|
||||
if (ret) {
|
||||
memcpy(screen_copy, ALT_SCREEN, screen_size);
|
||||
DrawQrCode(ALT_SCREEN, qrcode);
|
||||
ShowPrompt(false, "%s", text);
|
||||
memcpy(ALT_SCREEN, screen_copy, screen_size);
|
||||
} else {
|
||||
return luaL_error(L, "could not allocate memory");
|
||||
}
|
||||
free(screen_copy);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int ui_show_text_viewer(lua_State* L) {
|
||||
CheckLuaArgCount(L, 1, "ui.show_text_viewer");
|
||||
size_t len = 0;
|
||||
const char* text = luaL_tolstring(L, 1, &len);
|
||||
|
||||
// validate text ourselves so we can return a better error
|
||||
// MemTextViewer calls ShowPrompt if it's bad, and i don't want that
|
||||
|
||||
if (!(ValidateText(text, len))) {
|
||||
return luaL_error(L, "text validation failed");
|
||||
}
|
||||
|
||||
if (!(MemTextViewer(text, len, 1, false))) {
|
||||
return luaL_error(L, "failed to run MemTextViewer");
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int ui_show_file_text_viewer(lua_State* L) {
|
||||
CheckLuaArgCount(L, 1, "ui.show_file_text_viewer");
|
||||
const char* path = luaL_checkstring(L, 1);
|
||||
|
||||
// validate text ourselves so we can return a better error
|
||||
// MemTextViewer calls ShowPrompt if it's bad, and i don't want that
|
||||
// and FileTextViewer calls the above function
|
||||
|
||||
char* text = malloc(STD_BUFFER_SIZE);
|
||||
if (!text) {
|
||||
return luaL_error(L, "could not allocate memory");
|
||||
};
|
||||
|
||||
// TODO: replace this with something that can detect file read errors and actual 0-length files
|
||||
size_t flen = FileGetData(path, text, STD_BUFFER_SIZE - 1, 0);
|
||||
|
||||
text[flen] = '\0';
|
||||
u32 len = (ptrdiff_t)memchr(text, '\0', flen + 1) - (ptrdiff_t)text;
|
||||
|
||||
if (!(ValidateText(text, len))) {
|
||||
free(text);
|
||||
return luaL_error(L, "text validation failed");
|
||||
}
|
||||
|
||||
if (!(MemTextViewer(text, len, 1, false))) {
|
||||
free(text);
|
||||
return luaL_error(L, "failed to run MemTextViewer");
|
||||
}
|
||||
|
||||
free(text);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int ui_ask_selection(lua_State* L) {
|
||||
CheckLuaArgCount(L, 2, "ui.ask_selection");
|
||||
const char* text = lua_tostring(L, 1);
|
||||
char* options[MAXOPTIONS];
|
||||
const char* tmpstr;
|
||||
size_t len;
|
||||
int i;
|
||||
|
||||
luaL_argcheck(L, lua_istable(L, 2), 2, "table expected");
|
||||
|
||||
lua_Integer opttablesize = luaL_len(L, 2);
|
||||
luaL_argcheck(L, opttablesize <= MAXOPTIONS, 2, "more than " MAXOPTIONS_STR " options given");
|
||||
for (i = 0; i < opttablesize; i++) {
|
||||
lua_geti(L, 2, i + 1);
|
||||
tmpstr = lua_tolstring(L, -1, &len);
|
||||
options[i] = malloc(len + 1);
|
||||
strlcpy(options[i], tmpstr, len + 1);
|
||||
lua_pop(L, 1);
|
||||
}
|
||||
int result = ShowSelectPrompt(opttablesize, (const char**)options, "%s", text);
|
||||
for (i = 0; i < opttablesize; i++) free(options[i]);
|
||||
// lua only treats "false" and "nil" as false values
|
||||
// so to make this easier, return nil and not 0 if no choice was made
|
||||
// https://www.lua.org/manual/5.4/manual.html#3.3.4
|
||||
if (result)
|
||||
lua_pushinteger(L, result);
|
||||
else
|
||||
lua_pushnil(L);
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int ui_format_bytes(lua_State* L) {
|
||||
CheckLuaArgCount(L, 1, "ui.format_bytes");
|
||||
lua_Integer size = luaL_checkinteger(L, 1);
|
||||
|
||||
char bytesstr[32] = { 0 };
|
||||
FormatBytes(bytesstr, (u64)size);
|
||||
|
||||
lua_pushstring(L, bytesstr);
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int ui_global_print(lua_State* L) {
|
||||
//const char* text = lua_tostring(L, 1);
|
||||
char buf[OUTPUTMAXCHARSPERLINE] = {0};
|
||||
int argcount = lua_gettop(L);
|
||||
for (int i = 0; i < lua_gettop(L); i++) {
|
||||
const char* str = luaL_tolstring(L, i+1, NULL);
|
||||
if (str) {
|
||||
strlcat(buf, str, OUTPUTMAXCHARSPERLINE);
|
||||
lua_pop(L, 1);
|
||||
} else {
|
||||
// idk
|
||||
strlcat(buf, "(unknown)", OUTPUTMAXCHARSPERLINE);
|
||||
}
|
||||
if (i < argcount) strlcat(buf, " ", OUTPUTMAXCHARSPERLINE);
|
||||
}
|
||||
ShiftOutputBufferUp();
|
||||
WriteToOutputBuffer((char*)buf);
|
||||
RenderOutputBuffer();
|
||||
return 0;
|
||||
}
|
||||
|
||||
// TODO: use luaL_checkoption which will auto-raise an error
|
||||
// use BUTTON_STRINGS from common/hid_map.h
|
||||
static int ui_check_key(lua_State* L) {
|
||||
CheckLuaArgCount(L, 1, "ui.check_key");
|
||||
const char* key = luaL_checkstring(L, 1);
|
||||
|
||||
lua_pushboolean(L, CheckButton(StringToButton((char*)key)));
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
static const luaL_Reg ui_lib[] = {
|
||||
{"echo", ui_echo},
|
||||
{"ask", ui_ask},
|
||||
{"ask_hex", ui_ask_hex},
|
||||
{"ask_number", ui_ask_number},
|
||||
{"ask_text", ui_ask_text},
|
||||
{"ask_selection", ui_ask_selection},
|
||||
{"clear", ui_clear},
|
||||
{"show_png", ui_show_png},
|
||||
{"show_text", ui_show_text},
|
||||
{"show_game_info", ui_show_game_info},
|
||||
{"show_qr", ui_show_qr},
|
||||
{"show_text_viewer", ui_show_text_viewer},
|
||||
{"show_file_text_viewer", ui_show_file_text_viewer},
|
||||
{"format_bytes", ui_format_bytes},
|
||||
{"check_key", ui_check_key},
|
||||
{NULL, NULL}
|
||||
};
|
||||
|
||||
static const luaL_Reg ui_global_lib[] = {
|
||||
{"print", ui_global_print},
|
||||
{NULL, NULL}
|
||||
};
|
||||
|
||||
int gm9lua_open_ui(lua_State* L) {
|
||||
luaL_newlib(L, ui_lib);
|
||||
lua_pushglobaltable(L); // push global table to stack
|
||||
luaL_setfuncs(L, ui_global_lib, 0); // set global funcs
|
||||
lua_pop(L, 1); // pop global table from stack
|
||||
return 1;
|
||||
}
|
||||
#endif
|
||||
@ -1,10 +0,0 @@
|
||||
#pragma once
|
||||
#include "gm9lua.h"
|
||||
|
||||
#define GM9LUA_UILIBNAME "ui"
|
||||
|
||||
void ShiftOutputBufferUp(void);
|
||||
void ClearOutputBuffer(void);
|
||||
void RenderOutputBuffer(void);
|
||||
void WriteToOutputBuffer(char* text);
|
||||
int gm9lua_open_ui(lua_State* L);
|
||||
File diff suppressed because it is too large
Load Diff
@ -1,52 +0,0 @@
|
||||
/*
|
||||
** $Id: lapi.h $
|
||||
** Auxiliary functions from Lua API
|
||||
** See Copyright Notice in lua.h
|
||||
*/
|
||||
|
||||
#ifndef lapi_h
|
||||
#define lapi_h
|
||||
|
||||
|
||||
#include "llimits.h"
|
||||
#include "lstate.h"
|
||||
|
||||
|
||||
/* Increments 'L->top.p', checking for stack overflows */
|
||||
#define api_incr_top(L) {L->top.p++; \
|
||||
api_check(L, L->top.p <= L->ci->top.p, \
|
||||
"stack overflow");}
|
||||
|
||||
|
||||
/*
|
||||
** If a call returns too many multiple returns, the callee may not have
|
||||
** stack space to accommodate all results. In this case, this macro
|
||||
** increases its stack space ('L->ci->top.p').
|
||||
*/
|
||||
#define adjustresults(L,nres) \
|
||||
{ if ((nres) <= LUA_MULTRET && L->ci->top.p < L->top.p) \
|
||||
L->ci->top.p = L->top.p; }
|
||||
|
||||
|
||||
/* Ensure the stack has at least 'n' elements */
|
||||
#define api_checknelems(L,n) \
|
||||
api_check(L, (n) < (L->top.p - L->ci->func.p), \
|
||||
"not enough elements in the stack")
|
||||
|
||||
|
||||
/*
|
||||
** To reduce the overhead of returning from C functions, the presence of
|
||||
** to-be-closed variables in these functions is coded in the CallInfo's
|
||||
** field 'nresults', in a way that functions with no to-be-closed variables
|
||||
** with zero, one, or "all" wanted results have no overhead. Functions
|
||||
** with other number of wanted results, as well as functions with
|
||||
** variables to be closed, have an extra check.
|
||||
*/
|
||||
|
||||
#define hastocloseCfunc(n) ((n) < LUA_MULTRET)
|
||||
|
||||
/* Map [-1, inf) (range of 'nresults') into (-inf, -2] */
|
||||
#define codeNresults(n) (-(n) - 3)
|
||||
#define decodeNresults(n) (-(n) - 3)
|
||||
|
||||
#endif
|
||||
File diff suppressed because it is too large
Load Diff
@ -1,301 +0,0 @@
|
||||
/*
|
||||
** $Id: lauxlib.h $
|
||||
** Auxiliary functions for building Lua libraries
|
||||
** See Copyright Notice in lua.h
|
||||
*/
|
||||
|
||||
|
||||
#ifndef lauxlib_h
|
||||
#define lauxlib_h
|
||||
|
||||
|
||||
#include <stddef.h>
|
||||
#include <stdio.h>
|
||||
|
||||
#include "luaconf.h"
|
||||
#include "lua.h"
|
||||
|
||||
|
||||
/* global table */
|
||||
#define LUA_GNAME "_G"
|
||||
|
||||
|
||||
typedef struct luaL_Buffer luaL_Buffer;
|
||||
|
||||
|
||||
/* extra error code for 'luaL_loadfilex' */
|
||||
#define LUA_ERRFILE (LUA_ERRERR+1)
|
||||
|
||||
|
||||
/* key, in the registry, for table of loaded modules */
|
||||
#define LUA_LOADED_TABLE "_LOADED"
|
||||
|
||||
|
||||
/* key, in the registry, for table of preloaded loaders */
|
||||
#define LUA_PRELOAD_TABLE "_PRELOAD"
|
||||
|
||||
|
||||
typedef struct luaL_Reg {
|
||||
const char *name;
|
||||
lua_CFunction func;
|
||||
} luaL_Reg;
|
||||
|
||||
|
||||
#define LUAL_NUMSIZES (sizeof(lua_Integer)*16 + sizeof(lua_Number))
|
||||
|
||||
LUALIB_API void (luaL_checkversion_) (lua_State *L, lua_Number ver, size_t sz);
|
||||
#define luaL_checkversion(L) \
|
||||
luaL_checkversion_(L, LUA_VERSION_NUM, LUAL_NUMSIZES)
|
||||
|
||||
LUALIB_API int (luaL_getmetafield) (lua_State *L, int obj, const char *e);
|
||||
LUALIB_API int (luaL_callmeta) (lua_State *L, int obj, const char *e);
|
||||
LUALIB_API const char *(luaL_tolstring) (lua_State *L, int idx, size_t *len);
|
||||
LUALIB_API int (luaL_argerror) (lua_State *L, int arg, const char *extramsg);
|
||||
LUALIB_API int (luaL_typeerror) (lua_State *L, int arg, const char *tname);
|
||||
LUALIB_API const char *(luaL_checklstring) (lua_State *L, int arg,
|
||||
size_t *l);
|
||||
LUALIB_API const char *(luaL_optlstring) (lua_State *L, int arg,
|
||||
const char *def, size_t *l);
|
||||
LUALIB_API lua_Number (luaL_checknumber) (lua_State *L, int arg);
|
||||
LUALIB_API lua_Number (luaL_optnumber) (lua_State *L, int arg, lua_Number def);
|
||||
|
||||
LUALIB_API lua_Integer (luaL_checkinteger) (lua_State *L, int arg);
|
||||
LUALIB_API lua_Integer (luaL_optinteger) (lua_State *L, int arg,
|
||||
lua_Integer def);
|
||||
|
||||
LUALIB_API void (luaL_checkstack) (lua_State *L, int sz, const char *msg);
|
||||
LUALIB_API void (luaL_checktype) (lua_State *L, int arg, int t);
|
||||
LUALIB_API void (luaL_checkany) (lua_State *L, int arg);
|
||||
|
||||
LUALIB_API int (luaL_newmetatable) (lua_State *L, const char *tname);
|
||||
LUALIB_API void (luaL_setmetatable) (lua_State *L, const char *tname);
|
||||
LUALIB_API void *(luaL_testudata) (lua_State *L, int ud, const char *tname);
|
||||
LUALIB_API void *(luaL_checkudata) (lua_State *L, int ud, const char *tname);
|
||||
|
||||
LUALIB_API void (luaL_where) (lua_State *L, int lvl);
|
||||
LUALIB_API int (luaL_error) (lua_State *L, const char *fmt, ...);
|
||||
|
||||
LUALIB_API int (luaL_checkoption) (lua_State *L, int arg, const char *def,
|
||||
const char *const lst[]);
|
||||
|
||||
LUALIB_API int (luaL_fileresult) (lua_State *L, int stat, const char *fname);
|
||||
LUALIB_API int (luaL_execresult) (lua_State *L, int stat);
|
||||
|
||||
|
||||
/* predefined references */
|
||||
#define LUA_NOREF (-2)
|
||||
#define LUA_REFNIL (-1)
|
||||
|
||||
LUALIB_API int (luaL_ref) (lua_State *L, int t);
|
||||
LUALIB_API void (luaL_unref) (lua_State *L, int t, int ref);
|
||||
|
||||
LUALIB_API int (luaL_loadfilex) (lua_State *L, const char *filename,
|
||||
const char *mode);
|
||||
|
||||
#define luaL_loadfile(L,f) luaL_loadfilex(L,f,NULL)
|
||||
|
||||
LUALIB_API int (luaL_loadbufferx) (lua_State *L, const char *buff, size_t sz,
|
||||
const char *name, const char *mode);
|
||||
LUALIB_API int (luaL_loadstring) (lua_State *L, const char *s);
|
||||
|
||||
LUALIB_API lua_State *(luaL_newstate) (void);
|
||||
|
||||
LUALIB_API lua_Integer (luaL_len) (lua_State *L, int idx);
|
||||
|
||||
LUALIB_API void (luaL_addgsub) (luaL_Buffer *b, const char *s,
|
||||
const char *p, const char *r);
|
||||
LUALIB_API const char *(luaL_gsub) (lua_State *L, const char *s,
|
||||
const char *p, const char *r);
|
||||
|
||||
LUALIB_API void (luaL_setfuncs) (lua_State *L, const luaL_Reg *l, int nup);
|
||||
|
||||
LUALIB_API int (luaL_getsubtable) (lua_State *L, int idx, const char *fname);
|
||||
|
||||
LUALIB_API void (luaL_traceback) (lua_State *L, lua_State *L1,
|
||||
const char *msg, int level);
|
||||
|
||||
LUALIB_API void (luaL_requiref) (lua_State *L, const char *modname,
|
||||
lua_CFunction openf, int glb);
|
||||
|
||||
/*
|
||||
** ===============================================================
|
||||
** some useful macros
|
||||
** ===============================================================
|
||||
*/
|
||||
|
||||
|
||||
#define luaL_newlibtable(L,l) \
|
||||
lua_createtable(L, 0, sizeof(l)/sizeof((l)[0]) - 1)
|
||||
|
||||
#define luaL_newlib(L,l) \
|
||||
(luaL_checkversion(L), luaL_newlibtable(L,l), luaL_setfuncs(L,l,0))
|
||||
|
||||
#define luaL_argcheck(L, cond,arg,extramsg) \
|
||||
((void)(luai_likely(cond) || luaL_argerror(L, (arg), (extramsg))))
|
||||
|
||||
#define luaL_argexpected(L,cond,arg,tname) \
|
||||
((void)(luai_likely(cond) || luaL_typeerror(L, (arg), (tname))))
|
||||
|
||||
#define luaL_checkstring(L,n) (luaL_checklstring(L, (n), NULL))
|
||||
#define luaL_optstring(L,n,d) (luaL_optlstring(L, (n), (d), NULL))
|
||||
|
||||
#define luaL_typename(L,i) lua_typename(L, lua_type(L,(i)))
|
||||
|
||||
#define luaL_dofile(L, fn) \
|
||||
(luaL_loadfile(L, fn) || lua_pcall(L, 0, LUA_MULTRET, 0))
|
||||
|
||||
#define luaL_dostring(L, s) \
|
||||
(luaL_loadstring(L, s) || lua_pcall(L, 0, LUA_MULTRET, 0))
|
||||
|
||||
#define luaL_getmetatable(L,n) (lua_getfield(L, LUA_REGISTRYINDEX, (n)))
|
||||
|
||||
#define luaL_opt(L,f,n,d) (lua_isnoneornil(L,(n)) ? (d) : f(L,(n)))
|
||||
|
||||
#define luaL_loadbuffer(L,s,sz,n) luaL_loadbufferx(L,s,sz,n,NULL)
|
||||
|
||||
|
||||
/*
|
||||
** Perform arithmetic operations on lua_Integer values with wrap-around
|
||||
** semantics, as the Lua core does.
|
||||
*/
|
||||
#define luaL_intop(op,v1,v2) \
|
||||
((lua_Integer)((lua_Unsigned)(v1) op (lua_Unsigned)(v2)))
|
||||
|
||||
|
||||
/* push the value used to represent failure/error */
|
||||
#define luaL_pushfail(L) lua_pushnil(L)
|
||||
|
||||
|
||||
/*
|
||||
** Internal assertions for in-house debugging
|
||||
*/
|
||||
#if !defined(lua_assert)
|
||||
|
||||
#if defined LUAI_ASSERT
|
||||
#include <assert.h>
|
||||
#define lua_assert(c) assert(c)
|
||||
#else
|
||||
#define lua_assert(c) ((void)0)
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
/*
|
||||
** {======================================================
|
||||
** Generic Buffer manipulation
|
||||
** =======================================================
|
||||
*/
|
||||
|
||||
struct luaL_Buffer {
|
||||
char *b; /* buffer address */
|
||||
size_t size; /* buffer size */
|
||||
size_t n; /* number of characters in buffer */
|
||||
lua_State *L;
|
||||
union {
|
||||
LUAI_MAXALIGN; /* ensure maximum alignment for buffer */
|
||||
char b[LUAL_BUFFERSIZE]; /* initial buffer */
|
||||
} init;
|
||||
};
|
||||
|
||||
|
||||
#define luaL_bufflen(bf) ((bf)->n)
|
||||
#define luaL_buffaddr(bf) ((bf)->b)
|
||||
|
||||
|
||||
#define luaL_addchar(B,c) \
|
||||
((void)((B)->n < (B)->size || luaL_prepbuffsize((B), 1)), \
|
||||
((B)->b[(B)->n++] = (c)))
|
||||
|
||||
#define luaL_addsize(B,s) ((B)->n += (s))
|
||||
|
||||
#define luaL_buffsub(B,s) ((B)->n -= (s))
|
||||
|
||||
LUALIB_API void (luaL_buffinit) (lua_State *L, luaL_Buffer *B);
|
||||
LUALIB_API char *(luaL_prepbuffsize) (luaL_Buffer *B, size_t sz);
|
||||
LUALIB_API void (luaL_addlstring) (luaL_Buffer *B, const char *s, size_t l);
|
||||
LUALIB_API void (luaL_addstring) (luaL_Buffer *B, const char *s);
|
||||
LUALIB_API void (luaL_addvalue) (luaL_Buffer *B);
|
||||
LUALIB_API void (luaL_pushresult) (luaL_Buffer *B);
|
||||
LUALIB_API void (luaL_pushresultsize) (luaL_Buffer *B, size_t sz);
|
||||
LUALIB_API char *(luaL_buffinitsize) (lua_State *L, luaL_Buffer *B, size_t sz);
|
||||
|
||||
#define luaL_prepbuffer(B) luaL_prepbuffsize(B, LUAL_BUFFERSIZE)
|
||||
|
||||
/* }====================================================== */
|
||||
|
||||
|
||||
|
||||
/*
|
||||
** {======================================================
|
||||
** File handles for IO library
|
||||
** =======================================================
|
||||
*/
|
||||
|
||||
/*
|
||||
** A file handle is a userdata with metatable 'LUA_FILEHANDLE' and
|
||||
** initial structure 'luaL_Stream' (it may contain other fields
|
||||
** after that initial structure).
|
||||
*/
|
||||
|
||||
#define LUA_FILEHANDLE "FILE*"
|
||||
|
||||
|
||||
typedef struct luaL_Stream {
|
||||
FILE *f; /* stream (NULL for incompletely created streams) */
|
||||
lua_CFunction closef; /* to close stream (NULL for closed streams) */
|
||||
} luaL_Stream;
|
||||
|
||||
/* }====================================================== */
|
||||
|
||||
/*
|
||||
** {==================================================================
|
||||
** "Abstraction Layer" for basic report of messages and errors
|
||||
** ===================================================================
|
||||
*/
|
||||
|
||||
/* print a string */
|
||||
#if !defined(lua_writestring)
|
||||
#define lua_writestring(s,l) fwrite((s), sizeof(char), (l), stdout)
|
||||
#endif
|
||||
|
||||
/* print a newline and flush the output */
|
||||
#if !defined(lua_writeline)
|
||||
#define lua_writeline() (lua_writestring("\n", 1), fflush(stdout))
|
||||
#endif
|
||||
|
||||
/* print an error message */
|
||||
#if !defined(lua_writestringerror)
|
||||
#define lua_writestringerror(s,p) \
|
||||
(fprintf(stderr, (s), (p)), fflush(stderr))
|
||||
#endif
|
||||
|
||||
/* }================================================================== */
|
||||
|
||||
|
||||
/*
|
||||
** {============================================================
|
||||
** Compatibility with deprecated conversions
|
||||
** =============================================================
|
||||
*/
|
||||
#if defined(LUA_COMPAT_APIINTCASTS)
|
||||
|
||||
#define luaL_checkunsigned(L,a) ((lua_Unsigned)luaL_checkinteger(L,a))
|
||||
#define luaL_optunsigned(L,a,d) \
|
||||
((lua_Unsigned)luaL_optinteger(L,a,(lua_Integer)(d)))
|
||||
|
||||
#define luaL_checkint(L,n) ((int)luaL_checkinteger(L, (n)))
|
||||
#define luaL_optint(L,n,d) ((int)luaL_optinteger(L, (n), (d)))
|
||||
|
||||
#define luaL_checklong(L,n) ((long)luaL_checkinteger(L, (n)))
|
||||
#define luaL_optlong(L,n,d) ((long)luaL_optinteger(L, (n), (d)))
|
||||
|
||||
#endif
|
||||
/* }============================================================ */
|
||||
|
||||
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
@ -1,549 +0,0 @@
|
||||
/*
|
||||
** $Id: lbaselib.c $
|
||||
** Basic library
|
||||
** See Copyright Notice in lua.h
|
||||
*/
|
||||
|
||||
#define lbaselib_c
|
||||
#define LUA_LIB
|
||||
|
||||
#include "lprefix.h"
|
||||
|
||||
|
||||
#include <ctype.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "lua.h"
|
||||
|
||||
#include "lauxlib.h"
|
||||
#include "lualib.h"
|
||||
|
||||
|
||||
static int luaB_print (lua_State *L) {
|
||||
int n = lua_gettop(L); /* number of arguments */
|
||||
int i;
|
||||
for (i = 1; i <= n; i++) { /* for each argument */
|
||||
size_t l;
|
||||
const char *s = luaL_tolstring(L, i, &l); /* convert it to string */
|
||||
if (i > 1) /* not the first element? */
|
||||
lua_writestring("\t", 1); /* add a tab before it */
|
||||
lua_writestring(s, l); /* print it */
|
||||
lua_pop(L, 1); /* pop result */
|
||||
}
|
||||
lua_writeline();
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Creates a warning with all given arguments.
|
||||
** Check first for errors; otherwise an error may interrupt
|
||||
** the composition of a warning, leaving it unfinished.
|
||||
*/
|
||||
static int luaB_warn (lua_State *L) {
|
||||
int n = lua_gettop(L); /* number of arguments */
|
||||
int i;
|
||||
luaL_checkstring(L, 1); /* at least one argument */
|
||||
for (i = 2; i <= n; i++)
|
||||
luaL_checkstring(L, i); /* make sure all arguments are strings */
|
||||
for (i = 1; i < n; i++) /* compose warning */
|
||||
lua_warning(L, lua_tostring(L, i), 1);
|
||||
lua_warning(L, lua_tostring(L, n), 0); /* close warning */
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
#define SPACECHARS " \f\n\r\t\v"
|
||||
|
||||
static const char *b_str2int (const char *s, int base, lua_Integer *pn) {
|
||||
lua_Unsigned n = 0;
|
||||
int neg = 0;
|
||||
s += strspn(s, SPACECHARS); /* skip initial spaces */
|
||||
if (*s == '-') { s++; neg = 1; } /* handle sign */
|
||||
else if (*s == '+') s++;
|
||||
if (!isalnum((unsigned char)*s)) /* no digit? */
|
||||
return NULL;
|
||||
do {
|
||||
int digit = (isdigit((unsigned char)*s)) ? *s - '0'
|
||||
: (toupper((unsigned char)*s) - 'A') + 10;
|
||||
if (digit >= base) return NULL; /* invalid numeral */
|
||||
n = n * base + digit;
|
||||
s++;
|
||||
} while (isalnum((unsigned char)*s));
|
||||
s += strspn(s, SPACECHARS); /* skip trailing spaces */
|
||||
*pn = (lua_Integer)((neg) ? (0u - n) : n);
|
||||
return s;
|
||||
}
|
||||
|
||||
|
||||
static int luaB_tonumber (lua_State *L) {
|
||||
if (lua_isnoneornil(L, 2)) { /* standard conversion? */
|
||||
if (lua_type(L, 1) == LUA_TNUMBER) { /* already a number? */
|
||||
lua_settop(L, 1); /* yes; return it */
|
||||
return 1;
|
||||
}
|
||||
else {
|
||||
size_t l;
|
||||
const char *s = lua_tolstring(L, 1, &l);
|
||||
if (s != NULL && lua_stringtonumber(L, s) == l + 1)
|
||||
return 1; /* successful conversion to number */
|
||||
/* else not a number */
|
||||
luaL_checkany(L, 1); /* (but there must be some parameter) */
|
||||
}
|
||||
}
|
||||
else {
|
||||
size_t l;
|
||||
const char *s;
|
||||
lua_Integer n = 0; /* to avoid warnings */
|
||||
lua_Integer base = luaL_checkinteger(L, 2);
|
||||
luaL_checktype(L, 1, LUA_TSTRING); /* no numbers as strings */
|
||||
s = lua_tolstring(L, 1, &l);
|
||||
luaL_argcheck(L, 2 <= base && base <= 36, 2, "base out of range");
|
||||
if (b_str2int(s, (int)base, &n) == s + l) {
|
||||
lua_pushinteger(L, n);
|
||||
return 1;
|
||||
} /* else not a number */
|
||||
} /* else not a number */
|
||||
luaL_pushfail(L); /* not a number */
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
static int luaB_error (lua_State *L) {
|
||||
int level = (int)luaL_optinteger(L, 2, 1);
|
||||
lua_settop(L, 1);
|
||||
if (lua_type(L, 1) == LUA_TSTRING && level > 0) {
|
||||
luaL_where(L, level); /* add extra information */
|
||||
lua_pushvalue(L, 1);
|
||||
lua_concat(L, 2);
|
||||
}
|
||||
return lua_error(L);
|
||||
}
|
||||
|
||||
|
||||
static int luaB_getmetatable (lua_State *L) {
|
||||
luaL_checkany(L, 1);
|
||||
if (!lua_getmetatable(L, 1)) {
|
||||
lua_pushnil(L);
|
||||
return 1; /* no metatable */
|
||||
}
|
||||
luaL_getmetafield(L, 1, "__metatable");
|
||||
return 1; /* returns either __metatable field (if present) or metatable */
|
||||
}
|
||||
|
||||
|
||||
static int luaB_setmetatable (lua_State *L) {
|
||||
int t = lua_type(L, 2);
|
||||
luaL_checktype(L, 1, LUA_TTABLE);
|
||||
luaL_argexpected(L, t == LUA_TNIL || t == LUA_TTABLE, 2, "nil or table");
|
||||
if (l_unlikely(luaL_getmetafield(L, 1, "__metatable") != LUA_TNIL))
|
||||
return luaL_error(L, "cannot change a protected metatable");
|
||||
lua_settop(L, 2);
|
||||
lua_setmetatable(L, 1);
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
static int luaB_rawequal (lua_State *L) {
|
||||
luaL_checkany(L, 1);
|
||||
luaL_checkany(L, 2);
|
||||
lua_pushboolean(L, lua_rawequal(L, 1, 2));
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
static int luaB_rawlen (lua_State *L) {
|
||||
int t = lua_type(L, 1);
|
||||
luaL_argexpected(L, t == LUA_TTABLE || t == LUA_TSTRING, 1,
|
||||
"table or string");
|
||||
lua_pushinteger(L, lua_rawlen(L, 1));
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
static int luaB_rawget (lua_State *L) {
|
||||
luaL_checktype(L, 1, LUA_TTABLE);
|
||||
luaL_checkany(L, 2);
|
||||
lua_settop(L, 2);
|
||||
lua_rawget(L, 1);
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int luaB_rawset (lua_State *L) {
|
||||
luaL_checktype(L, 1, LUA_TTABLE);
|
||||
luaL_checkany(L, 2);
|
||||
luaL_checkany(L, 3);
|
||||
lua_settop(L, 3);
|
||||
lua_rawset(L, 1);
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
static int pushmode (lua_State *L, int oldmode) {
|
||||
if (oldmode == -1)
|
||||
luaL_pushfail(L); /* invalid call to 'lua_gc' */
|
||||
else
|
||||
lua_pushstring(L, (oldmode == LUA_GCINC) ? "incremental"
|
||||
: "generational");
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** check whether call to 'lua_gc' was valid (not inside a finalizer)
|
||||
*/
|
||||
#define checkvalres(res) { if (res == -1) break; }
|
||||
|
||||
static int luaB_collectgarbage (lua_State *L) {
|
||||
static const char *const opts[] = {"stop", "restart", "collect",
|
||||
"count", "step", "setpause", "setstepmul",
|
||||
"isrunning", "generational", "incremental", NULL};
|
||||
static const int optsnum[] = {LUA_GCSTOP, LUA_GCRESTART, LUA_GCCOLLECT,
|
||||
LUA_GCCOUNT, LUA_GCSTEP, LUA_GCSETPAUSE, LUA_GCSETSTEPMUL,
|
||||
LUA_GCISRUNNING, LUA_GCGEN, LUA_GCINC};
|
||||
int o = optsnum[luaL_checkoption(L, 1, "collect", opts)];
|
||||
switch (o) {
|
||||
case LUA_GCCOUNT: {
|
||||
int k = lua_gc(L, o);
|
||||
int b = lua_gc(L, LUA_GCCOUNTB);
|
||||
checkvalres(k);
|
||||
lua_pushnumber(L, (lua_Number)k + ((lua_Number)b/1024));
|
||||
return 1;
|
||||
}
|
||||
case LUA_GCSTEP: {
|
||||
int step = (int)luaL_optinteger(L, 2, 0);
|
||||
int res = lua_gc(L, o, step);
|
||||
checkvalres(res);
|
||||
lua_pushboolean(L, res);
|
||||
return 1;
|
||||
}
|
||||
case LUA_GCSETPAUSE:
|
||||
case LUA_GCSETSTEPMUL: {
|
||||
int p = (int)luaL_optinteger(L, 2, 0);
|
||||
int previous = lua_gc(L, o, p);
|
||||
checkvalres(previous);
|
||||
lua_pushinteger(L, previous);
|
||||
return 1;
|
||||
}
|
||||
case LUA_GCISRUNNING: {
|
||||
int res = lua_gc(L, o);
|
||||
checkvalres(res);
|
||||
lua_pushboolean(L, res);
|
||||
return 1;
|
||||
}
|
||||
case LUA_GCGEN: {
|
||||
int minormul = (int)luaL_optinteger(L, 2, 0);
|
||||
int majormul = (int)luaL_optinteger(L, 3, 0);
|
||||
return pushmode(L, lua_gc(L, o, minormul, majormul));
|
||||
}
|
||||
case LUA_GCINC: {
|
||||
int pause = (int)luaL_optinteger(L, 2, 0);
|
||||
int stepmul = (int)luaL_optinteger(L, 3, 0);
|
||||
int stepsize = (int)luaL_optinteger(L, 4, 0);
|
||||
return pushmode(L, lua_gc(L, o, pause, stepmul, stepsize));
|
||||
}
|
||||
default: {
|
||||
int res = lua_gc(L, o);
|
||||
checkvalres(res);
|
||||
lua_pushinteger(L, res);
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
luaL_pushfail(L); /* invalid call (inside a finalizer) */
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
static int luaB_type (lua_State *L) {
|
||||
int t = lua_type(L, 1);
|
||||
luaL_argcheck(L, t != LUA_TNONE, 1, "value expected");
|
||||
lua_pushstring(L, lua_typename(L, t));
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
static int luaB_next (lua_State *L) {
|
||||
luaL_checktype(L, 1, LUA_TTABLE);
|
||||
lua_settop(L, 2); /* create a 2nd argument if there isn't one */
|
||||
if (lua_next(L, 1))
|
||||
return 2;
|
||||
else {
|
||||
lua_pushnil(L);
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static int pairscont (lua_State *L, int status, lua_KContext k) {
|
||||
(void)L; (void)status; (void)k; /* unused */
|
||||
return 3;
|
||||
}
|
||||
|
||||
static int luaB_pairs (lua_State *L) {
|
||||
luaL_checkany(L, 1);
|
||||
if (luaL_getmetafield(L, 1, "__pairs") == LUA_TNIL) { /* no metamethod? */
|
||||
lua_pushcfunction(L, luaB_next); /* will return generator, */
|
||||
lua_pushvalue(L, 1); /* state, */
|
||||
lua_pushnil(L); /* and initial value */
|
||||
}
|
||||
else {
|
||||
lua_pushvalue(L, 1); /* argument 'self' to metamethod */
|
||||
lua_callk(L, 1, 3, 0, pairscont); /* get 3 values from metamethod */
|
||||
}
|
||||
return 3;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Traversal function for 'ipairs'
|
||||
*/
|
||||
static int ipairsaux (lua_State *L) {
|
||||
lua_Integer i = luaL_checkinteger(L, 2);
|
||||
i = luaL_intop(+, i, 1);
|
||||
lua_pushinteger(L, i);
|
||||
return (lua_geti(L, 1, i) == LUA_TNIL) ? 1 : 2;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** 'ipairs' function. Returns 'ipairsaux', given "table", 0.
|
||||
** (The given "table" may not be a table.)
|
||||
*/
|
||||
static int luaB_ipairs (lua_State *L) {
|
||||
luaL_checkany(L, 1);
|
||||
lua_pushcfunction(L, ipairsaux); /* iteration function */
|
||||
lua_pushvalue(L, 1); /* state */
|
||||
lua_pushinteger(L, 0); /* initial value */
|
||||
return 3;
|
||||
}
|
||||
|
||||
|
||||
static int load_aux (lua_State *L, int status, int envidx) {
|
||||
if (l_likely(status == LUA_OK)) {
|
||||
if (envidx != 0) { /* 'env' parameter? */
|
||||
lua_pushvalue(L, envidx); /* environment for loaded function */
|
||||
if (!lua_setupvalue(L, -2, 1)) /* set it as 1st upvalue */
|
||||
lua_pop(L, 1); /* remove 'env' if not used by previous call */
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
else { /* error (message is on top of the stack) */
|
||||
luaL_pushfail(L);
|
||||
lua_insert(L, -2); /* put before error message */
|
||||
return 2; /* return fail plus error message */
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static int luaB_loadfile (lua_State *L) {
|
||||
const char *fname = luaL_optstring(L, 1, NULL);
|
||||
const char *mode = luaL_optstring(L, 2, NULL);
|
||||
int env = (!lua_isnone(L, 3) ? 3 : 0); /* 'env' index or 0 if no 'env' */
|
||||
int status = luaL_loadfilex(L, fname, mode);
|
||||
return load_aux(L, status, env);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** {======================================================
|
||||
** Generic Read function
|
||||
** =======================================================
|
||||
*/
|
||||
|
||||
|
||||
/*
|
||||
** reserved slot, above all arguments, to hold a copy of the returned
|
||||
** string to avoid it being collected while parsed. 'load' has four
|
||||
** optional arguments (chunk, source name, mode, and environment).
|
||||
*/
|
||||
#define RESERVEDSLOT 5
|
||||
|
||||
|
||||
/*
|
||||
** Reader for generic 'load' function: 'lua_load' uses the
|
||||
** stack for internal stuff, so the reader cannot change the
|
||||
** stack top. Instead, it keeps its resulting string in a
|
||||
** reserved slot inside the stack.
|
||||
*/
|
||||
static const char *generic_reader (lua_State *L, void *ud, size_t *size) {
|
||||
(void)(ud); /* not used */
|
||||
luaL_checkstack(L, 2, "too many nested functions");
|
||||
lua_pushvalue(L, 1); /* get function */
|
||||
lua_call(L, 0, 1); /* call it */
|
||||
if (lua_isnil(L, -1)) {
|
||||
lua_pop(L, 1); /* pop result */
|
||||
*size = 0;
|
||||
return NULL;
|
||||
}
|
||||
else if (l_unlikely(!lua_isstring(L, -1)))
|
||||
luaL_error(L, "reader function must return a string");
|
||||
lua_replace(L, RESERVEDSLOT); /* save string in reserved slot */
|
||||
return lua_tolstring(L, RESERVEDSLOT, size);
|
||||
}
|
||||
|
||||
|
||||
static int luaB_load (lua_State *L) {
|
||||
int status;
|
||||
size_t l;
|
||||
const char *s = lua_tolstring(L, 1, &l);
|
||||
const char *mode = luaL_optstring(L, 3, "bt");
|
||||
int env = (!lua_isnone(L, 4) ? 4 : 0); /* 'env' index or 0 if no 'env' */
|
||||
if (s != NULL) { /* loading a string? */
|
||||
const char *chunkname = luaL_optstring(L, 2, s);
|
||||
status = luaL_loadbufferx(L, s, l, chunkname, mode);
|
||||
}
|
||||
else { /* loading from a reader function */
|
||||
const char *chunkname = luaL_optstring(L, 2, "=(load)");
|
||||
luaL_checktype(L, 1, LUA_TFUNCTION);
|
||||
lua_settop(L, RESERVEDSLOT); /* create reserved slot */
|
||||
status = lua_load(L, generic_reader, NULL, chunkname, mode);
|
||||
}
|
||||
return load_aux(L, status, env);
|
||||
}
|
||||
|
||||
/* }====================================================== */
|
||||
|
||||
|
||||
static int dofilecont (lua_State *L, int d1, lua_KContext d2) {
|
||||
(void)d1; (void)d2; /* only to match 'lua_Kfunction' prototype */
|
||||
return lua_gettop(L) - 1;
|
||||
}
|
||||
|
||||
|
||||
static int luaB_dofile (lua_State *L) {
|
||||
const char *fname = luaL_optstring(L, 1, NULL);
|
||||
lua_settop(L, 1);
|
||||
if (l_unlikely(luaL_loadfile(L, fname) != LUA_OK))
|
||||
return lua_error(L);
|
||||
lua_callk(L, 0, LUA_MULTRET, 0, dofilecont);
|
||||
return dofilecont(L, 0, 0);
|
||||
}
|
||||
|
||||
|
||||
static int luaB_assert (lua_State *L) {
|
||||
if (l_likely(lua_toboolean(L, 1))) /* condition is true? */
|
||||
return lua_gettop(L); /* return all arguments */
|
||||
else { /* error */
|
||||
luaL_checkany(L, 1); /* there must be a condition */
|
||||
lua_remove(L, 1); /* remove it */
|
||||
lua_pushliteral(L, "assertion failed!"); /* default message */
|
||||
lua_settop(L, 1); /* leave only message (default if no other one) */
|
||||
return luaB_error(L); /* call 'error' */
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static int luaB_select (lua_State *L) {
|
||||
int n = lua_gettop(L);
|
||||
if (lua_type(L, 1) == LUA_TSTRING && *lua_tostring(L, 1) == '#') {
|
||||
lua_pushinteger(L, n-1);
|
||||
return 1;
|
||||
}
|
||||
else {
|
||||
lua_Integer i = luaL_checkinteger(L, 1);
|
||||
if (i < 0) i = n + i;
|
||||
else if (i > n) i = n;
|
||||
luaL_argcheck(L, 1 <= i, 1, "index out of range");
|
||||
return n - (int)i;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Continuation function for 'pcall' and 'xpcall'. Both functions
|
||||
** already pushed a 'true' before doing the call, so in case of success
|
||||
** 'finishpcall' only has to return everything in the stack minus
|
||||
** 'extra' values (where 'extra' is exactly the number of items to be
|
||||
** ignored).
|
||||
*/
|
||||
static int finishpcall (lua_State *L, int status, lua_KContext extra) {
|
||||
if (l_unlikely(status != LUA_OK && status != LUA_YIELD)) { /* error? */
|
||||
lua_pushboolean(L, 0); /* first result (false) */
|
||||
lua_pushvalue(L, -2); /* error message */
|
||||
return 2; /* return false, msg */
|
||||
}
|
||||
else
|
||||
return lua_gettop(L) - (int)extra; /* return all results */
|
||||
}
|
||||
|
||||
|
||||
static int luaB_pcall (lua_State *L) {
|
||||
int status;
|
||||
luaL_checkany(L, 1);
|
||||
lua_pushboolean(L, 1); /* first result if no errors */
|
||||
lua_insert(L, 1); /* put it in place */
|
||||
status = lua_pcallk(L, lua_gettop(L) - 2, LUA_MULTRET, 0, 0, finishpcall);
|
||||
return finishpcall(L, status, 0);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Do a protected call with error handling. After 'lua_rotate', the
|
||||
** stack will have <f, err, true, f, [args...]>; so, the function passes
|
||||
** 2 to 'finishpcall' to skip the 2 first values when returning results.
|
||||
*/
|
||||
static int luaB_xpcall (lua_State *L) {
|
||||
int status;
|
||||
int n = lua_gettop(L);
|
||||
luaL_checktype(L, 2, LUA_TFUNCTION); /* check error function */
|
||||
lua_pushboolean(L, 1); /* first result */
|
||||
lua_pushvalue(L, 1); /* function */
|
||||
lua_rotate(L, 3, 2); /* move them below function's arguments */
|
||||
status = lua_pcallk(L, n - 2, LUA_MULTRET, 2, 2, finishpcall);
|
||||
return finishpcall(L, status, 2);
|
||||
}
|
||||
|
||||
|
||||
static int luaB_tostring (lua_State *L) {
|
||||
luaL_checkany(L, 1);
|
||||
luaL_tolstring(L, 1, NULL);
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
static const luaL_Reg base_funcs[] = {
|
||||
{"assert", luaB_assert},
|
||||
{"collectgarbage", luaB_collectgarbage},
|
||||
{"dofile", luaB_dofile},
|
||||
{"error", luaB_error},
|
||||
{"getmetatable", luaB_getmetatable},
|
||||
{"ipairs", luaB_ipairs},
|
||||
{"loadfile", luaB_loadfile},
|
||||
{"load", luaB_load},
|
||||
{"next", luaB_next},
|
||||
{"pairs", luaB_pairs},
|
||||
{"pcall", luaB_pcall},
|
||||
{"print", luaB_print},
|
||||
{"warn", luaB_warn},
|
||||
{"rawequal", luaB_rawequal},
|
||||
{"rawlen", luaB_rawlen},
|
||||
{"rawget", luaB_rawget},
|
||||
{"rawset", luaB_rawset},
|
||||
{"select", luaB_select},
|
||||
{"setmetatable", luaB_setmetatable},
|
||||
{"tonumber", luaB_tonumber},
|
||||
{"tostring", luaB_tostring},
|
||||
{"type", luaB_type},
|
||||
{"xpcall", luaB_xpcall},
|
||||
/* placeholders */
|
||||
{LUA_GNAME, NULL},
|
||||
{"_VERSION", NULL},
|
||||
{NULL, NULL}
|
||||
};
|
||||
|
||||
|
||||
LUAMOD_API int luaopen_base (lua_State *L) {
|
||||
/* open lib into global table */
|
||||
lua_pushglobaltable(L);
|
||||
luaL_setfuncs(L, base_funcs, 0);
|
||||
/* set global _G */
|
||||
lua_pushvalue(L, -1);
|
||||
lua_setfield(L, -2, LUA_GNAME);
|
||||
/* set global _VERSION */
|
||||
lua_pushliteral(L, LUA_VERSION);
|
||||
lua_setfield(L, -2, "_VERSION");
|
||||
return 1;
|
||||
}
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@ -1,101 +0,0 @@
|
||||
/*
|
||||
** $Id: lcode.h $
|
||||
** Code generator for Lua
|
||||
** See Copyright Notice in lua.h
|
||||
*/
|
||||
|
||||
#ifndef lcode_h
|
||||
#define lcode_h
|
||||
|
||||
#include "llex.h"
|
||||
#include "lobject.h"
|
||||
#include "lopcodes.h"
|
||||
#include "lparser.h"
|
||||
|
||||
|
||||
/*
|
||||
** Marks the end of a patch list. It is an invalid value both as an absolute
|
||||
** address, and as a list link (would link an element to itself).
|
||||
*/
|
||||
#define NO_JUMP (-1)
|
||||
|
||||
|
||||
/*
|
||||
** grep "ORDER OPR" if you change these enums (ORDER OP)
|
||||
*/
|
||||
typedef enum BinOpr {
|
||||
/* arithmetic operators */
|
||||
OPR_ADD, OPR_SUB, OPR_MUL, OPR_MOD, OPR_POW,
|
||||
OPR_DIV, OPR_IDIV,
|
||||
/* bitwise operators */
|
||||
OPR_BAND, OPR_BOR, OPR_BXOR,
|
||||
OPR_SHL, OPR_SHR,
|
||||
/* string operator */
|
||||
OPR_CONCAT,
|
||||
/* comparison operators */
|
||||
OPR_EQ, OPR_LT, OPR_LE,
|
||||
OPR_NE, OPR_GT, OPR_GE,
|
||||
/* logical operators */
|
||||
OPR_AND, OPR_OR,
|
||||
OPR_NOBINOPR
|
||||
} BinOpr;
|
||||
|
||||
|
||||
/* true if operation is foldable (that is, it is arithmetic or bitwise) */
|
||||
#define foldbinop(op) ((op) <= OPR_SHR)
|
||||
|
||||
|
||||
#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0)
|
||||
|
||||
|
||||
typedef enum UnOpr { OPR_MINUS, OPR_BNOT, OPR_NOT, OPR_LEN, OPR_NOUNOPR } UnOpr;
|
||||
|
||||
|
||||
/* get (pointer to) instruction of given 'expdesc' */
|
||||
#define getinstruction(fs,e) ((fs)->f->code[(e)->u.info])
|
||||
|
||||
|
||||
#define luaK_setmultret(fs,e) luaK_setreturns(fs, e, LUA_MULTRET)
|
||||
|
||||
#define luaK_jumpto(fs,t) luaK_patchlist(fs, luaK_jump(fs), t)
|
||||
|
||||
LUAI_FUNC int luaK_code (FuncState *fs, Instruction i);
|
||||
LUAI_FUNC int luaK_codeABx (FuncState *fs, OpCode o, int A, unsigned int Bx);
|
||||
LUAI_FUNC int luaK_codeABCk (FuncState *fs, OpCode o, int A,
|
||||
int B, int C, int k);
|
||||
LUAI_FUNC int luaK_exp2const (FuncState *fs, const expdesc *e, TValue *v);
|
||||
LUAI_FUNC void luaK_fixline (FuncState *fs, int line);
|
||||
LUAI_FUNC void luaK_nil (FuncState *fs, int from, int n);
|
||||
LUAI_FUNC void luaK_reserveregs (FuncState *fs, int n);
|
||||
LUAI_FUNC void luaK_checkstack (FuncState *fs, int n);
|
||||
LUAI_FUNC void luaK_int (FuncState *fs, int reg, lua_Integer n);
|
||||
LUAI_FUNC void luaK_dischargevars (FuncState *fs, expdesc *e);
|
||||
LUAI_FUNC int luaK_exp2anyreg (FuncState *fs, expdesc *e);
|
||||
LUAI_FUNC void luaK_exp2anyregup (FuncState *fs, expdesc *e);
|
||||
LUAI_FUNC void luaK_exp2nextreg (FuncState *fs, expdesc *e);
|
||||
LUAI_FUNC void luaK_exp2val (FuncState *fs, expdesc *e);
|
||||
LUAI_FUNC void luaK_self (FuncState *fs, expdesc *e, expdesc *key);
|
||||
LUAI_FUNC void luaK_indexed (FuncState *fs, expdesc *t, expdesc *k);
|
||||
LUAI_FUNC void luaK_goiftrue (FuncState *fs, expdesc *e);
|
||||
LUAI_FUNC void luaK_goiffalse (FuncState *fs, expdesc *e);
|
||||
LUAI_FUNC void luaK_storevar (FuncState *fs, expdesc *var, expdesc *e);
|
||||
LUAI_FUNC void luaK_setreturns (FuncState *fs, expdesc *e, int nresults);
|
||||
LUAI_FUNC void luaK_setoneret (FuncState *fs, expdesc *e);
|
||||
LUAI_FUNC int luaK_jump (FuncState *fs);
|
||||
LUAI_FUNC void luaK_ret (FuncState *fs, int first, int nret);
|
||||
LUAI_FUNC void luaK_patchlist (FuncState *fs, int list, int target);
|
||||
LUAI_FUNC void luaK_patchtohere (FuncState *fs, int list);
|
||||
LUAI_FUNC void luaK_concat (FuncState *fs, int *l1, int l2);
|
||||
LUAI_FUNC int luaK_getlabel (FuncState *fs);
|
||||
LUAI_FUNC void luaK_prefix (FuncState *fs, UnOpr op, expdesc *v, int line);
|
||||
LUAI_FUNC void luaK_infix (FuncState *fs, BinOpr op, expdesc *v);
|
||||
LUAI_FUNC void luaK_posfix (FuncState *fs, BinOpr op, expdesc *v1,
|
||||
expdesc *v2, int line);
|
||||
LUAI_FUNC void luaK_settablesize (FuncState *fs, int pc,
|
||||
int ra, int asize, int hsize);
|
||||
LUAI_FUNC void luaK_setlist (FuncState *fs, int base, int nelems, int tostore);
|
||||
LUAI_FUNC void luaK_finish (FuncState *fs);
|
||||
LUAI_FUNC l_noret luaK_semerror (LexState *ls, const char *msg);
|
||||
|
||||
|
||||
#endif
|
||||
@ -1,210 +0,0 @@
|
||||
/*
|
||||
** $Id: lcorolib.c $
|
||||
** Coroutine Library
|
||||
** See Copyright Notice in lua.h
|
||||
*/
|
||||
|
||||
#define lcorolib_c
|
||||
#define LUA_LIB
|
||||
|
||||
#include "lprefix.h"
|
||||
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "lua.h"
|
||||
|
||||
#include "lauxlib.h"
|
||||
#include "lualib.h"
|
||||
|
||||
|
||||
static lua_State *getco (lua_State *L) {
|
||||
lua_State *co = lua_tothread(L, 1);
|
||||
luaL_argexpected(L, co, 1, "thread");
|
||||
return co;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Resumes a coroutine. Returns the number of results for non-error
|
||||
** cases or -1 for errors.
|
||||
*/
|
||||
static int auxresume (lua_State *L, lua_State *co, int narg) {
|
||||
int status, nres;
|
||||
if (l_unlikely(!lua_checkstack(co, narg))) {
|
||||
lua_pushliteral(L, "too many arguments to resume");
|
||||
return -1; /* error flag */
|
||||
}
|
||||
lua_xmove(L, co, narg);
|
||||
status = lua_resume(co, L, narg, &nres);
|
||||
if (l_likely(status == LUA_OK || status == LUA_YIELD)) {
|
||||
if (l_unlikely(!lua_checkstack(L, nres + 1))) {
|
||||
lua_pop(co, nres); /* remove results anyway */
|
||||
lua_pushliteral(L, "too many results to resume");
|
||||
return -1; /* error flag */
|
||||
}
|
||||
lua_xmove(co, L, nres); /* move yielded values */
|
||||
return nres;
|
||||
}
|
||||
else {
|
||||
lua_xmove(co, L, 1); /* move error message */
|
||||
return -1; /* error flag */
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static int luaB_coresume (lua_State *L) {
|
||||
lua_State *co = getco(L);
|
||||
int r;
|
||||
r = auxresume(L, co, lua_gettop(L) - 1);
|
||||
if (l_unlikely(r < 0)) {
|
||||
lua_pushboolean(L, 0);
|
||||
lua_insert(L, -2);
|
||||
return 2; /* return false + error message */
|
||||
}
|
||||
else {
|
||||
lua_pushboolean(L, 1);
|
||||
lua_insert(L, -(r + 1));
|
||||
return r + 1; /* return true + 'resume' returns */
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static int luaB_auxwrap (lua_State *L) {
|
||||
lua_State *co = lua_tothread(L, lua_upvalueindex(1));
|
||||
int r = auxresume(L, co, lua_gettop(L));
|
||||
if (l_unlikely(r < 0)) { /* error? */
|
||||
int stat = lua_status(co);
|
||||
if (stat != LUA_OK && stat != LUA_YIELD) { /* error in the coroutine? */
|
||||
stat = lua_closethread(co, L); /* close its tbc variables */
|
||||
lua_assert(stat != LUA_OK);
|
||||
lua_xmove(co, L, 1); /* move error message to the caller */
|
||||
}
|
||||
if (stat != LUA_ERRMEM && /* not a memory error and ... */
|
||||
lua_type(L, -1) == LUA_TSTRING) { /* ... error object is a string? */
|
||||
luaL_where(L, 1); /* add extra info, if available */
|
||||
lua_insert(L, -2);
|
||||
lua_concat(L, 2);
|
||||
}
|
||||
return lua_error(L); /* propagate error */
|
||||
}
|
||||
return r;
|
||||
}
|
||||
|
||||
|
||||
static int luaB_cocreate (lua_State *L) {
|
||||
lua_State *NL;
|
||||
luaL_checktype(L, 1, LUA_TFUNCTION);
|
||||
NL = lua_newthread(L);
|
||||
lua_pushvalue(L, 1); /* move function to top */
|
||||
lua_xmove(L, NL, 1); /* move function from L to NL */
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
static int luaB_cowrap (lua_State *L) {
|
||||
luaB_cocreate(L);
|
||||
lua_pushcclosure(L, luaB_auxwrap, 1);
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
static int luaB_yield (lua_State *L) {
|
||||
return lua_yield(L, lua_gettop(L));
|
||||
}
|
||||
|
||||
|
||||
#define COS_RUN 0
|
||||
#define COS_DEAD 1
|
||||
#define COS_YIELD 2
|
||||
#define COS_NORM 3
|
||||
|
||||
|
||||
static const char *const statname[] =
|
||||
{"running", "dead", "suspended", "normal"};
|
||||
|
||||
|
||||
static int auxstatus (lua_State *L, lua_State *co) {
|
||||
if (L == co) return COS_RUN;
|
||||
else {
|
||||
switch (lua_status(co)) {
|
||||
case LUA_YIELD:
|
||||
return COS_YIELD;
|
||||
case LUA_OK: {
|
||||
lua_Debug ar;
|
||||
if (lua_getstack(co, 0, &ar)) /* does it have frames? */
|
||||
return COS_NORM; /* it is running */
|
||||
else if (lua_gettop(co) == 0)
|
||||
return COS_DEAD;
|
||||
else
|
||||
return COS_YIELD; /* initial state */
|
||||
}
|
||||
default: /* some error occurred */
|
||||
return COS_DEAD;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static int luaB_costatus (lua_State *L) {
|
||||
lua_State *co = getco(L);
|
||||
lua_pushstring(L, statname[auxstatus(L, co)]);
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
static int luaB_yieldable (lua_State *L) {
|
||||
lua_State *co = lua_isnone(L, 1) ? L : getco(L);
|
||||
lua_pushboolean(L, lua_isyieldable(co));
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
static int luaB_corunning (lua_State *L) {
|
||||
int ismain = lua_pushthread(L);
|
||||
lua_pushboolean(L, ismain);
|
||||
return 2;
|
||||
}
|
||||
|
||||
|
||||
static int luaB_close (lua_State *L) {
|
||||
lua_State *co = getco(L);
|
||||
int status = auxstatus(L, co);
|
||||
switch (status) {
|
||||
case COS_DEAD: case COS_YIELD: {
|
||||
status = lua_closethread(co, L);
|
||||
if (status == LUA_OK) {
|
||||
lua_pushboolean(L, 1);
|
||||
return 1;
|
||||
}
|
||||
else {
|
||||
lua_pushboolean(L, 0);
|
||||
lua_xmove(co, L, 1); /* move error message */
|
||||
return 2;
|
||||
}
|
||||
}
|
||||
default: /* normal or running coroutine */
|
||||
return luaL_error(L, "cannot close a %s coroutine", statname[status]);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static const luaL_Reg co_funcs[] = {
|
||||
{"create", luaB_cocreate},
|
||||
{"resume", luaB_coresume},
|
||||
{"running", luaB_corunning},
|
||||
{"status", luaB_costatus},
|
||||
{"wrap", luaB_cowrap},
|
||||
{"yield", luaB_yield},
|
||||
{"isyieldable", luaB_yieldable},
|
||||
{"close", luaB_close},
|
||||
{NULL, NULL}
|
||||
};
|
||||
|
||||
|
||||
|
||||
LUAMOD_API int luaopen_coroutine (lua_State *L) {
|
||||
luaL_newlib(L, co_funcs);
|
||||
return 1;
|
||||
}
|
||||
|
||||
@ -1,64 +0,0 @@
|
||||
/*
|
||||
** $Id: lctype.c $
|
||||
** 'ctype' functions for Lua
|
||||
** See Copyright Notice in lua.h
|
||||
*/
|
||||
|
||||
#define lctype_c
|
||||
#define LUA_CORE
|
||||
|
||||
#include "lprefix.h"
|
||||
|
||||
|
||||
#include "lctype.h"
|
||||
|
||||
#if !LUA_USE_CTYPE /* { */
|
||||
|
||||
#include <limits.h>
|
||||
|
||||
|
||||
#if defined (LUA_UCID) /* accept UniCode IDentifiers? */
|
||||
/* consider all non-ascii codepoints to be alphabetic */
|
||||
#define NONA 0x01
|
||||
#else
|
||||
#define NONA 0x00 /* default */
|
||||
#endif
|
||||
|
||||
|
||||
LUAI_DDEF const lu_byte luai_ctype_[UCHAR_MAX + 2] = {
|
||||
0x00, /* EOZ */
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0. */
|
||||
0x00, 0x08, 0x08, 0x08, 0x08, 0x08, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 1. */
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x0c, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, /* 2. */
|
||||
0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
|
||||
0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, /* 3. */
|
||||
0x16, 0x16, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
|
||||
0x04, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x05, /* 4. */
|
||||
0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
|
||||
0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, /* 5. */
|
||||
0x05, 0x05, 0x05, 0x04, 0x04, 0x04, 0x04, 0x05,
|
||||
0x04, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x05, /* 6. */
|
||||
0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
|
||||
0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, /* 7. */
|
||||
0x05, 0x05, 0x05, 0x04, 0x04, 0x04, 0x04, 0x00,
|
||||
NONA, NONA, NONA, NONA, NONA, NONA, NONA, NONA, /* 8. */
|
||||
NONA, NONA, NONA, NONA, NONA, NONA, NONA, NONA,
|
||||
NONA, NONA, NONA, NONA, NONA, NONA, NONA, NONA, /* 9. */
|
||||
NONA, NONA, NONA, NONA, NONA, NONA, NONA, NONA,
|
||||
NONA, NONA, NONA, NONA, NONA, NONA, NONA, NONA, /* a. */
|
||||
NONA, NONA, NONA, NONA, NONA, NONA, NONA, NONA,
|
||||
NONA, NONA, NONA, NONA, NONA, NONA, NONA, NONA, /* b. */
|
||||
NONA, NONA, NONA, NONA, NONA, NONA, NONA, NONA,
|
||||
0x00, 0x00, NONA, NONA, NONA, NONA, NONA, NONA, /* c. */
|
||||
NONA, NONA, NONA, NONA, NONA, NONA, NONA, NONA,
|
||||
NONA, NONA, NONA, NONA, NONA, NONA, NONA, NONA, /* d. */
|
||||
NONA, NONA, NONA, NONA, NONA, NONA, NONA, NONA,
|
||||
NONA, NONA, NONA, NONA, NONA, NONA, NONA, NONA, /* e. */
|
||||
NONA, NONA, NONA, NONA, NONA, NONA, NONA, NONA,
|
||||
NONA, NONA, NONA, NONA, NONA, 0x00, 0x00, 0x00, /* f. */
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
|
||||
};
|
||||
|
||||
#endif /* } */
|
||||
@ -1,101 +0,0 @@
|
||||
/*
|
||||
** $Id: lctype.h $
|
||||
** 'ctype' functions for Lua
|
||||
** See Copyright Notice in lua.h
|
||||
*/
|
||||
|
||||
#ifndef lctype_h
|
||||
#define lctype_h
|
||||
|
||||
#include "lua.h"
|
||||
|
||||
|
||||
/*
|
||||
** WARNING: the functions defined here do not necessarily correspond
|
||||
** to the similar functions in the standard C ctype.h. They are
|
||||
** optimized for the specific needs of Lua.
|
||||
*/
|
||||
|
||||
#if !defined(LUA_USE_CTYPE)
|
||||
|
||||
#if 'A' == 65 && '0' == 48
|
||||
/* ASCII case: can use its own tables; faster and fixed */
|
||||
#define LUA_USE_CTYPE 0
|
||||
#else
|
||||
/* must use standard C ctype */
|
||||
#define LUA_USE_CTYPE 1
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
#if !LUA_USE_CTYPE /* { */
|
||||
|
||||
#include <limits.h>
|
||||
|
||||
#include "llimits.h"
|
||||
|
||||
|
||||
#define ALPHABIT 0
|
||||
#define DIGITBIT 1
|
||||
#define PRINTBIT 2
|
||||
#define SPACEBIT 3
|
||||
#define XDIGITBIT 4
|
||||
|
||||
|
||||
#define MASK(B) (1 << (B))
|
||||
|
||||
|
||||
/*
|
||||
** add 1 to char to allow index -1 (EOZ)
|
||||
*/
|
||||
#define testprop(c,p) (luai_ctype_[(c)+1] & (p))
|
||||
|
||||
/*
|
||||
** 'lalpha' (Lua alphabetic) and 'lalnum' (Lua alphanumeric) both include '_'
|
||||
*/
|
||||
#define lislalpha(c) testprop(c, MASK(ALPHABIT))
|
||||
#define lislalnum(c) testprop(c, (MASK(ALPHABIT) | MASK(DIGITBIT)))
|
||||
#define lisdigit(c) testprop(c, MASK(DIGITBIT))
|
||||
#define lisspace(c) testprop(c, MASK(SPACEBIT))
|
||||
#define lisprint(c) testprop(c, MASK(PRINTBIT))
|
||||
#define lisxdigit(c) testprop(c, MASK(XDIGITBIT))
|
||||
|
||||
|
||||
/*
|
||||
** In ASCII, this 'ltolower' is correct for alphabetic characters and
|
||||
** for '.'. That is enough for Lua needs. ('check_exp' ensures that
|
||||
** the character either is an upper-case letter or is unchanged by
|
||||
** the transformation, which holds for lower-case letters and '.'.)
|
||||
*/
|
||||
#define ltolower(c) \
|
||||
check_exp(('A' <= (c) && (c) <= 'Z') || (c) == ((c) | ('A' ^ 'a')), \
|
||||
(c) | ('A' ^ 'a'))
|
||||
|
||||
|
||||
/* one entry for each character and for -1 (EOZ) */
|
||||
LUAI_DDEC(const lu_byte luai_ctype_[UCHAR_MAX + 2];)
|
||||
|
||||
|
||||
#else /* }{ */
|
||||
|
||||
/*
|
||||
** use standard C ctypes
|
||||
*/
|
||||
|
||||
#include <ctype.h>
|
||||
|
||||
|
||||
#define lislalpha(c) (isalpha(c) || (c) == '_')
|
||||
#define lislalnum(c) (isalnum(c) || (c) == '_')
|
||||
#define lisdigit(c) (isdigit(c))
|
||||
#define lisspace(c) (isspace(c))
|
||||
#define lisprint(c) (isprint(c))
|
||||
#define lisxdigit(c) (isxdigit(c))
|
||||
|
||||
#define ltolower(c) (tolower(c))
|
||||
|
||||
#endif /* } */
|
||||
|
||||
#endif
|
||||
|
||||
@ -1,483 +0,0 @@
|
||||
/*
|
||||
** $Id: ldblib.c $
|
||||
** Interface from Lua to its debug API
|
||||
** See Copyright Notice in lua.h
|
||||
*/
|
||||
|
||||
#define ldblib_c
|
||||
#define LUA_LIB
|
||||
|
||||
#include "lprefix.h"
|
||||
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "lua.h"
|
||||
|
||||
#include "lauxlib.h"
|
||||
#include "lualib.h"
|
||||
|
||||
|
||||
/*
|
||||
** The hook table at registry[HOOKKEY] maps threads to their current
|
||||
** hook function.
|
||||
*/
|
||||
static const char *const HOOKKEY = "_HOOKKEY";
|
||||
|
||||
|
||||
/*
|
||||
** If L1 != L, L1 can be in any state, and therefore there are no
|
||||
** guarantees about its stack space; any push in L1 must be
|
||||
** checked.
|
||||
*/
|
||||
static void checkstack (lua_State *L, lua_State *L1, int n) {
|
||||
if (l_unlikely(L != L1 && !lua_checkstack(L1, n)))
|
||||
luaL_error(L, "stack overflow");
|
||||
}
|
||||
|
||||
|
||||
static int db_getregistry (lua_State *L) {
|
||||
lua_pushvalue(L, LUA_REGISTRYINDEX);
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
static int db_getmetatable (lua_State *L) {
|
||||
luaL_checkany(L, 1);
|
||||
if (!lua_getmetatable(L, 1)) {
|
||||
lua_pushnil(L); /* no metatable */
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
static int db_setmetatable (lua_State *L) {
|
||||
int t = lua_type(L, 2);
|
||||
luaL_argexpected(L, t == LUA_TNIL || t == LUA_TTABLE, 2, "nil or table");
|
||||
lua_settop(L, 2);
|
||||
lua_setmetatable(L, 1);
|
||||
return 1; /* return 1st argument */
|
||||
}
|
||||
|
||||
|
||||
static int db_getuservalue (lua_State *L) {
|
||||
int n = (int)luaL_optinteger(L, 2, 1);
|
||||
if (lua_type(L, 1) != LUA_TUSERDATA)
|
||||
luaL_pushfail(L);
|
||||
else if (lua_getiuservalue(L, 1, n) != LUA_TNONE) {
|
||||
lua_pushboolean(L, 1);
|
||||
return 2;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
static int db_setuservalue (lua_State *L) {
|
||||
int n = (int)luaL_optinteger(L, 3, 1);
|
||||
luaL_checktype(L, 1, LUA_TUSERDATA);
|
||||
luaL_checkany(L, 2);
|
||||
lua_settop(L, 2);
|
||||
if (!lua_setiuservalue(L, 1, n))
|
||||
luaL_pushfail(L);
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Auxiliary function used by several library functions: check for
|
||||
** an optional thread as function's first argument and set 'arg' with
|
||||
** 1 if this argument is present (so that functions can skip it to
|
||||
** access their other arguments)
|
||||
*/
|
||||
static lua_State *getthread (lua_State *L, int *arg) {
|
||||
if (lua_isthread(L, 1)) {
|
||||
*arg = 1;
|
||||
return lua_tothread(L, 1);
|
||||
}
|
||||
else {
|
||||
*arg = 0;
|
||||
return L; /* function will operate over current thread */
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Variations of 'lua_settable', used by 'db_getinfo' to put results
|
||||
** from 'lua_getinfo' into result table. Key is always a string;
|
||||
** value can be a string, an int, or a boolean.
|
||||
*/
|
||||
static void settabss (lua_State *L, const char *k, const char *v) {
|
||||
lua_pushstring(L, v);
|
||||
lua_setfield(L, -2, k);
|
||||
}
|
||||
|
||||
static void settabsi (lua_State *L, const char *k, int v) {
|
||||
lua_pushinteger(L, v);
|
||||
lua_setfield(L, -2, k);
|
||||
}
|
||||
|
||||
static void settabsb (lua_State *L, const char *k, int v) {
|
||||
lua_pushboolean(L, v);
|
||||
lua_setfield(L, -2, k);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** In function 'db_getinfo', the call to 'lua_getinfo' may push
|
||||
** results on the stack; later it creates the result table to put
|
||||
** these objects. Function 'treatstackoption' puts the result from
|
||||
** 'lua_getinfo' on top of the result table so that it can call
|
||||
** 'lua_setfield'.
|
||||
*/
|
||||
static void treatstackoption (lua_State *L, lua_State *L1, const char *fname) {
|
||||
if (L == L1)
|
||||
lua_rotate(L, -2, 1); /* exchange object and table */
|
||||
else
|
||||
lua_xmove(L1, L, 1); /* move object to the "main" stack */
|
||||
lua_setfield(L, -2, fname); /* put object into table */
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Calls 'lua_getinfo' and collects all results in a new table.
|
||||
** L1 needs stack space for an optional input (function) plus
|
||||
** two optional outputs (function and line table) from function
|
||||
** 'lua_getinfo'.
|
||||
*/
|
||||
static int db_getinfo (lua_State *L) {
|
||||
lua_Debug ar;
|
||||
int arg;
|
||||
lua_State *L1 = getthread(L, &arg);
|
||||
const char *options = luaL_optstring(L, arg+2, "flnSrtu");
|
||||
checkstack(L, L1, 3);
|
||||
luaL_argcheck(L, options[0] != '>', arg + 2, "invalid option '>'");
|
||||
if (lua_isfunction(L, arg + 1)) { /* info about a function? */
|
||||
options = lua_pushfstring(L, ">%s", options); /* add '>' to 'options' */
|
||||
lua_pushvalue(L, arg + 1); /* move function to 'L1' stack */
|
||||
lua_xmove(L, L1, 1);
|
||||
}
|
||||
else { /* stack level */
|
||||
if (!lua_getstack(L1, (int)luaL_checkinteger(L, arg + 1), &ar)) {
|
||||
luaL_pushfail(L); /* level out of range */
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
if (!lua_getinfo(L1, options, &ar))
|
||||
return luaL_argerror(L, arg+2, "invalid option");
|
||||
lua_newtable(L); /* table to collect results */
|
||||
if (strchr(options, 'S')) {
|
||||
lua_pushlstring(L, ar.source, ar.srclen);
|
||||
lua_setfield(L, -2, "source");
|
||||
settabss(L, "short_src", ar.short_src);
|
||||
settabsi(L, "linedefined", ar.linedefined);
|
||||
settabsi(L, "lastlinedefined", ar.lastlinedefined);
|
||||
settabss(L, "what", ar.what);
|
||||
}
|
||||
if (strchr(options, 'l'))
|
||||
settabsi(L, "currentline", ar.currentline);
|
||||
if (strchr(options, 'u')) {
|
||||
settabsi(L, "nups", ar.nups);
|
||||
settabsi(L, "nparams", ar.nparams);
|
||||
settabsb(L, "isvararg", ar.isvararg);
|
||||
}
|
||||
if (strchr(options, 'n')) {
|
||||
settabss(L, "name", ar.name);
|
||||
settabss(L, "namewhat", ar.namewhat);
|
||||
}
|
||||
if (strchr(options, 'r')) {
|
||||
settabsi(L, "ftransfer", ar.ftransfer);
|
||||
settabsi(L, "ntransfer", ar.ntransfer);
|
||||
}
|
||||
if (strchr(options, 't'))
|
||||
settabsb(L, "istailcall", ar.istailcall);
|
||||
if (strchr(options, 'L'))
|
||||
treatstackoption(L, L1, "activelines");
|
||||
if (strchr(options, 'f'))
|
||||
treatstackoption(L, L1, "func");
|
||||
return 1; /* return table */
|
||||
}
|
||||
|
||||
|
||||
static int db_getlocal (lua_State *L) {
|
||||
int arg;
|
||||
lua_State *L1 = getthread(L, &arg);
|
||||
int nvar = (int)luaL_checkinteger(L, arg + 2); /* local-variable index */
|
||||
if (lua_isfunction(L, arg + 1)) { /* function argument? */
|
||||
lua_pushvalue(L, arg + 1); /* push function */
|
||||
lua_pushstring(L, lua_getlocal(L, NULL, nvar)); /* push local name */
|
||||
return 1; /* return only name (there is no value) */
|
||||
}
|
||||
else { /* stack-level argument */
|
||||
lua_Debug ar;
|
||||
const char *name;
|
||||
int level = (int)luaL_checkinteger(L, arg + 1);
|
||||
if (l_unlikely(!lua_getstack(L1, level, &ar))) /* out of range? */
|
||||
return luaL_argerror(L, arg+1, "level out of range");
|
||||
checkstack(L, L1, 1);
|
||||
name = lua_getlocal(L1, &ar, nvar);
|
||||
if (name) {
|
||||
lua_xmove(L1, L, 1); /* move local value */
|
||||
lua_pushstring(L, name); /* push name */
|
||||
lua_rotate(L, -2, 1); /* re-order */
|
||||
return 2;
|
||||
}
|
||||
else {
|
||||
luaL_pushfail(L); /* no name (nor value) */
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static int db_setlocal (lua_State *L) {
|
||||
int arg;
|
||||
const char *name;
|
||||
lua_State *L1 = getthread(L, &arg);
|
||||
lua_Debug ar;
|
||||
int level = (int)luaL_checkinteger(L, arg + 1);
|
||||
int nvar = (int)luaL_checkinteger(L, arg + 2);
|
||||
if (l_unlikely(!lua_getstack(L1, level, &ar))) /* out of range? */
|
||||
return luaL_argerror(L, arg+1, "level out of range");
|
||||
luaL_checkany(L, arg+3);
|
||||
lua_settop(L, arg+3);
|
||||
checkstack(L, L1, 1);
|
||||
lua_xmove(L, L1, 1);
|
||||
name = lua_setlocal(L1, &ar, nvar);
|
||||
if (name == NULL)
|
||||
lua_pop(L1, 1); /* pop value (if not popped by 'lua_setlocal') */
|
||||
lua_pushstring(L, name);
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** get (if 'get' is true) or set an upvalue from a closure
|
||||
*/
|
||||
static int auxupvalue (lua_State *L, int get) {
|
||||
const char *name;
|
||||
int n = (int)luaL_checkinteger(L, 2); /* upvalue index */
|
||||
luaL_checktype(L, 1, LUA_TFUNCTION); /* closure */
|
||||
name = get ? lua_getupvalue(L, 1, n) : lua_setupvalue(L, 1, n);
|
||||
if (name == NULL) return 0;
|
||||
lua_pushstring(L, name);
|
||||
lua_insert(L, -(get+1)); /* no-op if get is false */
|
||||
return get + 1;
|
||||
}
|
||||
|
||||
|
||||
static int db_getupvalue (lua_State *L) {
|
||||
return auxupvalue(L, 1);
|
||||
}
|
||||
|
||||
|
||||
static int db_setupvalue (lua_State *L) {
|
||||
luaL_checkany(L, 3);
|
||||
return auxupvalue(L, 0);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Check whether a given upvalue from a given closure exists and
|
||||
** returns its index
|
||||
*/
|
||||
static void *checkupval (lua_State *L, int argf, int argnup, int *pnup) {
|
||||
void *id;
|
||||
int nup = (int)luaL_checkinteger(L, argnup); /* upvalue index */
|
||||
luaL_checktype(L, argf, LUA_TFUNCTION); /* closure */
|
||||
id = lua_upvalueid(L, argf, nup);
|
||||
if (pnup) {
|
||||
luaL_argcheck(L, id != NULL, argnup, "invalid upvalue index");
|
||||
*pnup = nup;
|
||||
}
|
||||
return id;
|
||||
}
|
||||
|
||||
|
||||
static int db_upvalueid (lua_State *L) {
|
||||
void *id = checkupval(L, 1, 2, NULL);
|
||||
if (id != NULL)
|
||||
lua_pushlightuserdata(L, id);
|
||||
else
|
||||
luaL_pushfail(L);
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
static int db_upvaluejoin (lua_State *L) {
|
||||
int n1, n2;
|
||||
checkupval(L, 1, 2, &n1);
|
||||
checkupval(L, 3, 4, &n2);
|
||||
luaL_argcheck(L, !lua_iscfunction(L, 1), 1, "Lua function expected");
|
||||
luaL_argcheck(L, !lua_iscfunction(L, 3), 3, "Lua function expected");
|
||||
lua_upvaluejoin(L, 1, n1, 3, n2);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Call hook function registered at hook table for the current
|
||||
** thread (if there is one)
|
||||
*/
|
||||
static void hookf (lua_State *L, lua_Debug *ar) {
|
||||
static const char *const hooknames[] =
|
||||
{"call", "return", "line", "count", "tail call"};
|
||||
lua_getfield(L, LUA_REGISTRYINDEX, HOOKKEY);
|
||||
lua_pushthread(L);
|
||||
if (lua_rawget(L, -2) == LUA_TFUNCTION) { /* is there a hook function? */
|
||||
lua_pushstring(L, hooknames[(int)ar->event]); /* push event name */
|
||||
if (ar->currentline >= 0)
|
||||
lua_pushinteger(L, ar->currentline); /* push current line */
|
||||
else lua_pushnil(L);
|
||||
lua_assert(lua_getinfo(L, "lS", ar));
|
||||
lua_call(L, 2, 0); /* call hook function */
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Convert a string mask (for 'sethook') into a bit mask
|
||||
*/
|
||||
static int makemask (const char *smask, int count) {
|
||||
int mask = 0;
|
||||
if (strchr(smask, 'c')) mask |= LUA_MASKCALL;
|
||||
if (strchr(smask, 'r')) mask |= LUA_MASKRET;
|
||||
if (strchr(smask, 'l')) mask |= LUA_MASKLINE;
|
||||
if (count > 0) mask |= LUA_MASKCOUNT;
|
||||
return mask;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Convert a bit mask (for 'gethook') into a string mask
|
||||
*/
|
||||
static char *unmakemask (int mask, char *smask) {
|
||||
int i = 0;
|
||||
if (mask & LUA_MASKCALL) smask[i++] = 'c';
|
||||
if (mask & LUA_MASKRET) smask[i++] = 'r';
|
||||
if (mask & LUA_MASKLINE) smask[i++] = 'l';
|
||||
smask[i] = '\0';
|
||||
return smask;
|
||||
}
|
||||
|
||||
|
||||
static int db_sethook (lua_State *L) {
|
||||
int arg, mask, count;
|
||||
lua_Hook func;
|
||||
lua_State *L1 = getthread(L, &arg);
|
||||
if (lua_isnoneornil(L, arg+1)) { /* no hook? */
|
||||
lua_settop(L, arg+1);
|
||||
func = NULL; mask = 0; count = 0; /* turn off hooks */
|
||||
}
|
||||
else {
|
||||
const char *smask = luaL_checkstring(L, arg+2);
|
||||
luaL_checktype(L, arg+1, LUA_TFUNCTION);
|
||||
count = (int)luaL_optinteger(L, arg + 3, 0);
|
||||
func = hookf; mask = makemask(smask, count);
|
||||
}
|
||||
if (!luaL_getsubtable(L, LUA_REGISTRYINDEX, HOOKKEY)) {
|
||||
/* table just created; initialize it */
|
||||
lua_pushliteral(L, "k");
|
||||
lua_setfield(L, -2, "__mode"); /** hooktable.__mode = "k" */
|
||||
lua_pushvalue(L, -1);
|
||||
lua_setmetatable(L, -2); /* metatable(hooktable) = hooktable */
|
||||
}
|
||||
checkstack(L, L1, 1);
|
||||
lua_pushthread(L1); lua_xmove(L1, L, 1); /* key (thread) */
|
||||
lua_pushvalue(L, arg + 1); /* value (hook function) */
|
||||
lua_rawset(L, -3); /* hooktable[L1] = new Lua hook */
|
||||
lua_sethook(L1, func, mask, count);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
static int db_gethook (lua_State *L) {
|
||||
int arg;
|
||||
lua_State *L1 = getthread(L, &arg);
|
||||
char buff[5];
|
||||
int mask = lua_gethookmask(L1);
|
||||
lua_Hook hook = lua_gethook(L1);
|
||||
if (hook == NULL) { /* no hook? */
|
||||
luaL_pushfail(L);
|
||||
return 1;
|
||||
}
|
||||
else if (hook != hookf) /* external hook? */
|
||||
lua_pushliteral(L, "external hook");
|
||||
else { /* hook table must exist */
|
||||
lua_getfield(L, LUA_REGISTRYINDEX, HOOKKEY);
|
||||
checkstack(L, L1, 1);
|
||||
lua_pushthread(L1); lua_xmove(L1, L, 1);
|
||||
lua_rawget(L, -2); /* 1st result = hooktable[L1] */
|
||||
lua_remove(L, -2); /* remove hook table */
|
||||
}
|
||||
lua_pushstring(L, unmakemask(mask, buff)); /* 2nd result = mask */
|
||||
lua_pushinteger(L, lua_gethookcount(L1)); /* 3rd result = count */
|
||||
return 3;
|
||||
}
|
||||
|
||||
|
||||
static int db_debug (lua_State *L) {
|
||||
for (;;) {
|
||||
char buffer[250];
|
||||
lua_writestringerror("%s", "lua_debug> ");
|
||||
if (fgets(buffer, sizeof(buffer), stdin) == NULL ||
|
||||
strcmp(buffer, "cont\n") == 0)
|
||||
return 0;
|
||||
if (luaL_loadbuffer(L, buffer, strlen(buffer), "=(debug command)") ||
|
||||
lua_pcall(L, 0, 0, 0))
|
||||
lua_writestringerror("%s\n", luaL_tolstring(L, -1, NULL));
|
||||
lua_settop(L, 0); /* remove eventual returns */
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static int db_traceback (lua_State *L) {
|
||||
int arg;
|
||||
lua_State *L1 = getthread(L, &arg);
|
||||
const char *msg = lua_tostring(L, arg + 1);
|
||||
if (msg == NULL && !lua_isnoneornil(L, arg + 1)) /* non-string 'msg'? */
|
||||
lua_pushvalue(L, arg + 1); /* return it untouched */
|
||||
else {
|
||||
int level = (int)luaL_optinteger(L, arg + 2, (L == L1) ? 1 : 0);
|
||||
luaL_traceback(L, L1, msg, level);
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
static int db_setcstacklimit (lua_State *L) {
|
||||
int limit = (int)luaL_checkinteger(L, 1);
|
||||
int res = lua_setcstacklimit(L, limit);
|
||||
lua_pushinteger(L, res);
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
static const luaL_Reg dblib[] = {
|
||||
{"debug", db_debug},
|
||||
{"getuservalue", db_getuservalue},
|
||||
{"gethook", db_gethook},
|
||||
{"getinfo", db_getinfo},
|
||||
{"getlocal", db_getlocal},
|
||||
{"getregistry", db_getregistry},
|
||||
{"getmetatable", db_getmetatable},
|
||||
{"getupvalue", db_getupvalue},
|
||||
{"upvaluejoin", db_upvaluejoin},
|
||||
{"upvalueid", db_upvalueid},
|
||||
{"setuservalue", db_setuservalue},
|
||||
{"sethook", db_sethook},
|
||||
{"setlocal", db_setlocal},
|
||||
{"setmetatable", db_setmetatable},
|
||||
{"setupvalue", db_setupvalue},
|
||||
{"traceback", db_traceback},
|
||||
{"setcstacklimit", db_setcstacklimit},
|
||||
{NULL, NULL}
|
||||
};
|
||||
|
||||
|
||||
LUAMOD_API int luaopen_debug (lua_State *L) {
|
||||
luaL_newlib(L, dblib);
|
||||
return 1;
|
||||
}
|
||||
|
||||
@ -1,962 +0,0 @@
|
||||
/*
|
||||
** $Id: ldebug.c $
|
||||
** Debug Interface
|
||||
** See Copyright Notice in lua.h
|
||||
*/
|
||||
|
||||
#define ldebug_c
|
||||
#define LUA_CORE
|
||||
|
||||
#include "lprefix.h"
|
||||
|
||||
|
||||
#include <stdarg.h>
|
||||
#include <stddef.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "lua.h"
|
||||
|
||||
#include "lapi.h"
|
||||
#include "lcode.h"
|
||||
#include "ldebug.h"
|
||||
#include "ldo.h"
|
||||
#include "lfunc.h"
|
||||
#include "lobject.h"
|
||||
#include "lopcodes.h"
|
||||
#include "lstate.h"
|
||||
#include "lstring.h"
|
||||
#include "ltable.h"
|
||||
#include "ltm.h"
|
||||
#include "lvm.h"
|
||||
|
||||
|
||||
|
||||
#define LuaClosure(f) ((f) != NULL && (f)->c.tt == LUA_VLCL)
|
||||
|
||||
|
||||
static const char *funcnamefromcall (lua_State *L, CallInfo *ci,
|
||||
const char **name);
|
||||
|
||||
|
||||
static int currentpc (CallInfo *ci) {
|
||||
lua_assert(isLua(ci));
|
||||
return pcRel(ci->u.l.savedpc, ci_func(ci)->p);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Get a "base line" to find the line corresponding to an instruction.
|
||||
** Base lines are regularly placed at MAXIWTHABS intervals, so usually
|
||||
** an integer division gets the right place. When the source file has
|
||||
** large sequences of empty/comment lines, it may need extra entries,
|
||||
** so the original estimate needs a correction.
|
||||
** If the original estimate is -1, the initial 'if' ensures that the
|
||||
** 'while' will run at least once.
|
||||
** The assertion that the estimate is a lower bound for the correct base
|
||||
** is valid as long as the debug info has been generated with the same
|
||||
** value for MAXIWTHABS or smaller. (Previous releases use a little
|
||||
** smaller value.)
|
||||
*/
|
||||
static int getbaseline (const Proto *f, int pc, int *basepc) {
|
||||
if (f->sizeabslineinfo == 0 || pc < f->abslineinfo[0].pc) {
|
||||
*basepc = -1; /* start from the beginning */
|
||||
return f->linedefined;
|
||||
}
|
||||
else {
|
||||
int i = cast_uint(pc) / MAXIWTHABS - 1; /* get an estimate */
|
||||
/* estimate must be a lower bound of the correct base */
|
||||
lua_assert(i < 0 ||
|
||||
(i < f->sizeabslineinfo && f->abslineinfo[i].pc <= pc));
|
||||
while (i + 1 < f->sizeabslineinfo && pc >= f->abslineinfo[i + 1].pc)
|
||||
i++; /* low estimate; adjust it */
|
||||
*basepc = f->abslineinfo[i].pc;
|
||||
return f->abslineinfo[i].line;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Get the line corresponding to instruction 'pc' in function 'f';
|
||||
** first gets a base line and from there does the increments until
|
||||
** the desired instruction.
|
||||
*/
|
||||
int luaG_getfuncline (const Proto *f, int pc) {
|
||||
if (f->lineinfo == NULL) /* no debug information? */
|
||||
return -1;
|
||||
else {
|
||||
int basepc;
|
||||
int baseline = getbaseline(f, pc, &basepc);
|
||||
while (basepc++ < pc) { /* walk until given instruction */
|
||||
lua_assert(f->lineinfo[basepc] != ABSLINEINFO);
|
||||
baseline += f->lineinfo[basepc]; /* correct line */
|
||||
}
|
||||
return baseline;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static int getcurrentline (CallInfo *ci) {
|
||||
return luaG_getfuncline(ci_func(ci)->p, currentpc(ci));
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Set 'trap' for all active Lua frames.
|
||||
** This function can be called during a signal, under "reasonable"
|
||||
** assumptions. A new 'ci' is completely linked in the list before it
|
||||
** becomes part of the "active" list, and we assume that pointers are
|
||||
** atomic; see comment in next function.
|
||||
** (A compiler doing interprocedural optimizations could, theoretically,
|
||||
** reorder memory writes in such a way that the list could be
|
||||
** temporarily broken while inserting a new element. We simply assume it
|
||||
** has no good reasons to do that.)
|
||||
*/
|
||||
static void settraps (CallInfo *ci) {
|
||||
for (; ci != NULL; ci = ci->previous)
|
||||
if (isLua(ci))
|
||||
ci->u.l.trap = 1;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** This function can be called during a signal, under "reasonable"
|
||||
** assumptions.
|
||||
** Fields 'basehookcount' and 'hookcount' (set by 'resethookcount')
|
||||
** are for debug only, and it is no problem if they get arbitrary
|
||||
** values (causes at most one wrong hook call). 'hookmask' is an atomic
|
||||
** value. We assume that pointers are atomic too (e.g., gcc ensures that
|
||||
** for all platforms where it runs). Moreover, 'hook' is always checked
|
||||
** before being called (see 'luaD_hook').
|
||||
*/
|
||||
LUA_API void lua_sethook (lua_State *L, lua_Hook func, int mask, int count) {
|
||||
if (func == NULL || mask == 0) { /* turn off hooks? */
|
||||
mask = 0;
|
||||
func = NULL;
|
||||
}
|
||||
L->hook = func;
|
||||
L->basehookcount = count;
|
||||
resethookcount(L);
|
||||
L->hookmask = cast_byte(mask);
|
||||
if (mask)
|
||||
settraps(L->ci); /* to trace inside 'luaV_execute' */
|
||||
}
|
||||
|
||||
|
||||
LUA_API lua_Hook lua_gethook (lua_State *L) {
|
||||
return L->hook;
|
||||
}
|
||||
|
||||
|
||||
LUA_API int lua_gethookmask (lua_State *L) {
|
||||
return L->hookmask;
|
||||
}
|
||||
|
||||
|
||||
LUA_API int lua_gethookcount (lua_State *L) {
|
||||
return L->basehookcount;
|
||||
}
|
||||
|
||||
|
||||
LUA_API int lua_getstack (lua_State *L, int level, lua_Debug *ar) {
|
||||
int status;
|
||||
CallInfo *ci;
|
||||
if (level < 0) return 0; /* invalid (negative) level */
|
||||
lua_lock(L);
|
||||
for (ci = L->ci; level > 0 && ci != &L->base_ci; ci = ci->previous)
|
||||
level--;
|
||||
if (level == 0 && ci != &L->base_ci) { /* level found? */
|
||||
status = 1;
|
||||
ar->i_ci = ci;
|
||||
}
|
||||
else status = 0; /* no such level */
|
||||
lua_unlock(L);
|
||||
return status;
|
||||
}
|
||||
|
||||
|
||||
static const char *upvalname (const Proto *p, int uv) {
|
||||
TString *s = check_exp(uv < p->sizeupvalues, p->upvalues[uv].name);
|
||||
if (s == NULL) return "?";
|
||||
else return getstr(s);
|
||||
}
|
||||
|
||||
|
||||
static const char *findvararg (CallInfo *ci, int n, StkId *pos) {
|
||||
if (clLvalue(s2v(ci->func.p))->p->is_vararg) {
|
||||
int nextra = ci->u.l.nextraargs;
|
||||
if (n >= -nextra) { /* 'n' is negative */
|
||||
*pos = ci->func.p - nextra - (n + 1);
|
||||
return "(vararg)"; /* generic name for any vararg */
|
||||
}
|
||||
}
|
||||
return NULL; /* no such vararg */
|
||||
}
|
||||
|
||||
|
||||
const char *luaG_findlocal (lua_State *L, CallInfo *ci, int n, StkId *pos) {
|
||||
StkId base = ci->func.p + 1;
|
||||
const char *name = NULL;
|
||||
if (isLua(ci)) {
|
||||
if (n < 0) /* access to vararg values? */
|
||||
return findvararg(ci, n, pos);
|
||||
else
|
||||
name = luaF_getlocalname(ci_func(ci)->p, n, currentpc(ci));
|
||||
}
|
||||
if (name == NULL) { /* no 'standard' name? */
|
||||
StkId limit = (ci == L->ci) ? L->top.p : ci->next->func.p;
|
||||
if (limit - base >= n && n > 0) { /* is 'n' inside 'ci' stack? */
|
||||
/* generic name for any valid slot */
|
||||
name = isLua(ci) ? "(temporary)" : "(C temporary)";
|
||||
}
|
||||
else
|
||||
return NULL; /* no name */
|
||||
}
|
||||
if (pos)
|
||||
*pos = base + (n - 1);
|
||||
return name;
|
||||
}
|
||||
|
||||
|
||||
LUA_API const char *lua_getlocal (lua_State *L, const lua_Debug *ar, int n) {
|
||||
const char *name;
|
||||
lua_lock(L);
|
||||
if (ar == NULL) { /* information about non-active function? */
|
||||
if (!isLfunction(s2v(L->top.p - 1))) /* not a Lua function? */
|
||||
name = NULL;
|
||||
else /* consider live variables at function start (parameters) */
|
||||
name = luaF_getlocalname(clLvalue(s2v(L->top.p - 1))->p, n, 0);
|
||||
}
|
||||
else { /* active function; get information through 'ar' */
|
||||
StkId pos = NULL; /* to avoid warnings */
|
||||
name = luaG_findlocal(L, ar->i_ci, n, &pos);
|
||||
if (name) {
|
||||
setobjs2s(L, L->top.p, pos);
|
||||
api_incr_top(L);
|
||||
}
|
||||
}
|
||||
lua_unlock(L);
|
||||
return name;
|
||||
}
|
||||
|
||||
|
||||
LUA_API const char *lua_setlocal (lua_State *L, const lua_Debug *ar, int n) {
|
||||
StkId pos = NULL; /* to avoid warnings */
|
||||
const char *name;
|
||||
lua_lock(L);
|
||||
name = luaG_findlocal(L, ar->i_ci, n, &pos);
|
||||
if (name) {
|
||||
setobjs2s(L, pos, L->top.p - 1);
|
||||
L->top.p--; /* pop value */
|
||||
}
|
||||
lua_unlock(L);
|
||||
return name;
|
||||
}
|
||||
|
||||
|
||||
static void funcinfo (lua_Debug *ar, Closure *cl) {
|
||||
if (!LuaClosure(cl)) {
|
||||
ar->source = "=[C]";
|
||||
ar->srclen = LL("=[C]");
|
||||
ar->linedefined = -1;
|
||||
ar->lastlinedefined = -1;
|
||||
ar->what = "C";
|
||||
}
|
||||
else {
|
||||
const Proto *p = cl->l.p;
|
||||
if (p->source) {
|
||||
ar->source = getstr(p->source);
|
||||
ar->srclen = tsslen(p->source);
|
||||
}
|
||||
else {
|
||||
ar->source = "=?";
|
||||
ar->srclen = LL("=?");
|
||||
}
|
||||
ar->linedefined = p->linedefined;
|
||||
ar->lastlinedefined = p->lastlinedefined;
|
||||
ar->what = (ar->linedefined == 0) ? "main" : "Lua";
|
||||
}
|
||||
luaO_chunkid(ar->short_src, ar->source, ar->srclen);
|
||||
}
|
||||
|
||||
|
||||
static int nextline (const Proto *p, int currentline, int pc) {
|
||||
if (p->lineinfo[pc] != ABSLINEINFO)
|
||||
return currentline + p->lineinfo[pc];
|
||||
else
|
||||
return luaG_getfuncline(p, pc);
|
||||
}
|
||||
|
||||
|
||||
static void collectvalidlines (lua_State *L, Closure *f) {
|
||||
if (!LuaClosure(f)) {
|
||||
setnilvalue(s2v(L->top.p));
|
||||
api_incr_top(L);
|
||||
}
|
||||
else {
|
||||
const Proto *p = f->l.p;
|
||||
int currentline = p->linedefined;
|
||||
Table *t = luaH_new(L); /* new table to store active lines */
|
||||
sethvalue2s(L, L->top.p, t); /* push it on stack */
|
||||
api_incr_top(L);
|
||||
if (p->lineinfo != NULL) { /* proto with debug information? */
|
||||
int i;
|
||||
TValue v;
|
||||
setbtvalue(&v); /* boolean 'true' to be the value of all indices */
|
||||
if (!p->is_vararg) /* regular function? */
|
||||
i = 0; /* consider all instructions */
|
||||
else { /* vararg function */
|
||||
lua_assert(GET_OPCODE(p->code[0]) == OP_VARARGPREP);
|
||||
currentline = nextline(p, currentline, 0);
|
||||
i = 1; /* skip first instruction (OP_VARARGPREP) */
|
||||
}
|
||||
for (; i < p->sizelineinfo; i++) { /* for each instruction */
|
||||
currentline = nextline(p, currentline, i); /* get its line */
|
||||
luaH_setint(L, t, currentline, &v); /* table[line] = true */
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static const char *getfuncname (lua_State *L, CallInfo *ci, const char **name) {
|
||||
/* calling function is a known function? */
|
||||
if (ci != NULL && !(ci->callstatus & CIST_TAIL))
|
||||
return funcnamefromcall(L, ci->previous, name);
|
||||
else return NULL; /* no way to find a name */
|
||||
}
|
||||
|
||||
|
||||
static int auxgetinfo (lua_State *L, const char *what, lua_Debug *ar,
|
||||
Closure *f, CallInfo *ci) {
|
||||
int status = 1;
|
||||
for (; *what; what++) {
|
||||
switch (*what) {
|
||||
case 'S': {
|
||||
funcinfo(ar, f);
|
||||
break;
|
||||
}
|
||||
case 'l': {
|
||||
ar->currentline = (ci && isLua(ci)) ? getcurrentline(ci) : -1;
|
||||
break;
|
||||
}
|
||||
case 'u': {
|
||||
ar->nups = (f == NULL) ? 0 : f->c.nupvalues;
|
||||
if (!LuaClosure(f)) {
|
||||
ar->isvararg = 1;
|
||||
ar->nparams = 0;
|
||||
}
|
||||
else {
|
||||
ar->isvararg = f->l.p->is_vararg;
|
||||
ar->nparams = f->l.p->numparams;
|
||||
}
|
||||
break;
|
||||
}
|
||||
case 't': {
|
||||
ar->istailcall = (ci) ? ci->callstatus & CIST_TAIL : 0;
|
||||
break;
|
||||
}
|
||||
case 'n': {
|
||||
ar->namewhat = getfuncname(L, ci, &ar->name);
|
||||
if (ar->namewhat == NULL) {
|
||||
ar->namewhat = ""; /* not found */
|
||||
ar->name = NULL;
|
||||
}
|
||||
break;
|
||||
}
|
||||
case 'r': {
|
||||
if (ci == NULL || !(ci->callstatus & CIST_TRAN))
|
||||
ar->ftransfer = ar->ntransfer = 0;
|
||||
else {
|
||||
ar->ftransfer = ci->u2.transferinfo.ftransfer;
|
||||
ar->ntransfer = ci->u2.transferinfo.ntransfer;
|
||||
}
|
||||
break;
|
||||
}
|
||||
case 'L':
|
||||
case 'f': /* handled by lua_getinfo */
|
||||
break;
|
||||
default: status = 0; /* invalid option */
|
||||
}
|
||||
}
|
||||
return status;
|
||||
}
|
||||
|
||||
|
||||
LUA_API int lua_getinfo (lua_State *L, const char *what, lua_Debug *ar) {
|
||||
int status;
|
||||
Closure *cl;
|
||||
CallInfo *ci;
|
||||
TValue *func;
|
||||
lua_lock(L);
|
||||
if (*what == '>') {
|
||||
ci = NULL;
|
||||
func = s2v(L->top.p - 1);
|
||||
api_check(L, ttisfunction(func), "function expected");
|
||||
what++; /* skip the '>' */
|
||||
L->top.p--; /* pop function */
|
||||
}
|
||||
else {
|
||||
ci = ar->i_ci;
|
||||
func = s2v(ci->func.p);
|
||||
lua_assert(ttisfunction(func));
|
||||
}
|
||||
cl = ttisclosure(func) ? clvalue(func) : NULL;
|
||||
status = auxgetinfo(L, what, ar, cl, ci);
|
||||
if (strchr(what, 'f')) {
|
||||
setobj2s(L, L->top.p, func);
|
||||
api_incr_top(L);
|
||||
}
|
||||
if (strchr(what, 'L'))
|
||||
collectvalidlines(L, cl);
|
||||
lua_unlock(L);
|
||||
return status;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** {======================================================
|
||||
** Symbolic Execution
|
||||
** =======================================================
|
||||
*/
|
||||
|
||||
|
||||
static int filterpc (int pc, int jmptarget) {
|
||||
if (pc < jmptarget) /* is code conditional (inside a jump)? */
|
||||
return -1; /* cannot know who sets that register */
|
||||
else return pc; /* current position sets that register */
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Try to find last instruction before 'lastpc' that modified register 'reg'.
|
||||
*/
|
||||
static int findsetreg (const Proto *p, int lastpc, int reg) {
|
||||
int pc;
|
||||
int setreg = -1; /* keep last instruction that changed 'reg' */
|
||||
int jmptarget = 0; /* any code before this address is conditional */
|
||||
if (testMMMode(GET_OPCODE(p->code[lastpc])))
|
||||
lastpc--; /* previous instruction was not actually executed */
|
||||
for (pc = 0; pc < lastpc; pc++) {
|
||||
Instruction i = p->code[pc];
|
||||
OpCode op = GET_OPCODE(i);
|
||||
int a = GETARG_A(i);
|
||||
int change; /* true if current instruction changed 'reg' */
|
||||
switch (op) {
|
||||
case OP_LOADNIL: { /* set registers from 'a' to 'a+b' */
|
||||
int b = GETARG_B(i);
|
||||
change = (a <= reg && reg <= a + b);
|
||||
break;
|
||||
}
|
||||
case OP_TFORCALL: { /* affect all regs above its base */
|
||||
change = (reg >= a + 2);
|
||||
break;
|
||||
}
|
||||
case OP_CALL:
|
||||
case OP_TAILCALL: { /* affect all registers above base */
|
||||
change = (reg >= a);
|
||||
break;
|
||||
}
|
||||
case OP_JMP: { /* doesn't change registers, but changes 'jmptarget' */
|
||||
int b = GETARG_sJ(i);
|
||||
int dest = pc + 1 + b;
|
||||
/* jump does not skip 'lastpc' and is larger than current one? */
|
||||
if (dest <= lastpc && dest > jmptarget)
|
||||
jmptarget = dest; /* update 'jmptarget' */
|
||||
change = 0;
|
||||
break;
|
||||
}
|
||||
default: /* any instruction that sets A */
|
||||
change = (testAMode(op) && reg == a);
|
||||
break;
|
||||
}
|
||||
if (change)
|
||||
setreg = filterpc(pc, jmptarget);
|
||||
}
|
||||
return setreg;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Find a "name" for the constant 'c'.
|
||||
*/
|
||||
static const char *kname (const Proto *p, int index, const char **name) {
|
||||
TValue *kvalue = &p->k[index];
|
||||
if (ttisstring(kvalue)) {
|
||||
*name = getstr(tsvalue(kvalue));
|
||||
return "constant";
|
||||
}
|
||||
else {
|
||||
*name = "?";
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static const char *basicgetobjname (const Proto *p, int *ppc, int reg,
|
||||
const char **name) {
|
||||
int pc = *ppc;
|
||||
*name = luaF_getlocalname(p, reg + 1, pc);
|
||||
if (*name) /* is a local? */
|
||||
return "local";
|
||||
/* else try symbolic execution */
|
||||
*ppc = pc = findsetreg(p, pc, reg);
|
||||
if (pc != -1) { /* could find instruction? */
|
||||
Instruction i = p->code[pc];
|
||||
OpCode op = GET_OPCODE(i);
|
||||
switch (op) {
|
||||
case OP_MOVE: {
|
||||
int b = GETARG_B(i); /* move from 'b' to 'a' */
|
||||
if (b < GETARG_A(i))
|
||||
return basicgetobjname(p, ppc, b, name); /* get name for 'b' */
|
||||
break;
|
||||
}
|
||||
case OP_GETUPVAL: {
|
||||
*name = upvalname(p, GETARG_B(i));
|
||||
return "upvalue";
|
||||
}
|
||||
case OP_LOADK: return kname(p, GETARG_Bx(i), name);
|
||||
case OP_LOADKX: return kname(p, GETARG_Ax(p->code[pc + 1]), name);
|
||||
default: break;
|
||||
}
|
||||
}
|
||||
return NULL; /* could not find reasonable name */
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Find a "name" for the register 'c'.
|
||||
*/
|
||||
static void rname (const Proto *p, int pc, int c, const char **name) {
|
||||
const char *what = basicgetobjname(p, &pc, c, name); /* search for 'c' */
|
||||
if (!(what && *what == 'c')) /* did not find a constant name? */
|
||||
*name = "?";
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Find a "name" for a 'C' value in an RK instruction.
|
||||
*/
|
||||
static void rkname (const Proto *p, int pc, Instruction i, const char **name) {
|
||||
int c = GETARG_C(i); /* key index */
|
||||
if (GETARG_k(i)) /* is 'c' a constant? */
|
||||
kname(p, c, name);
|
||||
else /* 'c' is a register */
|
||||
rname(p, pc, c, name);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Check whether table being indexed by instruction 'i' is the
|
||||
** environment '_ENV'
|
||||
*/
|
||||
static const char *isEnv (const Proto *p, int pc, Instruction i, int isup) {
|
||||
int t = GETARG_B(i); /* table index */
|
||||
const char *name; /* name of indexed variable */
|
||||
if (isup) /* is 't' an upvalue? */
|
||||
name = upvalname(p, t);
|
||||
else /* 't' is a register */
|
||||
basicgetobjname(p, &pc, t, &name);
|
||||
return (name && strcmp(name, LUA_ENV) == 0) ? "global" : "field";
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Extend 'basicgetobjname' to handle table accesses
|
||||
*/
|
||||
static const char *getobjname (const Proto *p, int lastpc, int reg,
|
||||
const char **name) {
|
||||
const char *kind = basicgetobjname(p, &lastpc, reg, name);
|
||||
if (kind != NULL)
|
||||
return kind;
|
||||
else if (lastpc != -1) { /* could find instruction? */
|
||||
Instruction i = p->code[lastpc];
|
||||
OpCode op = GET_OPCODE(i);
|
||||
switch (op) {
|
||||
case OP_GETTABUP: {
|
||||
int k = GETARG_C(i); /* key index */
|
||||
kname(p, k, name);
|
||||
return isEnv(p, lastpc, i, 1);
|
||||
}
|
||||
case OP_GETTABLE: {
|
||||
int k = GETARG_C(i); /* key index */
|
||||
rname(p, lastpc, k, name);
|
||||
return isEnv(p, lastpc, i, 0);
|
||||
}
|
||||
case OP_GETI: {
|
||||
*name = "integer index";
|
||||
return "field";
|
||||
}
|
||||
case OP_GETFIELD: {
|
||||
int k = GETARG_C(i); /* key index */
|
||||
kname(p, k, name);
|
||||
return isEnv(p, lastpc, i, 0);
|
||||
}
|
||||
case OP_SELF: {
|
||||
rkname(p, lastpc, i, name);
|
||||
return "method";
|
||||
}
|
||||
default: break; /* go through to return NULL */
|
||||
}
|
||||
}
|
||||
return NULL; /* could not find reasonable name */
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Try to find a name for a function based on the code that called it.
|
||||
** (Only works when function was called by a Lua function.)
|
||||
** Returns what the name is (e.g., "for iterator", "method",
|
||||
** "metamethod") and sets '*name' to point to the name.
|
||||
*/
|
||||
static const char *funcnamefromcode (lua_State *L, const Proto *p,
|
||||
int pc, const char **name) {
|
||||
TMS tm = (TMS)0; /* (initial value avoids warnings) */
|
||||
Instruction i = p->code[pc]; /* calling instruction */
|
||||
switch (GET_OPCODE(i)) {
|
||||
case OP_CALL:
|
||||
case OP_TAILCALL:
|
||||
return getobjname(p, pc, GETARG_A(i), name); /* get function name */
|
||||
case OP_TFORCALL: { /* for iterator */
|
||||
*name = "for iterator";
|
||||
return "for iterator";
|
||||
}
|
||||
/* other instructions can do calls through metamethods */
|
||||
case OP_SELF: case OP_GETTABUP: case OP_GETTABLE:
|
||||
case OP_GETI: case OP_GETFIELD:
|
||||
tm = TM_INDEX;
|
||||
break;
|
||||
case OP_SETTABUP: case OP_SETTABLE: case OP_SETI: case OP_SETFIELD:
|
||||
tm = TM_NEWINDEX;
|
||||
break;
|
||||
case OP_MMBIN: case OP_MMBINI: case OP_MMBINK: {
|
||||
tm = cast(TMS, GETARG_C(i));
|
||||
break;
|
||||
}
|
||||
case OP_UNM: tm = TM_UNM; break;
|
||||
case OP_BNOT: tm = TM_BNOT; break;
|
||||
case OP_LEN: tm = TM_LEN; break;
|
||||
case OP_CONCAT: tm = TM_CONCAT; break;
|
||||
case OP_EQ: tm = TM_EQ; break;
|
||||
/* no cases for OP_EQI and OP_EQK, as they don't call metamethods */
|
||||
case OP_LT: case OP_LTI: case OP_GTI: tm = TM_LT; break;
|
||||
case OP_LE: case OP_LEI: case OP_GEI: tm = TM_LE; break;
|
||||
case OP_CLOSE: case OP_RETURN: tm = TM_CLOSE; break;
|
||||
default:
|
||||
return NULL; /* cannot find a reasonable name */
|
||||
}
|
||||
*name = getshrstr(G(L)->tmname[tm]) + 2;
|
||||
return "metamethod";
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Try to find a name for a function based on how it was called.
|
||||
*/
|
||||
static const char *funcnamefromcall (lua_State *L, CallInfo *ci,
|
||||
const char **name) {
|
||||
if (ci->callstatus & CIST_HOOKED) { /* was it called inside a hook? */
|
||||
*name = "?";
|
||||
return "hook";
|
||||
}
|
||||
else if (ci->callstatus & CIST_FIN) { /* was it called as a finalizer? */
|
||||
*name = "__gc";
|
||||
return "metamethod"; /* report it as such */
|
||||
}
|
||||
else if (isLua(ci))
|
||||
return funcnamefromcode(L, ci_func(ci)->p, currentpc(ci), name);
|
||||
else
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* }====================================================== */
|
||||
|
||||
|
||||
|
||||
/*
|
||||
** Check whether pointer 'o' points to some value in the stack frame of
|
||||
** the current function and, if so, returns its index. Because 'o' may
|
||||
** not point to a value in this stack, we cannot compare it with the
|
||||
** region boundaries (undefined behavior in ISO C).
|
||||
*/
|
||||
static int instack (CallInfo *ci, const TValue *o) {
|
||||
int pos;
|
||||
StkId base = ci->func.p + 1;
|
||||
for (pos = 0; base + pos < ci->top.p; pos++) {
|
||||
if (o == s2v(base + pos))
|
||||
return pos;
|
||||
}
|
||||
return -1; /* not found */
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Checks whether value 'o' came from an upvalue. (That can only happen
|
||||
** with instructions OP_GETTABUP/OP_SETTABUP, which operate directly on
|
||||
** upvalues.)
|
||||
*/
|
||||
static const char *getupvalname (CallInfo *ci, const TValue *o,
|
||||
const char **name) {
|
||||
LClosure *c = ci_func(ci);
|
||||
int i;
|
||||
for (i = 0; i < c->nupvalues; i++) {
|
||||
if (c->upvals[i]->v.p == o) {
|
||||
*name = upvalname(c->p, i);
|
||||
return "upvalue";
|
||||
}
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
||||
static const char *formatvarinfo (lua_State *L, const char *kind,
|
||||
const char *name) {
|
||||
if (kind == NULL)
|
||||
return ""; /* no information */
|
||||
else
|
||||
return luaO_pushfstring(L, " (%s '%s')", kind, name);
|
||||
}
|
||||
|
||||
/*
|
||||
** Build a string with a "description" for the value 'o', such as
|
||||
** "variable 'x'" or "upvalue 'y'".
|
||||
*/
|
||||
static const char *varinfo (lua_State *L, const TValue *o) {
|
||||
CallInfo *ci = L->ci;
|
||||
const char *name = NULL; /* to avoid warnings */
|
||||
const char *kind = NULL;
|
||||
if (isLua(ci)) {
|
||||
kind = getupvalname(ci, o, &name); /* check whether 'o' is an upvalue */
|
||||
if (!kind) { /* not an upvalue? */
|
||||
int reg = instack(ci, o); /* try a register */
|
||||
if (reg >= 0) /* is 'o' a register? */
|
||||
kind = getobjname(ci_func(ci)->p, currentpc(ci), reg, &name);
|
||||
}
|
||||
}
|
||||
return formatvarinfo(L, kind, name);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Raise a type error
|
||||
*/
|
||||
static l_noret typeerror (lua_State *L, const TValue *o, const char *op,
|
||||
const char *extra) {
|
||||
const char *t = luaT_objtypename(L, o);
|
||||
luaG_runerror(L, "attempt to %s a %s value%s", op, t, extra);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Raise a type error with "standard" information about the faulty
|
||||
** object 'o' (using 'varinfo').
|
||||
*/
|
||||
l_noret luaG_typeerror (lua_State *L, const TValue *o, const char *op) {
|
||||
typeerror(L, o, op, varinfo(L, o));
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Raise an error for calling a non-callable object. Try to find a name
|
||||
** for the object based on how it was called ('funcnamefromcall'); if it
|
||||
** cannot get a name there, try 'varinfo'.
|
||||
*/
|
||||
l_noret luaG_callerror (lua_State *L, const TValue *o) {
|
||||
CallInfo *ci = L->ci;
|
||||
const char *name = NULL; /* to avoid warnings */
|
||||
const char *kind = funcnamefromcall(L, ci, &name);
|
||||
const char *extra = kind ? formatvarinfo(L, kind, name) : varinfo(L, o);
|
||||
typeerror(L, o, "call", extra);
|
||||
}
|
||||
|
||||
|
||||
l_noret luaG_forerror (lua_State *L, const TValue *o, const char *what) {
|
||||
luaG_runerror(L, "bad 'for' %s (number expected, got %s)",
|
||||
what, luaT_objtypename(L, o));
|
||||
}
|
||||
|
||||
|
||||
l_noret luaG_concaterror (lua_State *L, const TValue *p1, const TValue *p2) {
|
||||
if (ttisstring(p1) || cvt2str(p1)) p1 = p2;
|
||||
luaG_typeerror(L, p1, "concatenate");
|
||||
}
|
||||
|
||||
|
||||
l_noret luaG_opinterror (lua_State *L, const TValue *p1,
|
||||
const TValue *p2, const char *msg) {
|
||||
if (!ttisnumber(p1)) /* first operand is wrong? */
|
||||
p2 = p1; /* now second is wrong */
|
||||
luaG_typeerror(L, p2, msg);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Error when both values are convertible to numbers, but not to integers
|
||||
*/
|
||||
l_noret luaG_tointerror (lua_State *L, const TValue *p1, const TValue *p2) {
|
||||
lua_Integer temp;
|
||||
if (!luaV_tointegerns(p1, &temp, LUA_FLOORN2I))
|
||||
p2 = p1;
|
||||
luaG_runerror(L, "number%s has no integer representation", varinfo(L, p2));
|
||||
}
|
||||
|
||||
|
||||
l_noret luaG_ordererror (lua_State *L, const TValue *p1, const TValue *p2) {
|
||||
const char *t1 = luaT_objtypename(L, p1);
|
||||
const char *t2 = luaT_objtypename(L, p2);
|
||||
if (strcmp(t1, t2) == 0)
|
||||
luaG_runerror(L, "attempt to compare two %s values", t1);
|
||||
else
|
||||
luaG_runerror(L, "attempt to compare %s with %s", t1, t2);
|
||||
}
|
||||
|
||||
|
||||
/* add src:line information to 'msg' */
|
||||
const char *luaG_addinfo (lua_State *L, const char *msg, TString *src,
|
||||
int line) {
|
||||
char buff[LUA_IDSIZE];
|
||||
if (src)
|
||||
luaO_chunkid(buff, getstr(src), tsslen(src));
|
||||
else { /* no source available; use "?" instead */
|
||||
buff[0] = '?'; buff[1] = '\0';
|
||||
}
|
||||
return luaO_pushfstring(L, "%s:%d: %s", buff, line, msg);
|
||||
}
|
||||
|
||||
|
||||
l_noret luaG_errormsg (lua_State *L) {
|
||||
if (L->errfunc != 0) { /* is there an error handling function? */
|
||||
StkId errfunc = restorestack(L, L->errfunc);
|
||||
lua_assert(ttisfunction(s2v(errfunc)));
|
||||
setobjs2s(L, L->top.p, L->top.p - 1); /* move argument */
|
||||
setobjs2s(L, L->top.p - 1, errfunc); /* push function */
|
||||
L->top.p++; /* assume EXTRA_STACK */
|
||||
luaD_callnoyield(L, L->top.p - 2, 1); /* call it */
|
||||
}
|
||||
luaD_throw(L, LUA_ERRRUN);
|
||||
}
|
||||
|
||||
|
||||
l_noret luaG_runerror (lua_State *L, const char *fmt, ...) {
|
||||
CallInfo *ci = L->ci;
|
||||
const char *msg;
|
||||
va_list argp;
|
||||
luaC_checkGC(L); /* error message uses memory */
|
||||
va_start(argp, fmt);
|
||||
msg = luaO_pushvfstring(L, fmt, argp); /* format message */
|
||||
va_end(argp);
|
||||
if (isLua(ci)) { /* if Lua function, add source:line information */
|
||||
luaG_addinfo(L, msg, ci_func(ci)->p->source, getcurrentline(ci));
|
||||
setobjs2s(L, L->top.p - 2, L->top.p - 1); /* remove 'msg' */
|
||||
L->top.p--;
|
||||
}
|
||||
luaG_errormsg(L);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Check whether new instruction 'newpc' is in a different line from
|
||||
** previous instruction 'oldpc'. More often than not, 'newpc' is only
|
||||
** one or a few instructions after 'oldpc' (it must be after, see
|
||||
** caller), so try to avoid calling 'luaG_getfuncline'. If they are
|
||||
** too far apart, there is a good chance of a ABSLINEINFO in the way,
|
||||
** so it goes directly to 'luaG_getfuncline'.
|
||||
*/
|
||||
static int changedline (const Proto *p, int oldpc, int newpc) {
|
||||
if (p->lineinfo == NULL) /* no debug information? */
|
||||
return 0;
|
||||
if (newpc - oldpc < MAXIWTHABS / 2) { /* not too far apart? */
|
||||
int delta = 0; /* line difference */
|
||||
int pc = oldpc;
|
||||
for (;;) {
|
||||
int lineinfo = p->lineinfo[++pc];
|
||||
if (lineinfo == ABSLINEINFO)
|
||||
break; /* cannot compute delta; fall through */
|
||||
delta += lineinfo;
|
||||
if (pc == newpc)
|
||||
return (delta != 0); /* delta computed successfully */
|
||||
}
|
||||
}
|
||||
/* either instructions are too far apart or there is an absolute line
|
||||
info in the way; compute line difference explicitly */
|
||||
return (luaG_getfuncline(p, oldpc) != luaG_getfuncline(p, newpc));
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Traces Lua calls. If code is running the first instruction of a function,
|
||||
** and function is not vararg, and it is not coming from an yield,
|
||||
** calls 'luaD_hookcall'. (Vararg functions will call 'luaD_hookcall'
|
||||
** after adjusting its variable arguments; otherwise, they could call
|
||||
** a line/count hook before the call hook. Functions coming from
|
||||
** an yield already called 'luaD_hookcall' before yielding.)
|
||||
*/
|
||||
int luaG_tracecall (lua_State *L) {
|
||||
CallInfo *ci = L->ci;
|
||||
Proto *p = ci_func(ci)->p;
|
||||
ci->u.l.trap = 1; /* ensure hooks will be checked */
|
||||
if (ci->u.l.savedpc == p->code) { /* first instruction (not resuming)? */
|
||||
if (p->is_vararg)
|
||||
return 0; /* hooks will start at VARARGPREP instruction */
|
||||
else if (!(ci->callstatus & CIST_HOOKYIELD)) /* not yieded? */
|
||||
luaD_hookcall(L, ci); /* check 'call' hook */
|
||||
}
|
||||
return 1; /* keep 'trap' on */
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Traces the execution of a Lua function. Called before the execution
|
||||
** of each opcode, when debug is on. 'L->oldpc' stores the last
|
||||
** instruction traced, to detect line changes. When entering a new
|
||||
** function, 'npci' will be zero and will test as a new line whatever
|
||||
** the value of 'oldpc'. Some exceptional conditions may return to
|
||||
** a function without setting 'oldpc'. In that case, 'oldpc' may be
|
||||
** invalid; if so, use zero as a valid value. (A wrong but valid 'oldpc'
|
||||
** at most causes an extra call to a line hook.)
|
||||
** This function is not "Protected" when called, so it should correct
|
||||
** 'L->top.p' before calling anything that can run the GC.
|
||||
*/
|
||||
int luaG_traceexec (lua_State *L, const Instruction *pc) {
|
||||
CallInfo *ci = L->ci;
|
||||
lu_byte mask = L->hookmask;
|
||||
const Proto *p = ci_func(ci)->p;
|
||||
int counthook;
|
||||
if (!(mask & (LUA_MASKLINE | LUA_MASKCOUNT))) { /* no hooks? */
|
||||
ci->u.l.trap = 0; /* don't need to stop again */
|
||||
return 0; /* turn off 'trap' */
|
||||
}
|
||||
pc++; /* reference is always next instruction */
|
||||
ci->u.l.savedpc = pc; /* save 'pc' */
|
||||
counthook = (mask & LUA_MASKCOUNT) && (--L->hookcount == 0);
|
||||
if (counthook)
|
||||
resethookcount(L); /* reset count */
|
||||
else if (!(mask & LUA_MASKLINE))
|
||||
return 1; /* no line hook and count != 0; nothing to be done now */
|
||||
if (ci->callstatus & CIST_HOOKYIELD) { /* hook yielded last time? */
|
||||
ci->callstatus &= ~CIST_HOOKYIELD; /* erase mark */
|
||||
return 1; /* do not call hook again (VM yielded, so it did not move) */
|
||||
}
|
||||
if (!isIT(*(ci->u.l.savedpc - 1))) /* top not being used? */
|
||||
L->top.p = ci->top.p; /* correct top */
|
||||
if (counthook)
|
||||
luaD_hook(L, LUA_HOOKCOUNT, -1, 0, 0); /* call count hook */
|
||||
if (mask & LUA_MASKLINE) {
|
||||
/* 'L->oldpc' may be invalid; use zero in this case */
|
||||
int oldpc = (L->oldpc < p->sizecode) ? L->oldpc : 0;
|
||||
int npci = pcRel(pc, p);
|
||||
if (npci <= oldpc || /* call hook when jump back (loop), */
|
||||
changedline(p, oldpc, npci)) { /* or when enter new line */
|
||||
int newline = luaG_getfuncline(p, npci);
|
||||
luaD_hook(L, LUA_HOOKLINE, newline, 0, 0); /* call line hook */
|
||||
}
|
||||
L->oldpc = npci; /* 'pc' of last call to line hook */
|
||||
}
|
||||
if (L->status == LUA_YIELD) { /* did hook yield? */
|
||||
if (counthook)
|
||||
L->hookcount = 1; /* undo decrement to zero */
|
||||
ci->callstatus |= CIST_HOOKYIELD; /* mark that it yielded */
|
||||
luaD_throw(L, LUA_YIELD);
|
||||
}
|
||||
return 1; /* keep 'trap' on */
|
||||
}
|
||||
|
||||
@ -1,64 +0,0 @@
|
||||
/*
|
||||
** $Id: ldebug.h $
|
||||
** Auxiliary functions from Debug Interface module
|
||||
** See Copyright Notice in lua.h
|
||||
*/
|
||||
|
||||
#ifndef ldebug_h
|
||||
#define ldebug_h
|
||||
|
||||
|
||||
#include "lstate.h"
|
||||
|
||||
|
||||
#define pcRel(pc, p) (cast_int((pc) - (p)->code) - 1)
|
||||
|
||||
|
||||
/* Active Lua function (given call info) */
|
||||
#define ci_func(ci) (clLvalue(s2v((ci)->func.p)))
|
||||
|
||||
|
||||
#define resethookcount(L) (L->hookcount = L->basehookcount)
|
||||
|
||||
/*
|
||||
** mark for entries in 'lineinfo' array that has absolute information in
|
||||
** 'abslineinfo' array
|
||||
*/
|
||||
#define ABSLINEINFO (-0x80)
|
||||
|
||||
|
||||
/*
|
||||
** MAXimum number of successive Instructions WiTHout ABSolute line
|
||||
** information. (A power of two allows fast divisions.)
|
||||
*/
|
||||
#if !defined(MAXIWTHABS)
|
||||
#define MAXIWTHABS 128
|
||||
#endif
|
||||
|
||||
|
||||
LUAI_FUNC int luaG_getfuncline (const Proto *f, int pc);
|
||||
LUAI_FUNC const char *luaG_findlocal (lua_State *L, CallInfo *ci, int n,
|
||||
StkId *pos);
|
||||
LUAI_FUNC l_noret luaG_typeerror (lua_State *L, const TValue *o,
|
||||
const char *opname);
|
||||
LUAI_FUNC l_noret luaG_callerror (lua_State *L, const TValue *o);
|
||||
LUAI_FUNC l_noret luaG_forerror (lua_State *L, const TValue *o,
|
||||
const char *what);
|
||||
LUAI_FUNC l_noret luaG_concaterror (lua_State *L, const TValue *p1,
|
||||
const TValue *p2);
|
||||
LUAI_FUNC l_noret luaG_opinterror (lua_State *L, const TValue *p1,
|
||||
const TValue *p2,
|
||||
const char *msg);
|
||||
LUAI_FUNC l_noret luaG_tointerror (lua_State *L, const TValue *p1,
|
||||
const TValue *p2);
|
||||
LUAI_FUNC l_noret luaG_ordererror (lua_State *L, const TValue *p1,
|
||||
const TValue *p2);
|
||||
LUAI_FUNC l_noret luaG_runerror (lua_State *L, const char *fmt, ...);
|
||||
LUAI_FUNC const char *luaG_addinfo (lua_State *L, const char *msg,
|
||||
TString *src, int line);
|
||||
LUAI_FUNC l_noret luaG_errormsg (lua_State *L);
|
||||
LUAI_FUNC int luaG_traceexec (lua_State *L, const Instruction *pc);
|
||||
LUAI_FUNC int luaG_tracecall (lua_State *L);
|
||||
|
||||
|
||||
#endif
|
||||
File diff suppressed because it is too large
Load Diff
@ -1,87 +0,0 @@
|
||||
/*
|
||||
** $Id: ldo.h $
|
||||
** Stack and Call structure of Lua
|
||||
** See Copyright Notice in lua.h
|
||||
*/
|
||||
|
||||
#ifndef ldo_h
|
||||
#define ldo_h
|
||||
|
||||
|
||||
#include "llimits.h"
|
||||
#include "lobject.h"
|
||||
#include "lstate.h"
|
||||
#include "lzio.h"
|
||||
|
||||
|
||||
/*
|
||||
** Macro to check stack size and grow stack if needed. Parameters
|
||||
** 'pre'/'pos' allow the macro to preserve a pointer into the
|
||||
** stack across reallocations, doing the work only when needed.
|
||||
** It also allows the running of one GC step when the stack is
|
||||
** reallocated.
|
||||
** 'condmovestack' is used in heavy tests to force a stack reallocation
|
||||
** at every check.
|
||||
*/
|
||||
#define luaD_checkstackaux(L,n,pre,pos) \
|
||||
if (l_unlikely(L->stack_last.p - L->top.p <= (n))) \
|
||||
{ pre; luaD_growstack(L, n, 1); pos; } \
|
||||
else { condmovestack(L,pre,pos); }
|
||||
|
||||
/* In general, 'pre'/'pos' are empty (nothing to save) */
|
||||
#define luaD_checkstack(L,n) luaD_checkstackaux(L,n,(void)0,(void)0)
|
||||
|
||||
|
||||
|
||||
#define savestack(L,pt) (cast_charp(pt) - cast_charp(L->stack.p))
|
||||
#define restorestack(L,n) castp(StkId, cast_charp(L->stack.p) + (n))
|
||||
|
||||
|
||||
/* macro to check stack size, preserving 'p' */
|
||||
#define checkstackp(L,n,p) \
|
||||
luaD_checkstackaux(L, n, \
|
||||
ptrdiff_t t__ = savestack(L, p), /* save 'p' */ \
|
||||
p = restorestack(L, t__)) /* 'pos' part: restore 'p' */
|
||||
|
||||
|
||||
/* macro to check stack size and GC, preserving 'p' */
|
||||
#define checkstackGCp(L,n,p) \
|
||||
luaD_checkstackaux(L, n, \
|
||||
ptrdiff_t t__ = savestack(L, p); /* save 'p' */ \
|
||||
luaC_checkGC(L), /* stack grow uses memory */ \
|
||||
p = restorestack(L, t__)) /* 'pos' part: restore 'p' */
|
||||
|
||||
|
||||
/* macro to check stack size and GC */
|
||||
#define checkstackGC(L,fsize) \
|
||||
luaD_checkstackaux(L, (fsize), luaC_checkGC(L), (void)0)
|
||||
|
||||
|
||||
/* type of protected functions, to be ran by 'runprotected' */
|
||||
typedef void (*Pfunc) (lua_State *L, void *ud);
|
||||
|
||||
LUAI_FUNC void luaD_seterrorobj (lua_State *L, int errcode, StkId oldtop);
|
||||
LUAI_FUNC int luaD_protectedparser (lua_State *L, ZIO *z, const char *name,
|
||||
const char *mode);
|
||||
LUAI_FUNC void luaD_hook (lua_State *L, int event, int line,
|
||||
int fTransfer, int nTransfer);
|
||||
LUAI_FUNC void luaD_hookcall (lua_State *L, CallInfo *ci);
|
||||
LUAI_FUNC int luaD_pretailcall (lua_State *L, CallInfo *ci, StkId func,
|
||||
int narg1, int delta);
|
||||
LUAI_FUNC CallInfo *luaD_precall (lua_State *L, StkId func, int nResults);
|
||||
LUAI_FUNC void luaD_call (lua_State *L, StkId func, int nResults);
|
||||
LUAI_FUNC void luaD_callnoyield (lua_State *L, StkId func, int nResults);
|
||||
LUAI_FUNC int luaD_closeprotected (lua_State *L, ptrdiff_t level, int status);
|
||||
LUAI_FUNC int luaD_pcall (lua_State *L, Pfunc func, void *u,
|
||||
ptrdiff_t oldtop, ptrdiff_t ef);
|
||||
LUAI_FUNC void luaD_poscall (lua_State *L, CallInfo *ci, int nres);
|
||||
LUAI_FUNC int luaD_reallocstack (lua_State *L, int newsize, int raiseerror);
|
||||
LUAI_FUNC int luaD_growstack (lua_State *L, int n, int raiseerror);
|
||||
LUAI_FUNC void luaD_shrinkstack (lua_State *L);
|
||||
LUAI_FUNC void luaD_inctop (lua_State *L);
|
||||
|
||||
LUAI_FUNC l_noret luaD_throw (lua_State *L, int errcode);
|
||||
LUAI_FUNC int luaD_rawrunprotected (lua_State *L, Pfunc f, void *ud);
|
||||
|
||||
#endif
|
||||
|
||||
@ -1,230 +0,0 @@
|
||||
/*
|
||||
** $Id: ldump.c $
|
||||
** save precompiled Lua chunks
|
||||
** See Copyright Notice in lua.h
|
||||
*/
|
||||
|
||||
#define ldump_c
|
||||
#define LUA_CORE
|
||||
|
||||
#include "lprefix.h"
|
||||
|
||||
|
||||
#include <limits.h>
|
||||
#include <stddef.h>
|
||||
|
||||
#include "lua.h"
|
||||
|
||||
#include "lobject.h"
|
||||
#include "lstate.h"
|
||||
#include "lundump.h"
|
||||
|
||||
|
||||
typedef struct {
|
||||
lua_State *L;
|
||||
lua_Writer writer;
|
||||
void *data;
|
||||
int strip;
|
||||
int status;
|
||||
} DumpState;
|
||||
|
||||
|
||||
/*
|
||||
** All high-level dumps go through dumpVector; you can change it to
|
||||
** change the endianness of the result
|
||||
*/
|
||||
#define dumpVector(D,v,n) dumpBlock(D,v,(n)*sizeof((v)[0]))
|
||||
|
||||
#define dumpLiteral(D, s) dumpBlock(D,s,sizeof(s) - sizeof(char))
|
||||
|
||||
|
||||
static void dumpBlock (DumpState *D, const void *b, size_t size) {
|
||||
if (D->status == 0 && size > 0) {
|
||||
lua_unlock(D->L);
|
||||
D->status = (*D->writer)(D->L, b, size, D->data);
|
||||
lua_lock(D->L);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
#define dumpVar(D,x) dumpVector(D,&x,1)
|
||||
|
||||
|
||||
static void dumpByte (DumpState *D, int y) {
|
||||
lu_byte x = (lu_byte)y;
|
||||
dumpVar(D, x);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** 'dumpSize' buffer size: each byte can store up to 7 bits. (The "+6"
|
||||
** rounds up the division.)
|
||||
*/
|
||||
#define DIBS ((sizeof(size_t) * CHAR_BIT + 6) / 7)
|
||||
|
||||
static void dumpSize (DumpState *D, size_t x) {
|
||||
lu_byte buff[DIBS];
|
||||
int n = 0;
|
||||
do {
|
||||
buff[DIBS - (++n)] = x & 0x7f; /* fill buffer in reverse order */
|
||||
x >>= 7;
|
||||
} while (x != 0);
|
||||
buff[DIBS - 1] |= 0x80; /* mark last byte */
|
||||
dumpVector(D, buff + DIBS - n, n);
|
||||
}
|
||||
|
||||
|
||||
static void dumpInt (DumpState *D, int x) {
|
||||
dumpSize(D, x);
|
||||
}
|
||||
|
||||
|
||||
static void dumpNumber (DumpState *D, lua_Number x) {
|
||||
dumpVar(D, x);
|
||||
}
|
||||
|
||||
|
||||
static void dumpInteger (DumpState *D, lua_Integer x) {
|
||||
dumpVar(D, x);
|
||||
}
|
||||
|
||||
|
||||
static void dumpString (DumpState *D, const TString *s) {
|
||||
if (s == NULL)
|
||||
dumpSize(D, 0);
|
||||
else {
|
||||
size_t size = tsslen(s);
|
||||
const char *str = getstr(s);
|
||||
dumpSize(D, size + 1);
|
||||
dumpVector(D, str, size);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static void dumpCode (DumpState *D, const Proto *f) {
|
||||
dumpInt(D, f->sizecode);
|
||||
dumpVector(D, f->code, f->sizecode);
|
||||
}
|
||||
|
||||
|
||||
static void dumpFunction(DumpState *D, const Proto *f, TString *psource);
|
||||
|
||||
static void dumpConstants (DumpState *D, const Proto *f) {
|
||||
int i;
|
||||
int n = f->sizek;
|
||||
dumpInt(D, n);
|
||||
for (i = 0; i < n; i++) {
|
||||
const TValue *o = &f->k[i];
|
||||
int tt = ttypetag(o);
|
||||
dumpByte(D, tt);
|
||||
switch (tt) {
|
||||
case LUA_VNUMFLT:
|
||||
dumpNumber(D, fltvalue(o));
|
||||
break;
|
||||
case LUA_VNUMINT:
|
||||
dumpInteger(D, ivalue(o));
|
||||
break;
|
||||
case LUA_VSHRSTR:
|
||||
case LUA_VLNGSTR:
|
||||
dumpString(D, tsvalue(o));
|
||||
break;
|
||||
default:
|
||||
lua_assert(tt == LUA_VNIL || tt == LUA_VFALSE || tt == LUA_VTRUE);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static void dumpProtos (DumpState *D, const Proto *f) {
|
||||
int i;
|
||||
int n = f->sizep;
|
||||
dumpInt(D, n);
|
||||
for (i = 0; i < n; i++)
|
||||
dumpFunction(D, f->p[i], f->source);
|
||||
}
|
||||
|
||||
|
||||
static void dumpUpvalues (DumpState *D, const Proto *f) {
|
||||
int i, n = f->sizeupvalues;
|
||||
dumpInt(D, n);
|
||||
for (i = 0; i < n; i++) {
|
||||
dumpByte(D, f->upvalues[i].instack);
|
||||
dumpByte(D, f->upvalues[i].idx);
|
||||
dumpByte(D, f->upvalues[i].kind);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static void dumpDebug (DumpState *D, const Proto *f) {
|
||||
int i, n;
|
||||
n = (D->strip) ? 0 : f->sizelineinfo;
|
||||
dumpInt(D, n);
|
||||
dumpVector(D, f->lineinfo, n);
|
||||
n = (D->strip) ? 0 : f->sizeabslineinfo;
|
||||
dumpInt(D, n);
|
||||
for (i = 0; i < n; i++) {
|
||||
dumpInt(D, f->abslineinfo[i].pc);
|
||||
dumpInt(D, f->abslineinfo[i].line);
|
||||
}
|
||||
n = (D->strip) ? 0 : f->sizelocvars;
|
||||
dumpInt(D, n);
|
||||
for (i = 0; i < n; i++) {
|
||||
dumpString(D, f->locvars[i].varname);
|
||||
dumpInt(D, f->locvars[i].startpc);
|
||||
dumpInt(D, f->locvars[i].endpc);
|
||||
}
|
||||
n = (D->strip) ? 0 : f->sizeupvalues;
|
||||
dumpInt(D, n);
|
||||
for (i = 0; i < n; i++)
|
||||
dumpString(D, f->upvalues[i].name);
|
||||
}
|
||||
|
||||
|
||||
static void dumpFunction (DumpState *D, const Proto *f, TString *psource) {
|
||||
if (D->strip || f->source == psource)
|
||||
dumpString(D, NULL); /* no debug info or same source as its parent */
|
||||
else
|
||||
dumpString(D, f->source);
|
||||
dumpInt(D, f->linedefined);
|
||||
dumpInt(D, f->lastlinedefined);
|
||||
dumpByte(D, f->numparams);
|
||||
dumpByte(D, f->is_vararg);
|
||||
dumpByte(D, f->maxstacksize);
|
||||
dumpCode(D, f);
|
||||
dumpConstants(D, f);
|
||||
dumpUpvalues(D, f);
|
||||
dumpProtos(D, f);
|
||||
dumpDebug(D, f);
|
||||
}
|
||||
|
||||
|
||||
static void dumpHeader (DumpState *D) {
|
||||
dumpLiteral(D, LUA_SIGNATURE);
|
||||
dumpByte(D, LUAC_VERSION);
|
||||
dumpByte(D, LUAC_FORMAT);
|
||||
dumpLiteral(D, LUAC_DATA);
|
||||
dumpByte(D, sizeof(Instruction));
|
||||
dumpByte(D, sizeof(lua_Integer));
|
||||
dumpByte(D, sizeof(lua_Number));
|
||||
dumpInteger(D, LUAC_INT);
|
||||
dumpNumber(D, LUAC_NUM);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** dump Lua function as precompiled chunk
|
||||
*/
|
||||
int luaU_dump(lua_State *L, const Proto *f, lua_Writer w, void *data,
|
||||
int strip) {
|
||||
DumpState D;
|
||||
D.L = L;
|
||||
D.writer = w;
|
||||
D.data = data;
|
||||
D.strip = strip;
|
||||
D.status = 0;
|
||||
dumpHeader(&D);
|
||||
dumpByte(&D, f->sizeupvalues);
|
||||
dumpFunction(&D, f, NULL);
|
||||
return D.status;
|
||||
}
|
||||
|
||||
@ -1,294 +0,0 @@
|
||||
/*
|
||||
** $Id: lfunc.c $
|
||||
** Auxiliary functions to manipulate prototypes and closures
|
||||
** See Copyright Notice in lua.h
|
||||
*/
|
||||
|
||||
#define lfunc_c
|
||||
#define LUA_CORE
|
||||
|
||||
#include "lprefix.h"
|
||||
|
||||
|
||||
#include <stddef.h>
|
||||
|
||||
#include "lua.h"
|
||||
|
||||
#include "ldebug.h"
|
||||
#include "ldo.h"
|
||||
#include "lfunc.h"
|
||||
#include "lgc.h"
|
||||
#include "lmem.h"
|
||||
#include "lobject.h"
|
||||
#include "lstate.h"
|
||||
|
||||
|
||||
|
||||
CClosure *luaF_newCclosure (lua_State *L, int nupvals) {
|
||||
GCObject *o = luaC_newobj(L, LUA_VCCL, sizeCclosure(nupvals));
|
||||
CClosure *c = gco2ccl(o);
|
||||
c->nupvalues = cast_byte(nupvals);
|
||||
return c;
|
||||
}
|
||||
|
||||
|
||||
LClosure *luaF_newLclosure (lua_State *L, int nupvals) {
|
||||
GCObject *o = luaC_newobj(L, LUA_VLCL, sizeLclosure(nupvals));
|
||||
LClosure *c = gco2lcl(o);
|
||||
c->p = NULL;
|
||||
c->nupvalues = cast_byte(nupvals);
|
||||
while (nupvals--) c->upvals[nupvals] = NULL;
|
||||
return c;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** fill a closure with new closed upvalues
|
||||
*/
|
||||
void luaF_initupvals (lua_State *L, LClosure *cl) {
|
||||
int i;
|
||||
for (i = 0; i < cl->nupvalues; i++) {
|
||||
GCObject *o = luaC_newobj(L, LUA_VUPVAL, sizeof(UpVal));
|
||||
UpVal *uv = gco2upv(o);
|
||||
uv->v.p = &uv->u.value; /* make it closed */
|
||||
setnilvalue(uv->v.p);
|
||||
cl->upvals[i] = uv;
|
||||
luaC_objbarrier(L, cl, uv);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Create a new upvalue at the given level, and link it to the list of
|
||||
** open upvalues of 'L' after entry 'prev'.
|
||||
**/
|
||||
static UpVal *newupval (lua_State *L, StkId level, UpVal **prev) {
|
||||
GCObject *o = luaC_newobj(L, LUA_VUPVAL, sizeof(UpVal));
|
||||
UpVal *uv = gco2upv(o);
|
||||
UpVal *next = *prev;
|
||||
uv->v.p = s2v(level); /* current value lives in the stack */
|
||||
uv->u.open.next = next; /* link it to list of open upvalues */
|
||||
uv->u.open.previous = prev;
|
||||
if (next)
|
||||
next->u.open.previous = &uv->u.open.next;
|
||||
*prev = uv;
|
||||
if (!isintwups(L)) { /* thread not in list of threads with upvalues? */
|
||||
L->twups = G(L)->twups; /* link it to the list */
|
||||
G(L)->twups = L;
|
||||
}
|
||||
return uv;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Find and reuse, or create if it does not exist, an upvalue
|
||||
** at the given level.
|
||||
*/
|
||||
UpVal *luaF_findupval (lua_State *L, StkId level) {
|
||||
UpVal **pp = &L->openupval;
|
||||
UpVal *p;
|
||||
lua_assert(isintwups(L) || L->openupval == NULL);
|
||||
while ((p = *pp) != NULL && uplevel(p) >= level) { /* search for it */
|
||||
lua_assert(!isdead(G(L), p));
|
||||
if (uplevel(p) == level) /* corresponding upvalue? */
|
||||
return p; /* return it */
|
||||
pp = &p->u.open.next;
|
||||
}
|
||||
/* not found: create a new upvalue after 'pp' */
|
||||
return newupval(L, level, pp);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Call closing method for object 'obj' with error message 'err'. The
|
||||
** boolean 'yy' controls whether the call is yieldable.
|
||||
** (This function assumes EXTRA_STACK.)
|
||||
*/
|
||||
static void callclosemethod (lua_State *L, TValue *obj, TValue *err, int yy) {
|
||||
StkId top = L->top.p;
|
||||
const TValue *tm = luaT_gettmbyobj(L, obj, TM_CLOSE);
|
||||
setobj2s(L, top, tm); /* will call metamethod... */
|
||||
setobj2s(L, top + 1, obj); /* with 'self' as the 1st argument */
|
||||
setobj2s(L, top + 2, err); /* and error msg. as 2nd argument */
|
||||
L->top.p = top + 3; /* add function and arguments */
|
||||
if (yy)
|
||||
luaD_call(L, top, 0);
|
||||
else
|
||||
luaD_callnoyield(L, top, 0);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Check whether object at given level has a close metamethod and raise
|
||||
** an error if not.
|
||||
*/
|
||||
static void checkclosemth (lua_State *L, StkId level) {
|
||||
const TValue *tm = luaT_gettmbyobj(L, s2v(level), TM_CLOSE);
|
||||
if (ttisnil(tm)) { /* no metamethod? */
|
||||
int idx = cast_int(level - L->ci->func.p); /* variable index */
|
||||
const char *vname = luaG_findlocal(L, L->ci, idx, NULL);
|
||||
if (vname == NULL) vname = "?";
|
||||
luaG_runerror(L, "variable '%s' got a non-closable value", vname);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Prepare and call a closing method.
|
||||
** If status is CLOSEKTOP, the call to the closing method will be pushed
|
||||
** at the top of the stack. Otherwise, values can be pushed right after
|
||||
** the 'level' of the upvalue being closed, as everything after that
|
||||
** won't be used again.
|
||||
*/
|
||||
static void prepcallclosemth (lua_State *L, StkId level, int status, int yy) {
|
||||
TValue *uv = s2v(level); /* value being closed */
|
||||
TValue *errobj;
|
||||
if (status == CLOSEKTOP)
|
||||
errobj = &G(L)->nilvalue; /* error object is nil */
|
||||
else { /* 'luaD_seterrorobj' will set top to level + 2 */
|
||||
errobj = s2v(level + 1); /* error object goes after 'uv' */
|
||||
luaD_seterrorobj(L, status, level + 1); /* set error object */
|
||||
}
|
||||
callclosemethod(L, uv, errobj, yy);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Maximum value for deltas in 'tbclist', dependent on the type
|
||||
** of delta. (This macro assumes that an 'L' is in scope where it
|
||||
** is used.)
|
||||
*/
|
||||
#define MAXDELTA \
|
||||
((256ul << ((sizeof(L->stack.p->tbclist.delta) - 1) * 8)) - 1)
|
||||
|
||||
|
||||
/*
|
||||
** Insert a variable in the list of to-be-closed variables.
|
||||
*/
|
||||
void luaF_newtbcupval (lua_State *L, StkId level) {
|
||||
lua_assert(level > L->tbclist.p);
|
||||
if (l_isfalse(s2v(level)))
|
||||
return; /* false doesn't need to be closed */
|
||||
checkclosemth(L, level); /* value must have a close method */
|
||||
while (cast_uint(level - L->tbclist.p) > MAXDELTA) {
|
||||
L->tbclist.p += MAXDELTA; /* create a dummy node at maximum delta */
|
||||
L->tbclist.p->tbclist.delta = 0;
|
||||
}
|
||||
level->tbclist.delta = cast(unsigned short, level - L->tbclist.p);
|
||||
L->tbclist.p = level;
|
||||
}
|
||||
|
||||
|
||||
void luaF_unlinkupval (UpVal *uv) {
|
||||
lua_assert(upisopen(uv));
|
||||
*uv->u.open.previous = uv->u.open.next;
|
||||
if (uv->u.open.next)
|
||||
uv->u.open.next->u.open.previous = uv->u.open.previous;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Close all upvalues up to the given stack level.
|
||||
*/
|
||||
void luaF_closeupval (lua_State *L, StkId level) {
|
||||
UpVal *uv;
|
||||
StkId upl; /* stack index pointed by 'uv' */
|
||||
while ((uv = L->openupval) != NULL && (upl = uplevel(uv)) >= level) {
|
||||
TValue *slot = &uv->u.value; /* new position for value */
|
||||
lua_assert(uplevel(uv) < L->top.p);
|
||||
luaF_unlinkupval(uv); /* remove upvalue from 'openupval' list */
|
||||
setobj(L, slot, uv->v.p); /* move value to upvalue slot */
|
||||
uv->v.p = slot; /* now current value lives here */
|
||||
if (!iswhite(uv)) { /* neither white nor dead? */
|
||||
nw2black(uv); /* closed upvalues cannot be gray */
|
||||
luaC_barrier(L, uv, slot);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Remove first element from the tbclist plus its dummy nodes.
|
||||
*/
|
||||
static void poptbclist (lua_State *L) {
|
||||
StkId tbc = L->tbclist.p;
|
||||
lua_assert(tbc->tbclist.delta > 0); /* first element cannot be dummy */
|
||||
tbc -= tbc->tbclist.delta;
|
||||
while (tbc > L->stack.p && tbc->tbclist.delta == 0)
|
||||
tbc -= MAXDELTA; /* remove dummy nodes */
|
||||
L->tbclist.p = tbc;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Close all upvalues and to-be-closed variables up to the given stack
|
||||
** level. Return restored 'level'.
|
||||
*/
|
||||
StkId luaF_close (lua_State *L, StkId level, int status, int yy) {
|
||||
ptrdiff_t levelrel = savestack(L, level);
|
||||
luaF_closeupval(L, level); /* first, close the upvalues */
|
||||
while (L->tbclist.p >= level) { /* traverse tbc's down to that level */
|
||||
StkId tbc = L->tbclist.p; /* get variable index */
|
||||
poptbclist(L); /* remove it from list */
|
||||
prepcallclosemth(L, tbc, status, yy); /* close variable */
|
||||
level = restorestack(L, levelrel);
|
||||
}
|
||||
return level;
|
||||
}
|
||||
|
||||
|
||||
Proto *luaF_newproto (lua_State *L) {
|
||||
GCObject *o = luaC_newobj(L, LUA_VPROTO, sizeof(Proto));
|
||||
Proto *f = gco2p(o);
|
||||
f->k = NULL;
|
||||
f->sizek = 0;
|
||||
f->p = NULL;
|
||||
f->sizep = 0;
|
||||
f->code = NULL;
|
||||
f->sizecode = 0;
|
||||
f->lineinfo = NULL;
|
||||
f->sizelineinfo = 0;
|
||||
f->abslineinfo = NULL;
|
||||
f->sizeabslineinfo = 0;
|
||||
f->upvalues = NULL;
|
||||
f->sizeupvalues = 0;
|
||||
f->numparams = 0;
|
||||
f->is_vararg = 0;
|
||||
f->maxstacksize = 0;
|
||||
f->locvars = NULL;
|
||||
f->sizelocvars = 0;
|
||||
f->linedefined = 0;
|
||||
f->lastlinedefined = 0;
|
||||
f->source = NULL;
|
||||
return f;
|
||||
}
|
||||
|
||||
|
||||
void luaF_freeproto (lua_State *L, Proto *f) {
|
||||
luaM_freearray(L, f->code, f->sizecode);
|
||||
luaM_freearray(L, f->p, f->sizep);
|
||||
luaM_freearray(L, f->k, f->sizek);
|
||||
luaM_freearray(L, f->lineinfo, f->sizelineinfo);
|
||||
luaM_freearray(L, f->abslineinfo, f->sizeabslineinfo);
|
||||
luaM_freearray(L, f->locvars, f->sizelocvars);
|
||||
luaM_freearray(L, f->upvalues, f->sizeupvalues);
|
||||
luaM_free(L, f);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Look for n-th local variable at line 'line' in function 'func'.
|
||||
** Returns NULL if not found.
|
||||
*/
|
||||
const char *luaF_getlocalname (const Proto *f, int local_number, int pc) {
|
||||
int i;
|
||||
for (i = 0; i<f->sizelocvars && f->locvars[i].startpc <= pc; i++) {
|
||||
if (pc < f->locvars[i].endpc) { /* is variable active? */
|
||||
local_number--;
|
||||
if (local_number == 0)
|
||||
return getstr(f->locvars[i].varname);
|
||||
}
|
||||
}
|
||||
return NULL; /* not found */
|
||||
}
|
||||
|
||||
@ -1,64 +0,0 @@
|
||||
/*
|
||||
** $Id: lfunc.h $
|
||||
** Auxiliary functions to manipulate prototypes and closures
|
||||
** See Copyright Notice in lua.h
|
||||
*/
|
||||
|
||||
#ifndef lfunc_h
|
||||
#define lfunc_h
|
||||
|
||||
|
||||
#include "lobject.h"
|
||||
|
||||
|
||||
#define sizeCclosure(n) (cast_int(offsetof(CClosure, upvalue)) + \
|
||||
cast_int(sizeof(TValue)) * (n))
|
||||
|
||||
#define sizeLclosure(n) (cast_int(offsetof(LClosure, upvals)) + \
|
||||
cast_int(sizeof(TValue *)) * (n))
|
||||
|
||||
|
||||
/* test whether thread is in 'twups' list */
|
||||
#define isintwups(L) (L->twups != L)
|
||||
|
||||
|
||||
/*
|
||||
** maximum number of upvalues in a closure (both C and Lua). (Value
|
||||
** must fit in a VM register.)
|
||||
*/
|
||||
#define MAXUPVAL 255
|
||||
|
||||
|
||||
#define upisopen(up) ((up)->v.p != &(up)->u.value)
|
||||
|
||||
|
||||
#define uplevel(up) check_exp(upisopen(up), cast(StkId, (up)->v.p))
|
||||
|
||||
|
||||
/*
|
||||
** maximum number of misses before giving up the cache of closures
|
||||
** in prototypes
|
||||
*/
|
||||
#define MAXMISS 10
|
||||
|
||||
|
||||
|
||||
/* special status to close upvalues preserving the top of the stack */
|
||||
#define CLOSEKTOP (-1)
|
||||
|
||||
|
||||
LUAI_FUNC Proto *luaF_newproto (lua_State *L);
|
||||
LUAI_FUNC CClosure *luaF_newCclosure (lua_State *L, int nupvals);
|
||||
LUAI_FUNC LClosure *luaF_newLclosure (lua_State *L, int nupvals);
|
||||
LUAI_FUNC void luaF_initupvals (lua_State *L, LClosure *cl);
|
||||
LUAI_FUNC UpVal *luaF_findupval (lua_State *L, StkId level);
|
||||
LUAI_FUNC void luaF_newtbcupval (lua_State *L, StkId level);
|
||||
LUAI_FUNC void luaF_closeupval (lua_State *L, StkId level);
|
||||
LUAI_FUNC StkId luaF_close (lua_State *L, StkId level, int status, int yy);
|
||||
LUAI_FUNC void luaF_unlinkupval (UpVal *uv);
|
||||
LUAI_FUNC void luaF_freeproto (lua_State *L, Proto *f);
|
||||
LUAI_FUNC const char *luaF_getlocalname (const Proto *func, int local_number,
|
||||
int pc);
|
||||
|
||||
|
||||
#endif
|
||||
File diff suppressed because it is too large
Load Diff
@ -1,202 +0,0 @@
|
||||
/*
|
||||
** $Id: lgc.h $
|
||||
** Garbage Collector
|
||||
** See Copyright Notice in lua.h
|
||||
*/
|
||||
|
||||
#ifndef lgc_h
|
||||
#define lgc_h
|
||||
|
||||
|
||||
#include "lobject.h"
|
||||
#include "lstate.h"
|
||||
|
||||
/*
|
||||
** Collectable objects may have one of three colors: white, which means
|
||||
** the object is not marked; gray, which means the object is marked, but
|
||||
** its references may be not marked; and black, which means that the
|
||||
** object and all its references are marked. The main invariant of the
|
||||
** garbage collector, while marking objects, is that a black object can
|
||||
** never point to a white one. Moreover, any gray object must be in a
|
||||
** "gray list" (gray, grayagain, weak, allweak, ephemeron) so that it
|
||||
** can be visited again before finishing the collection cycle. (Open
|
||||
** upvalues are an exception to this rule.) These lists have no meaning
|
||||
** when the invariant is not being enforced (e.g., sweep phase).
|
||||
*/
|
||||
|
||||
|
||||
/*
|
||||
** Possible states of the Garbage Collector
|
||||
*/
|
||||
#define GCSpropagate 0
|
||||
#define GCSenteratomic 1
|
||||
#define GCSatomic 2
|
||||
#define GCSswpallgc 3
|
||||
#define GCSswpfinobj 4
|
||||
#define GCSswptobefnz 5
|
||||
#define GCSswpend 6
|
||||
#define GCScallfin 7
|
||||
#define GCSpause 8
|
||||
|
||||
|
||||
#define issweepphase(g) \
|
||||
(GCSswpallgc <= (g)->gcstate && (g)->gcstate <= GCSswpend)
|
||||
|
||||
|
||||
/*
|
||||
** macro to tell when main invariant (white objects cannot point to black
|
||||
** ones) must be kept. During a collection, the sweep
|
||||
** phase may break the invariant, as objects turned white may point to
|
||||
** still-black objects. The invariant is restored when sweep ends and
|
||||
** all objects are white again.
|
||||
*/
|
||||
|
||||
#define keepinvariant(g) ((g)->gcstate <= GCSatomic)
|
||||
|
||||
|
||||
/*
|
||||
** some useful bit tricks
|
||||
*/
|
||||
#define resetbits(x,m) ((x) &= cast_byte(~(m)))
|
||||
#define setbits(x,m) ((x) |= (m))
|
||||
#define testbits(x,m) ((x) & (m))
|
||||
#define bitmask(b) (1<<(b))
|
||||
#define bit2mask(b1,b2) (bitmask(b1) | bitmask(b2))
|
||||
#define l_setbit(x,b) setbits(x, bitmask(b))
|
||||
#define resetbit(x,b) resetbits(x, bitmask(b))
|
||||
#define testbit(x,b) testbits(x, bitmask(b))
|
||||
|
||||
|
||||
/*
|
||||
** Layout for bit use in 'marked' field. First three bits are
|
||||
** used for object "age" in generational mode. Last bit is used
|
||||
** by tests.
|
||||
*/
|
||||
#define WHITE0BIT 3 /* object is white (type 0) */
|
||||
#define WHITE1BIT 4 /* object is white (type 1) */
|
||||
#define BLACKBIT 5 /* object is black */
|
||||
#define FINALIZEDBIT 6 /* object has been marked for finalization */
|
||||
|
||||
#define TESTBIT 7
|
||||
|
||||
|
||||
|
||||
#define WHITEBITS bit2mask(WHITE0BIT, WHITE1BIT)
|
||||
|
||||
|
||||
#define iswhite(x) testbits((x)->marked, WHITEBITS)
|
||||
#define isblack(x) testbit((x)->marked, BLACKBIT)
|
||||
#define isgray(x) /* neither white nor black */ \
|
||||
(!testbits((x)->marked, WHITEBITS | bitmask(BLACKBIT)))
|
||||
|
||||
#define tofinalize(x) testbit((x)->marked, FINALIZEDBIT)
|
||||
|
||||
#define otherwhite(g) ((g)->currentwhite ^ WHITEBITS)
|
||||
#define isdeadm(ow,m) ((m) & (ow))
|
||||
#define isdead(g,v) isdeadm(otherwhite(g), (v)->marked)
|
||||
|
||||
#define changewhite(x) ((x)->marked ^= WHITEBITS)
|
||||
#define nw2black(x) \
|
||||
check_exp(!iswhite(x), l_setbit((x)->marked, BLACKBIT))
|
||||
|
||||
#define luaC_white(g) cast_byte((g)->currentwhite & WHITEBITS)
|
||||
|
||||
|
||||
/* object age in generational mode */
|
||||
#define G_NEW 0 /* created in current cycle */
|
||||
#define G_SURVIVAL 1 /* created in previous cycle */
|
||||
#define G_OLD0 2 /* marked old by frw. barrier in this cycle */
|
||||
#define G_OLD1 3 /* first full cycle as old */
|
||||
#define G_OLD 4 /* really old object (not to be visited) */
|
||||
#define G_TOUCHED1 5 /* old object touched this cycle */
|
||||
#define G_TOUCHED2 6 /* old object touched in previous cycle */
|
||||
|
||||
#define AGEBITS 7 /* all age bits (111) */
|
||||
|
||||
#define getage(o) ((o)->marked & AGEBITS)
|
||||
#define setage(o,a) ((o)->marked = cast_byte(((o)->marked & (~AGEBITS)) | a))
|
||||
#define isold(o) (getage(o) > G_SURVIVAL)
|
||||
|
||||
#define changeage(o,f,t) \
|
||||
check_exp(getage(o) == (f), (o)->marked ^= ((f)^(t)))
|
||||
|
||||
|
||||
/* Default Values for GC parameters */
|
||||
#define LUAI_GENMAJORMUL 100
|
||||
#define LUAI_GENMINORMUL 20
|
||||
|
||||
/* wait memory to double before starting new cycle */
|
||||
#define LUAI_GCPAUSE 200
|
||||
|
||||
/*
|
||||
** some gc parameters are stored divided by 4 to allow a maximum value
|
||||
** up to 1023 in a 'lu_byte'.
|
||||
*/
|
||||
#define getgcparam(p) ((p) * 4)
|
||||
#define setgcparam(p,v) ((p) = (v) / 4)
|
||||
|
||||
#define LUAI_GCMUL 100
|
||||
|
||||
/* how much to allocate before next GC step (log2) */
|
||||
#define LUAI_GCSTEPSIZE 13 /* 8 KB */
|
||||
|
||||
|
||||
/*
|
||||
** Check whether the declared GC mode is generational. While in
|
||||
** generational mode, the collector can go temporarily to incremental
|
||||
** mode to improve performance. This is signaled by 'g->lastatomic != 0'.
|
||||
*/
|
||||
#define isdecGCmodegen(g) (g->gckind == KGC_GEN || g->lastatomic != 0)
|
||||
|
||||
|
||||
/*
|
||||
** Control when GC is running:
|
||||
*/
|
||||
#define GCSTPUSR 1 /* bit true when GC stopped by user */
|
||||
#define GCSTPGC 2 /* bit true when GC stopped by itself */
|
||||
#define GCSTPCLS 4 /* bit true when closing Lua state */
|
||||
#define gcrunning(g) ((g)->gcstp == 0)
|
||||
|
||||
|
||||
/*
|
||||
** Does one step of collection when debt becomes positive. 'pre'/'pos'
|
||||
** allows some adjustments to be done only when needed. macro
|
||||
** 'condchangemem' is used only for heavy tests (forcing a full
|
||||
** GC cycle on every opportunity)
|
||||
*/
|
||||
#define luaC_condGC(L,pre,pos) \
|
||||
{ if (G(L)->GCdebt > 0) { pre; luaC_step(L); pos;}; \
|
||||
condchangemem(L,pre,pos); }
|
||||
|
||||
/* more often than not, 'pre'/'pos' are empty */
|
||||
#define luaC_checkGC(L) luaC_condGC(L,(void)0,(void)0)
|
||||
|
||||
|
||||
#define luaC_objbarrier(L,p,o) ( \
|
||||
(isblack(p) && iswhite(o)) ? \
|
||||
luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0))
|
||||
|
||||
#define luaC_barrier(L,p,v) ( \
|
||||
iscollectable(v) ? luaC_objbarrier(L,p,gcvalue(v)) : cast_void(0))
|
||||
|
||||
#define luaC_objbarrierback(L,p,o) ( \
|
||||
(isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0))
|
||||
|
||||
#define luaC_barrierback(L,p,v) ( \
|
||||
iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0))
|
||||
|
||||
LUAI_FUNC void luaC_fix (lua_State *L, GCObject *o);
|
||||
LUAI_FUNC void luaC_freeallobjects (lua_State *L);
|
||||
LUAI_FUNC void luaC_step (lua_State *L);
|
||||
LUAI_FUNC void luaC_runtilstate (lua_State *L, int statesmask);
|
||||
LUAI_FUNC void luaC_fullgc (lua_State *L, int isemergency);
|
||||
LUAI_FUNC GCObject *luaC_newobj (lua_State *L, int tt, size_t sz);
|
||||
LUAI_FUNC GCObject *luaC_newobjdt (lua_State *L, int tt, size_t sz,
|
||||
size_t offset);
|
||||
LUAI_FUNC void luaC_barrier_ (lua_State *L, GCObject *o, GCObject *v);
|
||||
LUAI_FUNC void luaC_barrierback_ (lua_State *L, GCObject *o);
|
||||
LUAI_FUNC void luaC_checkfinalizer (lua_State *L, GCObject *o, Table *mt);
|
||||
LUAI_FUNC void luaC_changemode (lua_State *L, int newmode);
|
||||
|
||||
|
||||
#endif
|
||||
@ -1,65 +0,0 @@
|
||||
/*
|
||||
** $Id: linit.c $
|
||||
** Initialization of libraries for lua.c and other clients
|
||||
** See Copyright Notice in lua.h
|
||||
*/
|
||||
|
||||
|
||||
#define linit_c
|
||||
#define LUA_LIB
|
||||
|
||||
/*
|
||||
** If you embed Lua in your program and need to open the standard
|
||||
** libraries, call luaL_openlibs in your program. If you need a
|
||||
** different set of libraries, copy this file to your project and edit
|
||||
** it to suit your needs.
|
||||
**
|
||||
** You can also *preload* libraries, so that a later 'require' can
|
||||
** open the library, which is already linked to the application.
|
||||
** For that, do the following code:
|
||||
**
|
||||
** luaL_getsubtable(L, LUA_REGISTRYINDEX, LUA_PRELOAD_TABLE);
|
||||
** lua_pushcfunction(L, luaopen_modname);
|
||||
** lua_setfield(L, -2, modname);
|
||||
** lua_pop(L, 1); // remove PRELOAD table
|
||||
*/
|
||||
|
||||
#include "lprefix.h"
|
||||
|
||||
|
||||
#include <stddef.h>
|
||||
|
||||
#include "lua.h"
|
||||
|
||||
#include "lualib.h"
|
||||
#include "lauxlib.h"
|
||||
|
||||
|
||||
/*
|
||||
** these libs are loaded by lua.c and are readily available to any Lua
|
||||
** program
|
||||
*/
|
||||
static const luaL_Reg loadedlibs[] = {
|
||||
{LUA_GNAME, luaopen_base},
|
||||
{LUA_LOADLIBNAME, luaopen_package},
|
||||
{LUA_COLIBNAME, luaopen_coroutine},
|
||||
{LUA_TABLIBNAME, luaopen_table},
|
||||
{LUA_IOLIBNAME, luaopen_io},
|
||||
{LUA_OSLIBNAME, luaopen_os},
|
||||
{LUA_STRLIBNAME, luaopen_string},
|
||||
{LUA_MATHLIBNAME, luaopen_math},
|
||||
{LUA_UTF8LIBNAME, luaopen_utf8},
|
||||
{LUA_DBLIBNAME, luaopen_debug},
|
||||
{NULL, NULL}
|
||||
};
|
||||
|
||||
|
||||
LUALIB_API void luaL_openlibs (lua_State *L) {
|
||||
const luaL_Reg *lib;
|
||||
/* "require" functions from 'loadedlibs' and set results to global table */
|
||||
for (lib = loadedlibs; lib->func; lib++) {
|
||||
luaL_requiref(L, lib->name, lib->func, 1);
|
||||
lua_pop(L, 1); /* remove lib */
|
||||
}
|
||||
}
|
||||
|
||||
@ -1,112 +0,0 @@
|
||||
/*
|
||||
** $Id: ljumptab.h $
|
||||
** Jump Table for the Lua interpreter
|
||||
** See Copyright Notice in lua.h
|
||||
*/
|
||||
|
||||
|
||||
#undef vmdispatch
|
||||
#undef vmcase
|
||||
#undef vmbreak
|
||||
|
||||
#define vmdispatch(x) goto *disptab[x];
|
||||
|
||||
#define vmcase(l) L_##l:
|
||||
|
||||
#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i));
|
||||
|
||||
|
||||
static const void *const disptab[NUM_OPCODES] = {
|
||||
|
||||
#if 0
|
||||
** you can update the following list with this command:
|
||||
**
|
||||
** sed -n '/^OP_/\!d; s/OP_/\&\&L_OP_/ ; s/,.*/,/ ; s/\/.*// ; p' lopcodes.h
|
||||
**
|
||||
#endif
|
||||
|
||||
&&L_OP_MOVE,
|
||||
&&L_OP_LOADI,
|
||||
&&L_OP_LOADF,
|
||||
&&L_OP_LOADK,
|
||||
&&L_OP_LOADKX,
|
||||
&&L_OP_LOADFALSE,
|
||||
&&L_OP_LFALSESKIP,
|
||||
&&L_OP_LOADTRUE,
|
||||
&&L_OP_LOADNIL,
|
||||
&&L_OP_GETUPVAL,
|
||||
&&L_OP_SETUPVAL,
|
||||
&&L_OP_GETTABUP,
|
||||
&&L_OP_GETTABLE,
|
||||
&&L_OP_GETI,
|
||||
&&L_OP_GETFIELD,
|
||||
&&L_OP_SETTABUP,
|
||||
&&L_OP_SETTABLE,
|
||||
&&L_OP_SETI,
|
||||
&&L_OP_SETFIELD,
|
||||
&&L_OP_NEWTABLE,
|
||||
&&L_OP_SELF,
|
||||
&&L_OP_ADDI,
|
||||
&&L_OP_ADDK,
|
||||
&&L_OP_SUBK,
|
||||
&&L_OP_MULK,
|
||||
&&L_OP_MODK,
|
||||
&&L_OP_POWK,
|
||||
&&L_OP_DIVK,
|
||||
&&L_OP_IDIVK,
|
||||
&&L_OP_BANDK,
|
||||
&&L_OP_BORK,
|
||||
&&L_OP_BXORK,
|
||||
&&L_OP_SHRI,
|
||||
&&L_OP_SHLI,
|
||||
&&L_OP_ADD,
|
||||
&&L_OP_SUB,
|
||||
&&L_OP_MUL,
|
||||
&&L_OP_MOD,
|
||||
&&L_OP_POW,
|
||||
&&L_OP_DIV,
|
||||
&&L_OP_IDIV,
|
||||
&&L_OP_BAND,
|
||||
&&L_OP_BOR,
|
||||
&&L_OP_BXOR,
|
||||
&&L_OP_SHL,
|
||||
&&L_OP_SHR,
|
||||
&&L_OP_MMBIN,
|
||||
&&L_OP_MMBINI,
|
||||
&&L_OP_MMBINK,
|
||||
&&L_OP_UNM,
|
||||
&&L_OP_BNOT,
|
||||
&&L_OP_NOT,
|
||||
&&L_OP_LEN,
|
||||
&&L_OP_CONCAT,
|
||||
&&L_OP_CLOSE,
|
||||
&&L_OP_TBC,
|
||||
&&L_OP_JMP,
|
||||
&&L_OP_EQ,
|
||||
&&L_OP_LT,
|
||||
&&L_OP_LE,
|
||||
&&L_OP_EQK,
|
||||
&&L_OP_EQI,
|
||||
&&L_OP_LTI,
|
||||
&&L_OP_LEI,
|
||||
&&L_OP_GTI,
|
||||
&&L_OP_GEI,
|
||||
&&L_OP_TEST,
|
||||
&&L_OP_TESTSET,
|
||||
&&L_OP_CALL,
|
||||
&&L_OP_TAILCALL,
|
||||
&&L_OP_RETURN,
|
||||
&&L_OP_RETURN0,
|
||||
&&L_OP_RETURN1,
|
||||
&&L_OP_FORLOOP,
|
||||
&&L_OP_FORPREP,
|
||||
&&L_OP_TFORPREP,
|
||||
&&L_OP_TFORCALL,
|
||||
&&L_OP_TFORLOOP,
|
||||
&&L_OP_SETLIST,
|
||||
&&L_OP_CLOSURE,
|
||||
&&L_OP_VARARG,
|
||||
&&L_OP_VARARGPREP,
|
||||
&&L_OP_EXTRAARG
|
||||
|
||||
};
|
||||
@ -1,581 +0,0 @@
|
||||
/*
|
||||
** $Id: llex.c $
|
||||
** Lexical Analyzer
|
||||
** See Copyright Notice in lua.h
|
||||
*/
|
||||
|
||||
#define llex_c
|
||||
#define LUA_CORE
|
||||
|
||||
#include "lprefix.h"
|
||||
|
||||
|
||||
#include <locale.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "lua.h"
|
||||
|
||||
#include "lctype.h"
|
||||
#include "ldebug.h"
|
||||
#include "ldo.h"
|
||||
#include "lgc.h"
|
||||
#include "llex.h"
|
||||
#include "lobject.h"
|
||||
#include "lparser.h"
|
||||
#include "lstate.h"
|
||||
#include "lstring.h"
|
||||
#include "ltable.h"
|
||||
#include "lzio.h"
|
||||
|
||||
|
||||
|
||||
#define next(ls) (ls->current = zgetc(ls->z))
|
||||
|
||||
|
||||
|
||||
#define currIsNewline(ls) (ls->current == '\n' || ls->current == '\r')
|
||||
|
||||
|
||||
/* ORDER RESERVED */
|
||||
static const char *const luaX_tokens [] = {
|
||||
"and", "break", "do", "else", "elseif",
|
||||
"end", "false", "for", "function", "goto", "if",
|
||||
"in", "local", "nil", "not", "or", "repeat",
|
||||
"return", "then", "true", "until", "while",
|
||||
"//", "..", "...", "==", ">=", "<=", "~=",
|
||||
"<<", ">>", "::", "<eof>",
|
||||
"<number>", "<integer>", "<name>", "<string>"
|
||||
};
|
||||
|
||||
|
||||
#define save_and_next(ls) (save(ls, ls->current), next(ls))
|
||||
|
||||
|
||||
static l_noret lexerror (LexState *ls, const char *msg, int token);
|
||||
|
||||
|
||||
static void save (LexState *ls, int c) {
|
||||
Mbuffer *b = ls->buff;
|
||||
if (luaZ_bufflen(b) + 1 > luaZ_sizebuffer(b)) {
|
||||
size_t newsize;
|
||||
if (luaZ_sizebuffer(b) >= MAX_SIZE/2)
|
||||
lexerror(ls, "lexical element too long", 0);
|
||||
newsize = luaZ_sizebuffer(b) * 2;
|
||||
luaZ_resizebuffer(ls->L, b, newsize);
|
||||
}
|
||||
b->buffer[luaZ_bufflen(b)++] = cast_char(c);
|
||||
}
|
||||
|
||||
|
||||
void luaX_init (lua_State *L) {
|
||||
int i;
|
||||
TString *e = luaS_newliteral(L, LUA_ENV); /* create env name */
|
||||
luaC_fix(L, obj2gco(e)); /* never collect this name */
|
||||
for (i=0; i<NUM_RESERVED; i++) {
|
||||
TString *ts = luaS_new(L, luaX_tokens[i]);
|
||||
luaC_fix(L, obj2gco(ts)); /* reserved words are never collected */
|
||||
ts->extra = cast_byte(i+1); /* reserved word */
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
const char *luaX_token2str (LexState *ls, int token) {
|
||||
if (token < FIRST_RESERVED) { /* single-byte symbols? */
|
||||
if (lisprint(token))
|
||||
return luaO_pushfstring(ls->L, "'%c'", token);
|
||||
else /* control character */
|
||||
return luaO_pushfstring(ls->L, "'<\\%d>'", token);
|
||||
}
|
||||
else {
|
||||
const char *s = luaX_tokens[token - FIRST_RESERVED];
|
||||
if (token < TK_EOS) /* fixed format (symbols and reserved words)? */
|
||||
return luaO_pushfstring(ls->L, "'%s'", s);
|
||||
else /* names, strings, and numerals */
|
||||
return s;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static const char *txtToken (LexState *ls, int token) {
|
||||
switch (token) {
|
||||
case TK_NAME: case TK_STRING:
|
||||
case TK_FLT: case TK_INT:
|
||||
save(ls, '\0');
|
||||
return luaO_pushfstring(ls->L, "'%s'", luaZ_buffer(ls->buff));
|
||||
default:
|
||||
return luaX_token2str(ls, token);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static l_noret lexerror (LexState *ls, const char *msg, int token) {
|
||||
msg = luaG_addinfo(ls->L, msg, ls->source, ls->linenumber);
|
||||
if (token)
|
||||
luaO_pushfstring(ls->L, "%s near %s", msg, txtToken(ls, token));
|
||||
luaD_throw(ls->L, LUA_ERRSYNTAX);
|
||||
}
|
||||
|
||||
|
||||
l_noret luaX_syntaxerror (LexState *ls, const char *msg) {
|
||||
lexerror(ls, msg, ls->t.token);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Creates a new string and anchors it in scanner's table so that it
|
||||
** will not be collected until the end of the compilation; by that time
|
||||
** it should be anchored somewhere. It also internalizes long strings,
|
||||
** ensuring there is only one copy of each unique string. The table
|
||||
** here is used as a set: the string enters as the key, while its value
|
||||
** is irrelevant. We use the string itself as the value only because it
|
||||
** is a TValue readily available. Later, the code generation can change
|
||||
** this value.
|
||||
*/
|
||||
TString *luaX_newstring (LexState *ls, const char *str, size_t l) {
|
||||
lua_State *L = ls->L;
|
||||
TString *ts = luaS_newlstr(L, str, l); /* create new string */
|
||||
const TValue *o = luaH_getstr(ls->h, ts);
|
||||
if (!ttisnil(o)) /* string already present? */
|
||||
ts = keystrval(nodefromval(o)); /* get saved copy */
|
||||
else { /* not in use yet */
|
||||
TValue *stv = s2v(L->top.p++); /* reserve stack space for string */
|
||||
setsvalue(L, stv, ts); /* temporarily anchor the string */
|
||||
luaH_finishset(L, ls->h, stv, o, stv); /* t[string] = string */
|
||||
/* table is not a metatable, so it does not need to invalidate cache */
|
||||
luaC_checkGC(L);
|
||||
L->top.p--; /* remove string from stack */
|
||||
}
|
||||
return ts;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** increment line number and skips newline sequence (any of
|
||||
** \n, \r, \n\r, or \r\n)
|
||||
*/
|
||||
static void inclinenumber (LexState *ls) {
|
||||
int old = ls->current;
|
||||
lua_assert(currIsNewline(ls));
|
||||
next(ls); /* skip '\n' or '\r' */
|
||||
if (currIsNewline(ls) && ls->current != old)
|
||||
next(ls); /* skip '\n\r' or '\r\n' */
|
||||
if (++ls->linenumber >= MAX_INT)
|
||||
lexerror(ls, "chunk has too many lines", 0);
|
||||
}
|
||||
|
||||
|
||||
void luaX_setinput (lua_State *L, LexState *ls, ZIO *z, TString *source,
|
||||
int firstchar) {
|
||||
ls->t.token = 0;
|
||||
ls->L = L;
|
||||
ls->current = firstchar;
|
||||
ls->lookahead.token = TK_EOS; /* no look-ahead token */
|
||||
ls->z = z;
|
||||
ls->fs = NULL;
|
||||
ls->linenumber = 1;
|
||||
ls->lastline = 1;
|
||||
ls->source = source;
|
||||
ls->envn = luaS_newliteral(L, LUA_ENV); /* get env name */
|
||||
luaZ_resizebuffer(ls->L, ls->buff, LUA_MINBUFFER); /* initialize buffer */
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*
|
||||
** =======================================================
|
||||
** LEXICAL ANALYZER
|
||||
** =======================================================
|
||||
*/
|
||||
|
||||
|
||||
static int check_next1 (LexState *ls, int c) {
|
||||
if (ls->current == c) {
|
||||
next(ls);
|
||||
return 1;
|
||||
}
|
||||
else return 0;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Check whether current char is in set 'set' (with two chars) and
|
||||
** saves it
|
||||
*/
|
||||
static int check_next2 (LexState *ls, const char *set) {
|
||||
lua_assert(set[2] == '\0');
|
||||
if (ls->current == set[0] || ls->current == set[1]) {
|
||||
save_and_next(ls);
|
||||
return 1;
|
||||
}
|
||||
else return 0;
|
||||
}
|
||||
|
||||
|
||||
/* LUA_NUMBER */
|
||||
/*
|
||||
** This function is quite liberal in what it accepts, as 'luaO_str2num'
|
||||
** will reject ill-formed numerals. Roughly, it accepts the following
|
||||
** pattern:
|
||||
**
|
||||
** %d(%x|%.|([Ee][+-]?))* | 0[Xx](%x|%.|([Pp][+-]?))*
|
||||
**
|
||||
** The only tricky part is to accept [+-] only after a valid exponent
|
||||
** mark, to avoid reading '3-4' or '0xe+1' as a single number.
|
||||
**
|
||||
** The caller might have already read an initial dot.
|
||||
*/
|
||||
static int read_numeral (LexState *ls, SemInfo *seminfo) {
|
||||
TValue obj;
|
||||
const char *expo = "Ee";
|
||||
int first = ls->current;
|
||||
lua_assert(lisdigit(ls->current));
|
||||
save_and_next(ls);
|
||||
if (first == '0' && check_next2(ls, "xX")) /* hexadecimal? */
|
||||
expo = "Pp";
|
||||
for (;;) {
|
||||
if (check_next2(ls, expo)) /* exponent mark? */
|
||||
check_next2(ls, "-+"); /* optional exponent sign */
|
||||
else if (lisxdigit(ls->current) || ls->current == '.') /* '%x|%.' */
|
||||
save_and_next(ls);
|
||||
else break;
|
||||
}
|
||||
if (lislalpha(ls->current)) /* is numeral touching a letter? */
|
||||
save_and_next(ls); /* force an error */
|
||||
save(ls, '\0');
|
||||
if (luaO_str2num(luaZ_buffer(ls->buff), &obj) == 0) /* format error? */
|
||||
lexerror(ls, "malformed number", TK_FLT);
|
||||
if (ttisinteger(&obj)) {
|
||||
seminfo->i = ivalue(&obj);
|
||||
return TK_INT;
|
||||
}
|
||||
else {
|
||||
lua_assert(ttisfloat(&obj));
|
||||
seminfo->r = fltvalue(&obj);
|
||||
return TK_FLT;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** read a sequence '[=*[' or ']=*]', leaving the last bracket. If
|
||||
** sequence is well formed, return its number of '='s + 2; otherwise,
|
||||
** return 1 if it is a single bracket (no '='s and no 2nd bracket);
|
||||
** otherwise (an unfinished '[==...') return 0.
|
||||
*/
|
||||
static size_t skip_sep (LexState *ls) {
|
||||
size_t count = 0;
|
||||
int s = ls->current;
|
||||
lua_assert(s == '[' || s == ']');
|
||||
save_and_next(ls);
|
||||
while (ls->current == '=') {
|
||||
save_and_next(ls);
|
||||
count++;
|
||||
}
|
||||
return (ls->current == s) ? count + 2
|
||||
: (count == 0) ? 1
|
||||
: 0;
|
||||
}
|
||||
|
||||
|
||||
static void read_long_string (LexState *ls, SemInfo *seminfo, size_t sep) {
|
||||
int line = ls->linenumber; /* initial line (for error message) */
|
||||
save_and_next(ls); /* skip 2nd '[' */
|
||||
if (currIsNewline(ls)) /* string starts with a newline? */
|
||||
inclinenumber(ls); /* skip it */
|
||||
for (;;) {
|
||||
switch (ls->current) {
|
||||
case EOZ: { /* error */
|
||||
const char *what = (seminfo ? "string" : "comment");
|
||||
const char *msg = luaO_pushfstring(ls->L,
|
||||
"unfinished long %s (starting at line %d)", what, line);
|
||||
lexerror(ls, msg, TK_EOS);
|
||||
break; /* to avoid warnings */
|
||||
}
|
||||
case ']': {
|
||||
if (skip_sep(ls) == sep) {
|
||||
save_and_next(ls); /* skip 2nd ']' */
|
||||
goto endloop;
|
||||
}
|
||||
break;
|
||||
}
|
||||
case '\n': case '\r': {
|
||||
save(ls, '\n');
|
||||
inclinenumber(ls);
|
||||
if (!seminfo) luaZ_resetbuffer(ls->buff); /* avoid wasting space */
|
||||
break;
|
||||
}
|
||||
default: {
|
||||
if (seminfo) save_and_next(ls);
|
||||
else next(ls);
|
||||
}
|
||||
}
|
||||
} endloop:
|
||||
if (seminfo)
|
||||
seminfo->ts = luaX_newstring(ls, luaZ_buffer(ls->buff) + sep,
|
||||
luaZ_bufflen(ls->buff) - 2 * sep);
|
||||
}
|
||||
|
||||
|
||||
static void esccheck (LexState *ls, int c, const char *msg) {
|
||||
if (!c) {
|
||||
if (ls->current != EOZ)
|
||||
save_and_next(ls); /* add current to buffer for error message */
|
||||
lexerror(ls, msg, TK_STRING);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static int gethexa (LexState *ls) {
|
||||
save_and_next(ls);
|
||||
esccheck (ls, lisxdigit(ls->current), "hexadecimal digit expected");
|
||||
return luaO_hexavalue(ls->current);
|
||||
}
|
||||
|
||||
|
||||
static int readhexaesc (LexState *ls) {
|
||||
int r = gethexa(ls);
|
||||
r = (r << 4) + gethexa(ls);
|
||||
luaZ_buffremove(ls->buff, 2); /* remove saved chars from buffer */
|
||||
return r;
|
||||
}
|
||||
|
||||
|
||||
static unsigned long readutf8esc (LexState *ls) {
|
||||
unsigned long r;
|
||||
int i = 4; /* chars to be removed: '\', 'u', '{', and first digit */
|
||||
save_and_next(ls); /* skip 'u' */
|
||||
esccheck(ls, ls->current == '{', "missing '{'");
|
||||
r = gethexa(ls); /* must have at least one digit */
|
||||
while (cast_void(save_and_next(ls)), lisxdigit(ls->current)) {
|
||||
i++;
|
||||
esccheck(ls, r <= (0x7FFFFFFFu >> 4), "UTF-8 value too large");
|
||||
r = (r << 4) + luaO_hexavalue(ls->current);
|
||||
}
|
||||
esccheck(ls, ls->current == '}', "missing '}'");
|
||||
next(ls); /* skip '}' */
|
||||
luaZ_buffremove(ls->buff, i); /* remove saved chars from buffer */
|
||||
return r;
|
||||
}
|
||||
|
||||
|
||||
static void utf8esc (LexState *ls) {
|
||||
char buff[UTF8BUFFSZ];
|
||||
int n = luaO_utf8esc(buff, readutf8esc(ls));
|
||||
for (; n > 0; n--) /* add 'buff' to string */
|
||||
save(ls, buff[UTF8BUFFSZ - n]);
|
||||
}
|
||||
|
||||
|
||||
static int readdecesc (LexState *ls) {
|
||||
int i;
|
||||
int r = 0; /* result accumulator */
|
||||
for (i = 0; i < 3 && lisdigit(ls->current); i++) { /* read up to 3 digits */
|
||||
r = 10*r + ls->current - '0';
|
||||
save_and_next(ls);
|
||||
}
|
||||
esccheck(ls, r <= UCHAR_MAX, "decimal escape too large");
|
||||
luaZ_buffremove(ls->buff, i); /* remove read digits from buffer */
|
||||
return r;
|
||||
}
|
||||
|
||||
|
||||
static void read_string (LexState *ls, int del, SemInfo *seminfo) {
|
||||
save_and_next(ls); /* keep delimiter (for error messages) */
|
||||
while (ls->current != del) {
|
||||
switch (ls->current) {
|
||||
case EOZ:
|
||||
lexerror(ls, "unfinished string", TK_EOS);
|
||||
break; /* to avoid warnings */
|
||||
case '\n':
|
||||
case '\r':
|
||||
lexerror(ls, "unfinished string", TK_STRING);
|
||||
break; /* to avoid warnings */
|
||||
case '\\': { /* escape sequences */
|
||||
int c; /* final character to be saved */
|
||||
save_and_next(ls); /* keep '\\' for error messages */
|
||||
switch (ls->current) {
|
||||
case 'a': c = '\a'; goto read_save;
|
||||
case 'b': c = '\b'; goto read_save;
|
||||
case 'f': c = '\f'; goto read_save;
|
||||
case 'n': c = '\n'; goto read_save;
|
||||
case 'r': c = '\r'; goto read_save;
|
||||
case 't': c = '\t'; goto read_save;
|
||||
case 'v': c = '\v'; goto read_save;
|
||||
case 'x': c = readhexaesc(ls); goto read_save;
|
||||
case 'u': utf8esc(ls); goto no_save;
|
||||
case '\n': case '\r':
|
||||
inclinenumber(ls); c = '\n'; goto only_save;
|
||||
case '\\': case '\"': case '\'':
|
||||
c = ls->current; goto read_save;
|
||||
case EOZ: goto no_save; /* will raise an error next loop */
|
||||
case 'z': { /* zap following span of spaces */
|
||||
luaZ_buffremove(ls->buff, 1); /* remove '\\' */
|
||||
next(ls); /* skip the 'z' */
|
||||
while (lisspace(ls->current)) {
|
||||
if (currIsNewline(ls)) inclinenumber(ls);
|
||||
else next(ls);
|
||||
}
|
||||
goto no_save;
|
||||
}
|
||||
default: {
|
||||
esccheck(ls, lisdigit(ls->current), "invalid escape sequence");
|
||||
c = readdecesc(ls); /* digital escape '\ddd' */
|
||||
goto only_save;
|
||||
}
|
||||
}
|
||||
read_save:
|
||||
next(ls);
|
||||
/* go through */
|
||||
only_save:
|
||||
luaZ_buffremove(ls->buff, 1); /* remove '\\' */
|
||||
save(ls, c);
|
||||
/* go through */
|
||||
no_save: break;
|
||||
}
|
||||
default:
|
||||
save_and_next(ls);
|
||||
}
|
||||
}
|
||||
save_and_next(ls); /* skip delimiter */
|
||||
seminfo->ts = luaX_newstring(ls, luaZ_buffer(ls->buff) + 1,
|
||||
luaZ_bufflen(ls->buff) - 2);
|
||||
}
|
||||
|
||||
|
||||
static int llex (LexState *ls, SemInfo *seminfo) {
|
||||
luaZ_resetbuffer(ls->buff);
|
||||
for (;;) {
|
||||
switch (ls->current) {
|
||||
case '\n': case '\r': { /* line breaks */
|
||||
inclinenumber(ls);
|
||||
break;
|
||||
}
|
||||
case ' ': case '\f': case '\t': case '\v': { /* spaces */
|
||||
next(ls);
|
||||
break;
|
||||
}
|
||||
case '-': { /* '-' or '--' (comment) */
|
||||
next(ls);
|
||||
if (ls->current != '-') return '-';
|
||||
/* else is a comment */
|
||||
next(ls);
|
||||
if (ls->current == '[') { /* long comment? */
|
||||
size_t sep = skip_sep(ls);
|
||||
luaZ_resetbuffer(ls->buff); /* 'skip_sep' may dirty the buffer */
|
||||
if (sep >= 2) {
|
||||
read_long_string(ls, NULL, sep); /* skip long comment */
|
||||
luaZ_resetbuffer(ls->buff); /* previous call may dirty the buff. */
|
||||
break;
|
||||
}
|
||||
}
|
||||
/* else short comment */
|
||||
while (!currIsNewline(ls) && ls->current != EOZ)
|
||||
next(ls); /* skip until end of line (or end of file) */
|
||||
break;
|
||||
}
|
||||
case '[': { /* long string or simply '[' */
|
||||
size_t sep = skip_sep(ls);
|
||||
if (sep >= 2) {
|
||||
read_long_string(ls, seminfo, sep);
|
||||
return TK_STRING;
|
||||
}
|
||||
else if (sep == 0) /* '[=...' missing second bracket? */
|
||||
lexerror(ls, "invalid long string delimiter", TK_STRING);
|
||||
return '[';
|
||||
}
|
||||
case '=': {
|
||||
next(ls);
|
||||
if (check_next1(ls, '=')) return TK_EQ; /* '==' */
|
||||
else return '=';
|
||||
}
|
||||
case '<': {
|
||||
next(ls);
|
||||
if (check_next1(ls, '=')) return TK_LE; /* '<=' */
|
||||
else if (check_next1(ls, '<')) return TK_SHL; /* '<<' */
|
||||
else return '<';
|
||||
}
|
||||
case '>': {
|
||||
next(ls);
|
||||
if (check_next1(ls, '=')) return TK_GE; /* '>=' */
|
||||
else if (check_next1(ls, '>')) return TK_SHR; /* '>>' */
|
||||
else return '>';
|
||||
}
|
||||
case '/': {
|
||||
next(ls);
|
||||
if (check_next1(ls, '/')) return TK_IDIV; /* '//' */
|
||||
else return '/';
|
||||
}
|
||||
case '~': {
|
||||
next(ls);
|
||||
if (check_next1(ls, '=')) return TK_NE; /* '~=' */
|
||||
else return '~';
|
||||
}
|
||||
case ':': {
|
||||
next(ls);
|
||||
if (check_next1(ls, ':')) return TK_DBCOLON; /* '::' */
|
||||
else return ':';
|
||||
}
|
||||
case '"': case '\'': { /* short literal strings */
|
||||
read_string(ls, ls->current, seminfo);
|
||||
return TK_STRING;
|
||||
}
|
||||
case '.': { /* '.', '..', '...', or number */
|
||||
save_and_next(ls);
|
||||
if (check_next1(ls, '.')) {
|
||||
if (check_next1(ls, '.'))
|
||||
return TK_DOTS; /* '...' */
|
||||
else return TK_CONCAT; /* '..' */
|
||||
}
|
||||
else if (!lisdigit(ls->current)) return '.';
|
||||
else return read_numeral(ls, seminfo);
|
||||
}
|
||||
case '0': case '1': case '2': case '3': case '4':
|
||||
case '5': case '6': case '7': case '8': case '9': {
|
||||
return read_numeral(ls, seminfo);
|
||||
}
|
||||
case EOZ: {
|
||||
return TK_EOS;
|
||||
}
|
||||
default: {
|
||||
if (lislalpha(ls->current)) { /* identifier or reserved word? */
|
||||
TString *ts;
|
||||
do {
|
||||
save_and_next(ls);
|
||||
} while (lislalnum(ls->current));
|
||||
ts = luaX_newstring(ls, luaZ_buffer(ls->buff),
|
||||
luaZ_bufflen(ls->buff));
|
||||
seminfo->ts = ts;
|
||||
if (isreserved(ts)) /* reserved word? */
|
||||
return ts->extra - 1 + FIRST_RESERVED;
|
||||
else {
|
||||
return TK_NAME;
|
||||
}
|
||||
}
|
||||
else { /* single-char tokens ('+', '*', '%', '{', '}', ...) */
|
||||
int c = ls->current;
|
||||
next(ls);
|
||||
return c;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void luaX_next (LexState *ls) {
|
||||
ls->lastline = ls->linenumber;
|
||||
if (ls->lookahead.token != TK_EOS) { /* is there a look-ahead token? */
|
||||
ls->t = ls->lookahead; /* use this one */
|
||||
ls->lookahead.token = TK_EOS; /* and discharge it */
|
||||
}
|
||||
else
|
||||
ls->t.token = llex(ls, &ls->t.seminfo); /* read next token */
|
||||
}
|
||||
|
||||
|
||||
int luaX_lookahead (LexState *ls) {
|
||||
lua_assert(ls->lookahead.token == TK_EOS);
|
||||
ls->lookahead.token = llex(ls, &ls->lookahead.seminfo);
|
||||
return ls->lookahead.token;
|
||||
}
|
||||
|
||||
@ -1,91 +0,0 @@
|
||||
/*
|
||||
** $Id: llex.h $
|
||||
** Lexical Analyzer
|
||||
** See Copyright Notice in lua.h
|
||||
*/
|
||||
|
||||
#ifndef llex_h
|
||||
#define llex_h
|
||||
|
||||
#include <limits.h>
|
||||
|
||||
#include "lobject.h"
|
||||
#include "lzio.h"
|
||||
|
||||
|
||||
/*
|
||||
** Single-char tokens (terminal symbols) are represented by their own
|
||||
** numeric code. Other tokens start at the following value.
|
||||
*/
|
||||
#define FIRST_RESERVED (UCHAR_MAX + 1)
|
||||
|
||||
|
||||
#if !defined(LUA_ENV)
|
||||
#define LUA_ENV "_ENV"
|
||||
#endif
|
||||
|
||||
|
||||
/*
|
||||
* WARNING: if you change the order of this enumeration,
|
||||
* grep "ORDER RESERVED"
|
||||
*/
|
||||
enum RESERVED {
|
||||
/* terminal symbols denoted by reserved words */
|
||||
TK_AND = FIRST_RESERVED, TK_BREAK,
|
||||
TK_DO, TK_ELSE, TK_ELSEIF, TK_END, TK_FALSE, TK_FOR, TK_FUNCTION,
|
||||
TK_GOTO, TK_IF, TK_IN, TK_LOCAL, TK_NIL, TK_NOT, TK_OR, TK_REPEAT,
|
||||
TK_RETURN, TK_THEN, TK_TRUE, TK_UNTIL, TK_WHILE,
|
||||
/* other terminal symbols */
|
||||
TK_IDIV, TK_CONCAT, TK_DOTS, TK_EQ, TK_GE, TK_LE, TK_NE,
|
||||
TK_SHL, TK_SHR,
|
||||
TK_DBCOLON, TK_EOS,
|
||||
TK_FLT, TK_INT, TK_NAME, TK_STRING
|
||||
};
|
||||
|
||||
/* number of reserved words */
|
||||
#define NUM_RESERVED (cast_int(TK_WHILE-FIRST_RESERVED + 1))
|
||||
|
||||
|
||||
typedef union {
|
||||
lua_Number r;
|
||||
lua_Integer i;
|
||||
TString *ts;
|
||||
} SemInfo; /* semantics information */
|
||||
|
||||
|
||||
typedef struct Token {
|
||||
int token;
|
||||
SemInfo seminfo;
|
||||
} Token;
|
||||
|
||||
|
||||
/* state of the lexer plus state of the parser when shared by all
|
||||
functions */
|
||||
typedef struct LexState {
|
||||
int current; /* current character (charint) */
|
||||
int linenumber; /* input line counter */
|
||||
int lastline; /* line of last token 'consumed' */
|
||||
Token t; /* current token */
|
||||
Token lookahead; /* look ahead token */
|
||||
struct FuncState *fs; /* current function (parser) */
|
||||
struct lua_State *L;
|
||||
ZIO *z; /* input stream */
|
||||
Mbuffer *buff; /* buffer for tokens */
|
||||
Table *h; /* to avoid collection/reuse strings */
|
||||
struct Dyndata *dyd; /* dynamic structures used by the parser */
|
||||
TString *source; /* current source name */
|
||||
TString *envn; /* environment variable name */
|
||||
} LexState;
|
||||
|
||||
|
||||
LUAI_FUNC void luaX_init (lua_State *L);
|
||||
LUAI_FUNC void luaX_setinput (lua_State *L, LexState *ls, ZIO *z,
|
||||
TString *source, int firstchar);
|
||||
LUAI_FUNC TString *luaX_newstring (LexState *ls, const char *str, size_t l);
|
||||
LUAI_FUNC void luaX_next (LexState *ls);
|
||||
LUAI_FUNC int luaX_lookahead (LexState *ls);
|
||||
LUAI_FUNC l_noret luaX_syntaxerror (LexState *ls, const char *s);
|
||||
LUAI_FUNC const char *luaX_token2str (LexState *ls, int token);
|
||||
|
||||
|
||||
#endif
|
||||
@ -1,381 +0,0 @@
|
||||
/*
|
||||
** $Id: llimits.h $
|
||||
** Limits, basic types, and some other 'installation-dependent' definitions
|
||||
** See Copyright Notice in lua.h
|
||||
*/
|
||||
|
||||
#ifndef llimits_h
|
||||
#define llimits_h
|
||||
|
||||
|
||||
#include <limits.h>
|
||||
#include <stddef.h>
|
||||
|
||||
|
||||
#include "lua.h"
|
||||
|
||||
|
||||
/*
|
||||
** 'lu_mem' and 'l_mem' are unsigned/signed integers big enough to count
|
||||
** the total memory used by Lua (in bytes). Usually, 'size_t' and
|
||||
** 'ptrdiff_t' should work, but we use 'long' for 16-bit machines.
|
||||
*/
|
||||
#if defined(LUAI_MEM) /* { external definitions? */
|
||||
typedef LUAI_UMEM lu_mem;
|
||||
typedef LUAI_MEM l_mem;
|
||||
#elif LUAI_IS32INT /* }{ */
|
||||
typedef size_t lu_mem;
|
||||
typedef ptrdiff_t l_mem;
|
||||
#else /* 16-bit ints */ /* }{ */
|
||||
typedef unsigned long lu_mem;
|
||||
typedef long l_mem;
|
||||
#endif /* } */
|
||||
|
||||
|
||||
/* chars used as small naturals (so that 'char' is reserved for characters) */
|
||||
typedef unsigned char lu_byte;
|
||||
typedef signed char ls_byte;
|
||||
|
||||
|
||||
/* maximum value for size_t */
|
||||
#define MAX_SIZET ((size_t)(~(size_t)0))
|
||||
|
||||
/* maximum size visible for Lua (must be representable in a lua_Integer) */
|
||||
#define MAX_SIZE (sizeof(size_t) < sizeof(lua_Integer) ? MAX_SIZET \
|
||||
: (size_t)(LUA_MAXINTEGER))
|
||||
|
||||
|
||||
#define MAX_LUMEM ((lu_mem)(~(lu_mem)0))
|
||||
|
||||
#define MAX_LMEM ((l_mem)(MAX_LUMEM >> 1))
|
||||
|
||||
|
||||
#define MAX_INT INT_MAX /* maximum value of an int */
|
||||
|
||||
|
||||
/*
|
||||
** floor of the log2 of the maximum signed value for integral type 't'.
|
||||
** (That is, maximum 'n' such that '2^n' fits in the given signed type.)
|
||||
*/
|
||||
#define log2maxs(t) (sizeof(t) * 8 - 2)
|
||||
|
||||
|
||||
/*
|
||||
** test whether an unsigned value is a power of 2 (or zero)
|
||||
*/
|
||||
#define ispow2(x) (((x) & ((x) - 1)) == 0)
|
||||
|
||||
|
||||
/* number of chars of a literal string without the ending \0 */
|
||||
#define LL(x) (sizeof(x)/sizeof(char) - 1)
|
||||
|
||||
|
||||
/*
|
||||
** conversion of pointer to unsigned integer: this is for hashing only;
|
||||
** there is no problem if the integer cannot hold the whole pointer
|
||||
** value. (In strict ISO C this may cause undefined behavior, but no
|
||||
** actual machine seems to bother.)
|
||||
*/
|
||||
#if !defined(LUA_USE_C89) && defined(__STDC_VERSION__) && \
|
||||
__STDC_VERSION__ >= 199901L
|
||||
#include <stdint.h>
|
||||
#if defined(UINTPTR_MAX) /* even in C99 this type is optional */
|
||||
#define L_P2I uintptr_t
|
||||
#else /* no 'intptr'? */
|
||||
#define L_P2I uintmax_t /* use the largest available integer */
|
||||
#endif
|
||||
#else /* C89 option */
|
||||
#define L_P2I size_t
|
||||
#endif
|
||||
|
||||
#define point2uint(p) ((unsigned int)((L_P2I)(p) & UINT_MAX))
|
||||
|
||||
|
||||
|
||||
/* types of 'usual argument conversions' for lua_Number and lua_Integer */
|
||||
typedef LUAI_UACNUMBER l_uacNumber;
|
||||
typedef LUAI_UACINT l_uacInt;
|
||||
|
||||
|
||||
/*
|
||||
** Internal assertions for in-house debugging
|
||||
*/
|
||||
#if defined LUAI_ASSERT
|
||||
#undef NDEBUG
|
||||
#include <assert.h>
|
||||
#define lua_assert(c) assert(c)
|
||||
#endif
|
||||
|
||||
#if defined(lua_assert)
|
||||
#define check_exp(c,e) (lua_assert(c), (e))
|
||||
/* to avoid problems with conditions too long */
|
||||
#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0))
|
||||
#else
|
||||
#define lua_assert(c) ((void)0)
|
||||
#define check_exp(c,e) (e)
|
||||
#define lua_longassert(c) ((void)0)
|
||||
#endif
|
||||
|
||||
/*
|
||||
** assertion for checking API calls
|
||||
*/
|
||||
#if !defined(luai_apicheck)
|
||||
#define luai_apicheck(l,e) ((void)l, lua_assert(e))
|
||||
#endif
|
||||
|
||||
#define api_check(l,e,msg) luai_apicheck(l,(e) && msg)
|
||||
|
||||
|
||||
/* macro to avoid warnings about unused variables */
|
||||
#if !defined(UNUSED)
|
||||
#define UNUSED(x) ((void)(x))
|
||||
#endif
|
||||
|
||||
|
||||
/* type casts (a macro highlights casts in the code) */
|
||||
#define cast(t, exp) ((t)(exp))
|
||||
#define castp(t, exp) ((t)(void *)(exp))
|
||||
|
||||
#define cast_void(i) cast(void, (i))
|
||||
#define cast_voidp(i) cast(void *, (i))
|
||||
#define cast_num(i) cast(lua_Number, (i))
|
||||
#define cast_int(i) cast(int, (i))
|
||||
#define cast_uint(i) cast(unsigned int, (i))
|
||||
#define cast_byte(i) cast(lu_byte, (i))
|
||||
#define cast_uchar(i) cast(unsigned char, (i))
|
||||
#define cast_char(i) cast(char, (i))
|
||||
#define cast_charp(i) castp(char *, (i))
|
||||
#define cast_sizet(i) cast(size_t, (i))
|
||||
|
||||
|
||||
/* cast a signed lua_Integer to lua_Unsigned */
|
||||
#if !defined(l_castS2U)
|
||||
#define l_castS2U(i) ((lua_Unsigned)(i))
|
||||
#endif
|
||||
|
||||
/*
|
||||
** cast a lua_Unsigned to a signed lua_Integer; this cast is
|
||||
** not strict ISO C, but two-complement architectures should
|
||||
** work fine.
|
||||
*/
|
||||
#if !defined(l_castU2S)
|
||||
#define l_castU2S(i) ((lua_Integer)(i))
|
||||
#endif
|
||||
|
||||
|
||||
/*
|
||||
** non-return type
|
||||
*/
|
||||
#if !defined(l_noret)
|
||||
|
||||
#if defined(__GNUC__)
|
||||
#define l_noret void __attribute__((noreturn))
|
||||
#elif defined(_MSC_VER) && _MSC_VER >= 1200
|
||||
#define l_noret void __declspec(noreturn)
|
||||
#else
|
||||
#define l_noret void
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
/*
|
||||
** Inline functions
|
||||
*/
|
||||
#if !defined(LUA_USE_C89)
|
||||
#define l_inline inline
|
||||
#elif defined(__GNUC__)
|
||||
#define l_inline __inline__
|
||||
#else
|
||||
#define l_inline /* empty */
|
||||
#endif
|
||||
|
||||
#define l_sinline static l_inline
|
||||
|
||||
|
||||
/*
|
||||
** type for virtual-machine instructions;
|
||||
** must be an unsigned with (at least) 4 bytes (see details in lopcodes.h)
|
||||
*/
|
||||
#if LUAI_IS32INT
|
||||
typedef unsigned int l_uint32;
|
||||
#else
|
||||
typedef unsigned long l_uint32;
|
||||
#endif
|
||||
|
||||
typedef l_uint32 Instruction;
|
||||
|
||||
|
||||
|
||||
/*
|
||||
** Maximum length for short strings, that is, strings that are
|
||||
** internalized. (Cannot be smaller than reserved words or tags for
|
||||
** metamethods, as these strings must be internalized;
|
||||
** #("function") = 8, #("__newindex") = 10.)
|
||||
*/
|
||||
#if !defined(LUAI_MAXSHORTLEN)
|
||||
#define LUAI_MAXSHORTLEN 40
|
||||
#endif
|
||||
|
||||
|
||||
/*
|
||||
** Initial size for the string table (must be power of 2).
|
||||
** The Lua core alone registers ~50 strings (reserved words +
|
||||
** metaevent keys + a few others). Libraries would typically add
|
||||
** a few dozens more.
|
||||
*/
|
||||
#if !defined(MINSTRTABSIZE)
|
||||
#define MINSTRTABSIZE 128
|
||||
#endif
|
||||
|
||||
|
||||
/*
|
||||
** Size of cache for strings in the API. 'N' is the number of
|
||||
** sets (better be a prime) and "M" is the size of each set (M == 1
|
||||
** makes a direct cache.)
|
||||
*/
|
||||
#if !defined(STRCACHE_N)
|
||||
#define STRCACHE_N 53
|
||||
#define STRCACHE_M 2
|
||||
#endif
|
||||
|
||||
|
||||
/* minimum size for string buffer */
|
||||
#if !defined(LUA_MINBUFFER)
|
||||
#define LUA_MINBUFFER 32
|
||||
#endif
|
||||
|
||||
|
||||
/*
|
||||
** Maximum depth for nested C calls, syntactical nested non-terminals,
|
||||
** and other features implemented through recursion in C. (Value must
|
||||
** fit in a 16-bit unsigned integer. It must also be compatible with
|
||||
** the size of the C stack.)
|
||||
*/
|
||||
#if !defined(LUAI_MAXCCALLS)
|
||||
#define LUAI_MAXCCALLS 200
|
||||
#endif
|
||||
|
||||
|
||||
/*
|
||||
** macros that are executed whenever program enters the Lua core
|
||||
** ('lua_lock') and leaves the core ('lua_unlock')
|
||||
*/
|
||||
#if !defined(lua_lock)
|
||||
#define lua_lock(L) ((void) 0)
|
||||
#define lua_unlock(L) ((void) 0)
|
||||
#endif
|
||||
|
||||
/*
|
||||
** macro executed during Lua functions at points where the
|
||||
** function can yield.
|
||||
*/
|
||||
#if !defined(luai_threadyield)
|
||||
#define luai_threadyield(L) {lua_unlock(L); lua_lock(L);}
|
||||
#endif
|
||||
|
||||
|
||||
/*
|
||||
** these macros allow user-specific actions when a thread is
|
||||
** created/deleted/resumed/yielded.
|
||||
*/
|
||||
#if !defined(luai_userstateopen)
|
||||
#define luai_userstateopen(L) ((void)L)
|
||||
#endif
|
||||
|
||||
#if !defined(luai_userstateclose)
|
||||
#define luai_userstateclose(L) ((void)L)
|
||||
#endif
|
||||
|
||||
#if !defined(luai_userstatethread)
|
||||
#define luai_userstatethread(L,L1) ((void)L)
|
||||
#endif
|
||||
|
||||
#if !defined(luai_userstatefree)
|
||||
#define luai_userstatefree(L,L1) ((void)L)
|
||||
#endif
|
||||
|
||||
#if !defined(luai_userstateresume)
|
||||
#define luai_userstateresume(L,n) ((void)L)
|
||||
#endif
|
||||
|
||||
#if !defined(luai_userstateyield)
|
||||
#define luai_userstateyield(L,n) ((void)L)
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
/*
|
||||
** The luai_num* macros define the primitive operations over numbers.
|
||||
*/
|
||||
|
||||
/* floor division (defined as 'floor(a/b)') */
|
||||
#if !defined(luai_numidiv)
|
||||
#define luai_numidiv(L,a,b) ((void)L, l_floor(luai_numdiv(L,a,b)))
|
||||
#endif
|
||||
|
||||
/* float division */
|
||||
#if !defined(luai_numdiv)
|
||||
#define luai_numdiv(L,a,b) ((a)/(b))
|
||||
#endif
|
||||
|
||||
/*
|
||||
** modulo: defined as 'a - floor(a/b)*b'; the direct computation
|
||||
** using this definition has several problems with rounding errors,
|
||||
** so it is better to use 'fmod'. 'fmod' gives the result of
|
||||
** 'a - trunc(a/b)*b', and therefore must be corrected when
|
||||
** 'trunc(a/b) ~= floor(a/b)'. That happens when the division has a
|
||||
** non-integer negative result: non-integer result is equivalent to
|
||||
** a non-zero remainder 'm'; negative result is equivalent to 'a' and
|
||||
** 'b' with different signs, or 'm' and 'b' with different signs
|
||||
** (as the result 'm' of 'fmod' has the same sign of 'a').
|
||||
*/
|
||||
#if !defined(luai_nummod)
|
||||
#define luai_nummod(L,a,b,m) \
|
||||
{ (void)L; (m) = l_mathop(fmod)(a,b); \
|
||||
if (((m) > 0) ? (b) < 0 : ((m) < 0 && (b) > 0)) (m) += (b); }
|
||||
#endif
|
||||
|
||||
/* exponentiation */
|
||||
#if !defined(luai_numpow)
|
||||
#define luai_numpow(L,a,b) \
|
||||
((void)L, (b == 2) ? (a)*(a) : l_mathop(pow)(a,b))
|
||||
#endif
|
||||
|
||||
/* the others are quite standard operations */
|
||||
#if !defined(luai_numadd)
|
||||
#define luai_numadd(L,a,b) ((a)+(b))
|
||||
#define luai_numsub(L,a,b) ((a)-(b))
|
||||
#define luai_nummul(L,a,b) ((a)*(b))
|
||||
#define luai_numunm(L,a) (-(a))
|
||||
#define luai_numeq(a,b) ((a)==(b))
|
||||
#define luai_numlt(a,b) ((a)<(b))
|
||||
#define luai_numle(a,b) ((a)<=(b))
|
||||
#define luai_numgt(a,b) ((a)>(b))
|
||||
#define luai_numge(a,b) ((a)>=(b))
|
||||
#define luai_numisnan(a) (!luai_numeq((a), (a)))
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
/*
|
||||
** macro to control inclusion of some hard tests on stack reallocation
|
||||
*/
|
||||
#if !defined(HARDSTACKTESTS)
|
||||
#define condmovestack(L,pre,pos) ((void)0)
|
||||
#else
|
||||
/* realloc stack keeping its size */
|
||||
#define condmovestack(L,pre,pos) \
|
||||
{ int sz_ = stacksize(L); pre; luaD_reallocstack((L), sz_, 0); pos; }
|
||||
#endif
|
||||
|
||||
#if !defined(HARDMEMTESTS)
|
||||
#define condchangemem(L,pre,pos) ((void)0)
|
||||
#else
|
||||
#define condchangemem(L,pre,pos) \
|
||||
{ if (gcrunning(G(L))) { pre; luaC_fullgc(L, 0); pos; } }
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@ -1,781 +0,0 @@
|
||||
/*
|
||||
** $Id: lmathlib.c $
|
||||
** Standard mathematical library
|
||||
** See Copyright Notice in lua.h
|
||||
*/
|
||||
|
||||
#define lmathlib_c
|
||||
#define LUA_LIB
|
||||
|
||||
#include "lprefix.h"
|
||||
|
||||
|
||||
#include <float.h>
|
||||
#include <limits.h>
|
||||
#include <math.h>
|
||||
#include <stdlib.h>
|
||||
#include <time.h>
|
||||
|
||||
#include "lua.h"
|
||||
|
||||
#include "lauxlib.h"
|
||||
#include "lualib.h"
|
||||
|
||||
|
||||
#undef PI
|
||||
#define PI (l_mathop(3.141592653589793238462643383279502884))
|
||||
|
||||
|
||||
static int math_abs (lua_State *L) {
|
||||
if (lua_isinteger(L, 1)) {
|
||||
lua_Integer n = lua_tointeger(L, 1);
|
||||
if (n < 0) n = (lua_Integer)(0u - (lua_Unsigned)n);
|
||||
lua_pushinteger(L, n);
|
||||
}
|
||||
else
|
||||
lua_pushnumber(L, l_mathop(fabs)(luaL_checknumber(L, 1)));
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int math_sin (lua_State *L) {
|
||||
lua_pushnumber(L, l_mathop(sin)(luaL_checknumber(L, 1)));
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int math_cos (lua_State *L) {
|
||||
lua_pushnumber(L, l_mathop(cos)(luaL_checknumber(L, 1)));
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int math_tan (lua_State *L) {
|
||||
lua_pushnumber(L, l_mathop(tan)(luaL_checknumber(L, 1)));
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int math_asin (lua_State *L) {
|
||||
lua_pushnumber(L, l_mathop(asin)(luaL_checknumber(L, 1)));
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int math_acos (lua_State *L) {
|
||||
lua_pushnumber(L, l_mathop(acos)(luaL_checknumber(L, 1)));
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int math_atan (lua_State *L) {
|
||||
lua_Number y = luaL_checknumber(L, 1);
|
||||
lua_Number x = luaL_optnumber(L, 2, 1);
|
||||
lua_pushnumber(L, l_mathop(atan2)(y, x));
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
static int math_toint (lua_State *L) {
|
||||
int valid;
|
||||
lua_Integer n = lua_tointegerx(L, 1, &valid);
|
||||
if (l_likely(valid))
|
||||
lua_pushinteger(L, n);
|
||||
else {
|
||||
luaL_checkany(L, 1);
|
||||
luaL_pushfail(L); /* value is not convertible to integer */
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
static void pushnumint (lua_State *L, lua_Number d) {
|
||||
lua_Integer n;
|
||||
if (lua_numbertointeger(d, &n)) /* does 'd' fit in an integer? */
|
||||
lua_pushinteger(L, n); /* result is integer */
|
||||
else
|
||||
lua_pushnumber(L, d); /* result is float */
|
||||
}
|
||||
|
||||
|
||||
static int math_floor (lua_State *L) {
|
||||
if (lua_isinteger(L, 1))
|
||||
lua_settop(L, 1); /* integer is its own floor */
|
||||
else {
|
||||
lua_Number d = l_mathop(floor)(luaL_checknumber(L, 1));
|
||||
pushnumint(L, d);
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
static int math_ceil (lua_State *L) {
|
||||
if (lua_isinteger(L, 1))
|
||||
lua_settop(L, 1); /* integer is its own ceil */
|
||||
else {
|
||||
lua_Number d = l_mathop(ceil)(luaL_checknumber(L, 1));
|
||||
pushnumint(L, d);
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
static int math_fmod (lua_State *L) {
|
||||
if (lua_isinteger(L, 1) && lua_isinteger(L, 2)) {
|
||||
lua_Integer d = lua_tointeger(L, 2);
|
||||
if ((lua_Unsigned)d + 1u <= 1u) { /* special cases: -1 or 0 */
|
||||
luaL_argcheck(L, d != 0, 2, "zero");
|
||||
lua_pushinteger(L, 0); /* avoid overflow with 0x80000... / -1 */
|
||||
}
|
||||
else
|
||||
lua_pushinteger(L, lua_tointeger(L, 1) % d);
|
||||
}
|
||||
else
|
||||
lua_pushnumber(L, l_mathop(fmod)(luaL_checknumber(L, 1),
|
||||
luaL_checknumber(L, 2)));
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** next function does not use 'modf', avoiding problems with 'double*'
|
||||
** (which is not compatible with 'float*') when lua_Number is not
|
||||
** 'double'.
|
||||
*/
|
||||
static int math_modf (lua_State *L) {
|
||||
if (lua_isinteger(L ,1)) {
|
||||
lua_settop(L, 1); /* number is its own integer part */
|
||||
lua_pushnumber(L, 0); /* no fractional part */
|
||||
}
|
||||
else {
|
||||
lua_Number n = luaL_checknumber(L, 1);
|
||||
/* integer part (rounds toward zero) */
|
||||
lua_Number ip = (n < 0) ? l_mathop(ceil)(n) : l_mathop(floor)(n);
|
||||
pushnumint(L, ip);
|
||||
/* fractional part (test needed for inf/-inf) */
|
||||
lua_pushnumber(L, (n == ip) ? l_mathop(0.0) : (n - ip));
|
||||
}
|
||||
return 2;
|
||||
}
|
||||
|
||||
|
||||
static int math_sqrt (lua_State *L) {
|
||||
lua_pushnumber(L, l_mathop(sqrt)(luaL_checknumber(L, 1)));
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
static int math_ult (lua_State *L) {
|
||||
lua_Integer a = luaL_checkinteger(L, 1);
|
||||
lua_Integer b = luaL_checkinteger(L, 2);
|
||||
lua_pushboolean(L, (lua_Unsigned)a < (lua_Unsigned)b);
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int math_log (lua_State *L) {
|
||||
lua_Number x = luaL_checknumber(L, 1);
|
||||
lua_Number res;
|
||||
if (lua_isnoneornil(L, 2))
|
||||
res = l_mathop(log)(x);
|
||||
else {
|
||||
lua_Number base = luaL_checknumber(L, 2);
|
||||
#if !defined(LUA_USE_C89)
|
||||
if (base == l_mathop(2.0))
|
||||
res = l_mathop(log2)(x);
|
||||
else
|
||||
#endif
|
||||
if (base == l_mathop(10.0))
|
||||
res = l_mathop(log10)(x);
|
||||
else
|
||||
res = l_mathop(log)(x)/l_mathop(log)(base);
|
||||
}
|
||||
lua_pushnumber(L, res);
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int math_exp (lua_State *L) {
|
||||
lua_pushnumber(L, l_mathop(exp)(luaL_checknumber(L, 1)));
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int math_deg (lua_State *L) {
|
||||
lua_pushnumber(L, luaL_checknumber(L, 1) * (l_mathop(180.0) / PI));
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int math_rad (lua_State *L) {
|
||||
lua_pushnumber(L, luaL_checknumber(L, 1) * (PI / l_mathop(180.0)));
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
static int math_min (lua_State *L) {
|
||||
int n = lua_gettop(L); /* number of arguments */
|
||||
int imin = 1; /* index of current minimum value */
|
||||
int i;
|
||||
luaL_argcheck(L, n >= 1, 1, "value expected");
|
||||
for (i = 2; i <= n; i++) {
|
||||
if (lua_compare(L, i, imin, LUA_OPLT))
|
||||
imin = i;
|
||||
}
|
||||
lua_pushvalue(L, imin);
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
static int math_max (lua_State *L) {
|
||||
int n = lua_gettop(L); /* number of arguments */
|
||||
int imax = 1; /* index of current maximum value */
|
||||
int i;
|
||||
luaL_argcheck(L, n >= 1, 1, "value expected");
|
||||
for (i = 2; i <= n; i++) {
|
||||
if (lua_compare(L, imax, i, LUA_OPLT))
|
||||
imax = i;
|
||||
}
|
||||
lua_pushvalue(L, imax);
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
static int math_type (lua_State *L) {
|
||||
if (lua_type(L, 1) == LUA_TNUMBER)
|
||||
lua_pushstring(L, (lua_isinteger(L, 1)) ? "integer" : "float");
|
||||
else {
|
||||
luaL_checkany(L, 1);
|
||||
luaL_pushfail(L);
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*
|
||||
** {==================================================================
|
||||
** Pseudo-Random Number Generator based on 'xoshiro256**'.
|
||||
** ===================================================================
|
||||
*/
|
||||
|
||||
/*
|
||||
** This code uses lots of shifts. ANSI C does not allow shifts greater
|
||||
** than or equal to the width of the type being shifted, so some shifts
|
||||
** are written in convoluted ways to match that restriction. For
|
||||
** preprocessor tests, it assumes a width of 32 bits, so the maximum
|
||||
** shift there is 31 bits.
|
||||
*/
|
||||
|
||||
|
||||
/* number of binary digits in the mantissa of a float */
|
||||
#define FIGS l_floatatt(MANT_DIG)
|
||||
|
||||
#if FIGS > 64
|
||||
/* there are only 64 random bits; use them all */
|
||||
#undef FIGS
|
||||
#define FIGS 64
|
||||
#endif
|
||||
|
||||
|
||||
/*
|
||||
** LUA_RAND32 forces the use of 32-bit integers in the implementation
|
||||
** of the PRN generator (mainly for testing).
|
||||
*/
|
||||
#if !defined(LUA_RAND32) && !defined(Rand64)
|
||||
|
||||
/* try to find an integer type with at least 64 bits */
|
||||
|
||||
#if ((ULONG_MAX >> 31) >> 31) >= 3
|
||||
|
||||
/* 'long' has at least 64 bits */
|
||||
#define Rand64 unsigned long
|
||||
#define SRand64 long
|
||||
|
||||
#elif !defined(LUA_USE_C89) && defined(LLONG_MAX)
|
||||
|
||||
/* there is a 'long long' type (which must have at least 64 bits) */
|
||||
#define Rand64 unsigned long long
|
||||
#define SRand64 long long
|
||||
|
||||
#elif ((LUA_MAXUNSIGNED >> 31) >> 31) >= 3
|
||||
|
||||
/* 'lua_Unsigned' has at least 64 bits */
|
||||
#define Rand64 lua_Unsigned
|
||||
#define SRand64 lua_Integer
|
||||
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
#if defined(Rand64) /* { */
|
||||
|
||||
/*
|
||||
** Standard implementation, using 64-bit integers.
|
||||
** If 'Rand64' has more than 64 bits, the extra bits do not interfere
|
||||
** with the 64 initial bits, except in a right shift. Moreover, the
|
||||
** final result has to discard the extra bits.
|
||||
*/
|
||||
|
||||
/* avoid using extra bits when needed */
|
||||
#define trim64(x) ((x) & 0xffffffffffffffffu)
|
||||
|
||||
|
||||
/* rotate left 'x' by 'n' bits */
|
||||
static Rand64 rotl (Rand64 x, int n) {
|
||||
return (x << n) | (trim64(x) >> (64 - n));
|
||||
}
|
||||
|
||||
static Rand64 nextrand (Rand64 *state) {
|
||||
Rand64 state0 = state[0];
|
||||
Rand64 state1 = state[1];
|
||||
Rand64 state2 = state[2] ^ state0;
|
||||
Rand64 state3 = state[3] ^ state1;
|
||||
Rand64 res = rotl(state1 * 5, 7) * 9;
|
||||
state[0] = state0 ^ state3;
|
||||
state[1] = state1 ^ state2;
|
||||
state[2] = state2 ^ (state1 << 17);
|
||||
state[3] = rotl(state3, 45);
|
||||
return res;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Convert bits from a random integer into a float in the
|
||||
** interval [0,1), getting the higher FIG bits from the
|
||||
** random unsigned integer and converting that to a float.
|
||||
** Some old Microsoft compilers cannot cast an unsigned long
|
||||
** to a floating-point number, so we use a signed long as an
|
||||
** intermediary. When lua_Number is float or double, the shift ensures
|
||||
** that 'sx' is non negative; in that case, a good compiler will remove
|
||||
** the correction.
|
||||
*/
|
||||
|
||||
/* must throw out the extra (64 - FIGS) bits */
|
||||
#define shift64_FIG (64 - FIGS)
|
||||
|
||||
/* 2^(-FIGS) == 2^-1 / 2^(FIGS-1) */
|
||||
#define scaleFIG (l_mathop(0.5) / ((Rand64)1 << (FIGS - 1)))
|
||||
|
||||
static lua_Number I2d (Rand64 x) {
|
||||
SRand64 sx = (SRand64)(trim64(x) >> shift64_FIG);
|
||||
lua_Number res = (lua_Number)(sx) * scaleFIG;
|
||||
if (sx < 0)
|
||||
res += l_mathop(1.0); /* correct the two's complement if negative */
|
||||
lua_assert(0 <= res && res < 1);
|
||||
return res;
|
||||
}
|
||||
|
||||
/* convert a 'Rand64' to a 'lua_Unsigned' */
|
||||
#define I2UInt(x) ((lua_Unsigned)trim64(x))
|
||||
|
||||
/* convert a 'lua_Unsigned' to a 'Rand64' */
|
||||
#define Int2I(x) ((Rand64)(x))
|
||||
|
||||
|
||||
#else /* no 'Rand64' }{ */
|
||||
|
||||
/* get an integer with at least 32 bits */
|
||||
#if LUAI_IS32INT
|
||||
typedef unsigned int lu_int32;
|
||||
#else
|
||||
typedef unsigned long lu_int32;
|
||||
#endif
|
||||
|
||||
|
||||
/*
|
||||
** Use two 32-bit integers to represent a 64-bit quantity.
|
||||
*/
|
||||
typedef struct Rand64 {
|
||||
lu_int32 h; /* higher half */
|
||||
lu_int32 l; /* lower half */
|
||||
} Rand64;
|
||||
|
||||
|
||||
/*
|
||||
** If 'lu_int32' has more than 32 bits, the extra bits do not interfere
|
||||
** with the 32 initial bits, except in a right shift and comparisons.
|
||||
** Moreover, the final result has to discard the extra bits.
|
||||
*/
|
||||
|
||||
/* avoid using extra bits when needed */
|
||||
#define trim32(x) ((x) & 0xffffffffu)
|
||||
|
||||
|
||||
/*
|
||||
** basic operations on 'Rand64' values
|
||||
*/
|
||||
|
||||
/* build a new Rand64 value */
|
||||
static Rand64 packI (lu_int32 h, lu_int32 l) {
|
||||
Rand64 result;
|
||||
result.h = h;
|
||||
result.l = l;
|
||||
return result;
|
||||
}
|
||||
|
||||
/* return i << n */
|
||||
static Rand64 Ishl (Rand64 i, int n) {
|
||||
lua_assert(n > 0 && n < 32);
|
||||
return packI((i.h << n) | (trim32(i.l) >> (32 - n)), i.l << n);
|
||||
}
|
||||
|
||||
/* i1 ^= i2 */
|
||||
static void Ixor (Rand64 *i1, Rand64 i2) {
|
||||
i1->h ^= i2.h;
|
||||
i1->l ^= i2.l;
|
||||
}
|
||||
|
||||
/* return i1 + i2 */
|
||||
static Rand64 Iadd (Rand64 i1, Rand64 i2) {
|
||||
Rand64 result = packI(i1.h + i2.h, i1.l + i2.l);
|
||||
if (trim32(result.l) < trim32(i1.l)) /* carry? */
|
||||
result.h++;
|
||||
return result;
|
||||
}
|
||||
|
||||
/* return i * 5 */
|
||||
static Rand64 times5 (Rand64 i) {
|
||||
return Iadd(Ishl(i, 2), i); /* i * 5 == (i << 2) + i */
|
||||
}
|
||||
|
||||
/* return i * 9 */
|
||||
static Rand64 times9 (Rand64 i) {
|
||||
return Iadd(Ishl(i, 3), i); /* i * 9 == (i << 3) + i */
|
||||
}
|
||||
|
||||
/* return 'i' rotated left 'n' bits */
|
||||
static Rand64 rotl (Rand64 i, int n) {
|
||||
lua_assert(n > 0 && n < 32);
|
||||
return packI((i.h << n) | (trim32(i.l) >> (32 - n)),
|
||||
(trim32(i.h) >> (32 - n)) | (i.l << n));
|
||||
}
|
||||
|
||||
/* for offsets larger than 32, rotate right by 64 - offset */
|
||||
static Rand64 rotl1 (Rand64 i, int n) {
|
||||
lua_assert(n > 32 && n < 64);
|
||||
n = 64 - n;
|
||||
return packI((trim32(i.h) >> n) | (i.l << (32 - n)),
|
||||
(i.h << (32 - n)) | (trim32(i.l) >> n));
|
||||
}
|
||||
|
||||
/*
|
||||
** implementation of 'xoshiro256**' algorithm on 'Rand64' values
|
||||
*/
|
||||
static Rand64 nextrand (Rand64 *state) {
|
||||
Rand64 res = times9(rotl(times5(state[1]), 7));
|
||||
Rand64 t = Ishl(state[1], 17);
|
||||
Ixor(&state[2], state[0]);
|
||||
Ixor(&state[3], state[1]);
|
||||
Ixor(&state[1], state[2]);
|
||||
Ixor(&state[0], state[3]);
|
||||
Ixor(&state[2], t);
|
||||
state[3] = rotl1(state[3], 45);
|
||||
return res;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Converts a 'Rand64' into a float.
|
||||
*/
|
||||
|
||||
/* an unsigned 1 with proper type */
|
||||
#define UONE ((lu_int32)1)
|
||||
|
||||
|
||||
#if FIGS <= 32
|
||||
|
||||
/* 2^(-FIGS) */
|
||||
#define scaleFIG (l_mathop(0.5) / (UONE << (FIGS - 1)))
|
||||
|
||||
/*
|
||||
** get up to 32 bits from higher half, shifting right to
|
||||
** throw out the extra bits.
|
||||
*/
|
||||
static lua_Number I2d (Rand64 x) {
|
||||
lua_Number h = (lua_Number)(trim32(x.h) >> (32 - FIGS));
|
||||
return h * scaleFIG;
|
||||
}
|
||||
|
||||
#else /* 32 < FIGS <= 64 */
|
||||
|
||||
/* 2^(-FIGS) = 1.0 / 2^30 / 2^3 / 2^(FIGS-33) */
|
||||
#define scaleFIG \
|
||||
(l_mathop(1.0) / (UONE << 30) / l_mathop(8.0) / (UONE << (FIGS - 33)))
|
||||
|
||||
/*
|
||||
** use FIGS - 32 bits from lower half, throwing out the other
|
||||
** (32 - (FIGS - 32)) = (64 - FIGS) bits
|
||||
*/
|
||||
#define shiftLOW (64 - FIGS)
|
||||
|
||||
/*
|
||||
** higher 32 bits go after those (FIGS - 32) bits: shiftHI = 2^(FIGS - 32)
|
||||
*/
|
||||
#define shiftHI ((lua_Number)(UONE << (FIGS - 33)) * l_mathop(2.0))
|
||||
|
||||
|
||||
static lua_Number I2d (Rand64 x) {
|
||||
lua_Number h = (lua_Number)trim32(x.h) * shiftHI;
|
||||
lua_Number l = (lua_Number)(trim32(x.l) >> shiftLOW);
|
||||
return (h + l) * scaleFIG;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
/* convert a 'Rand64' to a 'lua_Unsigned' */
|
||||
static lua_Unsigned I2UInt (Rand64 x) {
|
||||
return (((lua_Unsigned)trim32(x.h) << 31) << 1) | (lua_Unsigned)trim32(x.l);
|
||||
}
|
||||
|
||||
/* convert a 'lua_Unsigned' to a 'Rand64' */
|
||||
static Rand64 Int2I (lua_Unsigned n) {
|
||||
return packI((lu_int32)((n >> 31) >> 1), (lu_int32)n);
|
||||
}
|
||||
|
||||
#endif /* } */
|
||||
|
||||
|
||||
/*
|
||||
** A state uses four 'Rand64' values.
|
||||
*/
|
||||
typedef struct {
|
||||
Rand64 s[4];
|
||||
} RanState;
|
||||
|
||||
|
||||
/*
|
||||
** Project the random integer 'ran' into the interval [0, n].
|
||||
** Because 'ran' has 2^B possible values, the projection can only be
|
||||
** uniform when the size of the interval is a power of 2 (exact
|
||||
** division). Otherwise, to get a uniform projection into [0, n], we
|
||||
** first compute 'lim', the smallest Mersenne number not smaller than
|
||||
** 'n'. We then project 'ran' into the interval [0, lim]. If the result
|
||||
** is inside [0, n], we are done. Otherwise, we try with another 'ran',
|
||||
** until we have a result inside the interval.
|
||||
*/
|
||||
static lua_Unsigned project (lua_Unsigned ran, lua_Unsigned n,
|
||||
RanState *state) {
|
||||
if ((n & (n + 1)) == 0) /* is 'n + 1' a power of 2? */
|
||||
return ran & n; /* no bias */
|
||||
else {
|
||||
lua_Unsigned lim = n;
|
||||
/* compute the smallest (2^b - 1) not smaller than 'n' */
|
||||
lim |= (lim >> 1);
|
||||
lim |= (lim >> 2);
|
||||
lim |= (lim >> 4);
|
||||
lim |= (lim >> 8);
|
||||
lim |= (lim >> 16);
|
||||
#if (LUA_MAXUNSIGNED >> 31) >= 3
|
||||
lim |= (lim >> 32); /* integer type has more than 32 bits */
|
||||
#endif
|
||||
lua_assert((lim & (lim + 1)) == 0 /* 'lim + 1' is a power of 2, */
|
||||
&& lim >= n /* not smaller than 'n', */
|
||||
&& (lim >> 1) < n); /* and it is the smallest one */
|
||||
while ((ran &= lim) > n) /* project 'ran' into [0..lim] */
|
||||
ran = I2UInt(nextrand(state->s)); /* not inside [0..n]? try again */
|
||||
return ran;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static int math_random (lua_State *L) {
|
||||
lua_Integer low, up;
|
||||
lua_Unsigned p;
|
||||
RanState *state = (RanState *)lua_touserdata(L, lua_upvalueindex(1));
|
||||
Rand64 rv = nextrand(state->s); /* next pseudo-random value */
|
||||
switch (lua_gettop(L)) { /* check number of arguments */
|
||||
case 0: { /* no arguments */
|
||||
lua_pushnumber(L, I2d(rv)); /* float between 0 and 1 */
|
||||
return 1;
|
||||
}
|
||||
case 1: { /* only upper limit */
|
||||
low = 1;
|
||||
up = luaL_checkinteger(L, 1);
|
||||
if (up == 0) { /* single 0 as argument? */
|
||||
lua_pushinteger(L, I2UInt(rv)); /* full random integer */
|
||||
return 1;
|
||||
}
|
||||
break;
|
||||
}
|
||||
case 2: { /* lower and upper limits */
|
||||
low = luaL_checkinteger(L, 1);
|
||||
up = luaL_checkinteger(L, 2);
|
||||
break;
|
||||
}
|
||||
default: return luaL_error(L, "wrong number of arguments");
|
||||
}
|
||||
/* random integer in the interval [low, up] */
|
||||
luaL_argcheck(L, low <= up, 1, "interval is empty");
|
||||
/* project random integer into the interval [0, up - low] */
|
||||
p = project(I2UInt(rv), (lua_Unsigned)up - (lua_Unsigned)low, state);
|
||||
lua_pushinteger(L, p + (lua_Unsigned)low);
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
static void setseed (lua_State *L, Rand64 *state,
|
||||
lua_Unsigned n1, lua_Unsigned n2) {
|
||||
int i;
|
||||
state[0] = Int2I(n1);
|
||||
state[1] = Int2I(0xff); /* avoid a zero state */
|
||||
state[2] = Int2I(n2);
|
||||
state[3] = Int2I(0);
|
||||
for (i = 0; i < 16; i++)
|
||||
nextrand(state); /* discard initial values to "spread" seed */
|
||||
lua_pushinteger(L, n1);
|
||||
lua_pushinteger(L, n2);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Set a "random" seed. To get some randomness, use the current time
|
||||
** and the address of 'L' (in case the machine does address space layout
|
||||
** randomization).
|
||||
*/
|
||||
static void randseed (lua_State *L, RanState *state) {
|
||||
lua_Unsigned seed1 = (lua_Unsigned)time(NULL);
|
||||
lua_Unsigned seed2 = (lua_Unsigned)(size_t)L;
|
||||
setseed(L, state->s, seed1, seed2);
|
||||
}
|
||||
|
||||
|
||||
static int math_randomseed (lua_State *L) {
|
||||
RanState *state = (RanState *)lua_touserdata(L, lua_upvalueindex(1));
|
||||
if (lua_isnone(L, 1)) {
|
||||
randseed(L, state);
|
||||
}
|
||||
else {
|
||||
lua_Integer n1 = luaL_checkinteger(L, 1);
|
||||
lua_Integer n2 = luaL_optinteger(L, 2, 0);
|
||||
setseed(L, state->s, n1, n2);
|
||||
}
|
||||
return 2; /* return seeds */
|
||||
}
|
||||
|
||||
|
||||
static const luaL_Reg randfuncs[] = {
|
||||
{"random", math_random},
|
||||
{"randomseed", math_randomseed},
|
||||
{NULL, NULL}
|
||||
};
|
||||
|
||||
|
||||
/*
|
||||
** Register the random functions and initialize their state.
|
||||
*/
|
||||
static void setrandfunc (lua_State *L) {
|
||||
RanState *state = (RanState *)lua_newuserdatauv(L, sizeof(RanState), 0);
|
||||
randseed(L, state); /* initialize with a "random" seed */
|
||||
lua_pop(L, 2); /* remove pushed seeds */
|
||||
luaL_setfuncs(L, randfuncs, 1);
|
||||
}
|
||||
|
||||
/* }================================================================== */
|
||||
|
||||
|
||||
/*
|
||||
** {==================================================================
|
||||
** Deprecated functions (for compatibility only)
|
||||
** ===================================================================
|
||||
*/
|
||||
#if defined(LUA_COMPAT_MATHLIB)
|
||||
|
||||
static int math_cosh (lua_State *L) {
|
||||
lua_pushnumber(L, l_mathop(cosh)(luaL_checknumber(L, 1)));
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int math_sinh (lua_State *L) {
|
||||
lua_pushnumber(L, l_mathop(sinh)(luaL_checknumber(L, 1)));
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int math_tanh (lua_State *L) {
|
||||
lua_pushnumber(L, l_mathop(tanh)(luaL_checknumber(L, 1)));
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int math_pow (lua_State *L) {
|
||||
lua_Number x = luaL_checknumber(L, 1);
|
||||
lua_Number y = luaL_checknumber(L, 2);
|
||||
lua_pushnumber(L, l_mathop(pow)(x, y));
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int math_frexp (lua_State *L) {
|
||||
int e;
|
||||
lua_pushnumber(L, l_mathop(frexp)(luaL_checknumber(L, 1), &e));
|
||||
lua_pushinteger(L, e);
|
||||
return 2;
|
||||
}
|
||||
|
||||
static int math_ldexp (lua_State *L) {
|
||||
lua_Number x = luaL_checknumber(L, 1);
|
||||
int ep = (int)luaL_checkinteger(L, 2);
|
||||
lua_pushnumber(L, l_mathop(ldexp)(x, ep));
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int math_log10 (lua_State *L) {
|
||||
lua_pushnumber(L, l_mathop(log10)(luaL_checknumber(L, 1)));
|
||||
return 1;
|
||||
}
|
||||
|
||||
#endif
|
||||
/* }================================================================== */
|
||||
|
||||
|
||||
|
||||
static const luaL_Reg mathlib[] = {
|
||||
{"abs", math_abs},
|
||||
{"acos", math_acos},
|
||||
{"asin", math_asin},
|
||||
{"atan", math_atan},
|
||||
{"ceil", math_ceil},
|
||||
{"cos", math_cos},
|
||||
{"deg", math_deg},
|
||||
{"exp", math_exp},
|
||||
{"tointeger", math_toint},
|
||||
{"floor", math_floor},
|
||||
{"fmod", math_fmod},
|
||||
{"ult", math_ult},
|
||||
{"log", math_log},
|
||||
{"max", math_max},
|
||||
{"min", math_min},
|
||||
{"modf", math_modf},
|
||||
{"rad", math_rad},
|
||||
{"sin", math_sin},
|
||||
{"sqrt", math_sqrt},
|
||||
{"tan", math_tan},
|
||||
{"type", math_type},
|
||||
#if defined(LUA_COMPAT_MATHLIB)
|
||||
{"atan2", math_atan},
|
||||
{"cosh", math_cosh},
|
||||
{"sinh", math_sinh},
|
||||
{"tanh", math_tanh},
|
||||
{"pow", math_pow},
|
||||
{"frexp", math_frexp},
|
||||
{"ldexp", math_ldexp},
|
||||
{"log10", math_log10},
|
||||
#endif
|
||||
/* placeholders */
|
||||
{"random", NULL},
|
||||
{"randomseed", NULL},
|
||||
{"pi", NULL},
|
||||
{"huge", NULL},
|
||||
{"maxinteger", NULL},
|
||||
{"mininteger", NULL},
|
||||
{NULL, NULL}
|
||||
};
|
||||
|
||||
|
||||
/*
|
||||
** Open math library
|
||||
*/
|
||||
LUAMOD_API int luaopen_math (lua_State *L) {
|
||||
luaL_newlib(L, mathlib);
|
||||
lua_pushnumber(L, PI);
|
||||
lua_setfield(L, -2, "pi");
|
||||
lua_pushnumber(L, (lua_Number)HUGE_VAL);
|
||||
lua_setfield(L, -2, "huge");
|
||||
lua_pushinteger(L, LUA_MAXINTEGER);
|
||||
lua_setfield(L, -2, "maxinteger");
|
||||
lua_pushinteger(L, LUA_MININTEGER);
|
||||
lua_setfield(L, -2, "mininteger");
|
||||
setrandfunc(L);
|
||||
return 1;
|
||||
}
|
||||
|
||||
@ -1,215 +0,0 @@
|
||||
/*
|
||||
** $Id: lmem.c $
|
||||
** Interface to Memory Manager
|
||||
** See Copyright Notice in lua.h
|
||||
*/
|
||||
|
||||
#define lmem_c
|
||||
#define LUA_CORE
|
||||
|
||||
#include "lprefix.h"
|
||||
|
||||
|
||||
#include <stddef.h>
|
||||
|
||||
#include "lua.h"
|
||||
|
||||
#include "ldebug.h"
|
||||
#include "ldo.h"
|
||||
#include "lgc.h"
|
||||
#include "lmem.h"
|
||||
#include "lobject.h"
|
||||
#include "lstate.h"
|
||||
|
||||
|
||||
|
||||
/*
|
||||
** About the realloc function:
|
||||
** void *frealloc (void *ud, void *ptr, size_t osize, size_t nsize);
|
||||
** ('osize' is the old size, 'nsize' is the new size)
|
||||
**
|
||||
** - frealloc(ud, p, x, 0) frees the block 'p' and returns NULL.
|
||||
** Particularly, frealloc(ud, NULL, 0, 0) does nothing,
|
||||
** which is equivalent to free(NULL) in ISO C.
|
||||
**
|
||||
** - frealloc(ud, NULL, x, s) creates a new block of size 's'
|
||||
** (no matter 'x'). Returns NULL if it cannot create the new block.
|
||||
**
|
||||
** - otherwise, frealloc(ud, b, x, y) reallocates the block 'b' from
|
||||
** size 'x' to size 'y'. Returns NULL if it cannot reallocate the
|
||||
** block to the new size.
|
||||
*/
|
||||
|
||||
|
||||
/*
|
||||
** Macro to call the allocation function.
|
||||
*/
|
||||
#define callfrealloc(g,block,os,ns) ((*g->frealloc)(g->ud, block, os, ns))
|
||||
|
||||
|
||||
/*
|
||||
** When an allocation fails, it will try again after an emergency
|
||||
** collection, except when it cannot run a collection. The GC should
|
||||
** not be called while the state is not fully built, as the collector
|
||||
** is not yet fully initialized. Also, it should not be called when
|
||||
** 'gcstopem' is true, because then the interpreter is in the middle of
|
||||
** a collection step.
|
||||
*/
|
||||
#define cantryagain(g) (completestate(g) && !g->gcstopem)
|
||||
|
||||
|
||||
|
||||
|
||||
#if defined(EMERGENCYGCTESTS)
|
||||
/*
|
||||
** First allocation will fail except when freeing a block (frees never
|
||||
** fail) and when it cannot try again; this fail will trigger 'tryagain'
|
||||
** and a full GC cycle at every allocation.
|
||||
*/
|
||||
static void *firsttry (global_State *g, void *block, size_t os, size_t ns) {
|
||||
if (ns > 0 && cantryagain(g))
|
||||
return NULL; /* fail */
|
||||
else /* normal allocation */
|
||||
return callfrealloc(g, block, os, ns);
|
||||
}
|
||||
#else
|
||||
#define firsttry(g,block,os,ns) callfrealloc(g, block, os, ns)
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
/*
|
||||
** {==================================================================
|
||||
** Functions to allocate/deallocate arrays for the Parser
|
||||
** ===================================================================
|
||||
*/
|
||||
|
||||
/*
|
||||
** Minimum size for arrays during parsing, to avoid overhead of
|
||||
** reallocating to size 1, then 2, and then 4. All these arrays
|
||||
** will be reallocated to exact sizes or erased when parsing ends.
|
||||
*/
|
||||
#define MINSIZEARRAY 4
|
||||
|
||||
|
||||
void *luaM_growaux_ (lua_State *L, void *block, int nelems, int *psize,
|
||||
int size_elems, int limit, const char *what) {
|
||||
void *newblock;
|
||||
int size = *psize;
|
||||
if (nelems + 1 <= size) /* does one extra element still fit? */
|
||||
return block; /* nothing to be done */
|
||||
if (size >= limit / 2) { /* cannot double it? */
|
||||
if (l_unlikely(size >= limit)) /* cannot grow even a little? */
|
||||
luaG_runerror(L, "too many %s (limit is %d)", what, limit);
|
||||
size = limit; /* still have at least one free place */
|
||||
}
|
||||
else {
|
||||
size *= 2;
|
||||
if (size < MINSIZEARRAY)
|
||||
size = MINSIZEARRAY; /* minimum size */
|
||||
}
|
||||
lua_assert(nelems + 1 <= size && size <= limit);
|
||||
/* 'limit' ensures that multiplication will not overflow */
|
||||
newblock = luaM_saferealloc_(L, block, cast_sizet(*psize) * size_elems,
|
||||
cast_sizet(size) * size_elems);
|
||||
*psize = size; /* update only when everything else is OK */
|
||||
return newblock;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** In prototypes, the size of the array is also its number of
|
||||
** elements (to save memory). So, if it cannot shrink an array
|
||||
** to its number of elements, the only option is to raise an
|
||||
** error.
|
||||
*/
|
||||
void *luaM_shrinkvector_ (lua_State *L, void *block, int *size,
|
||||
int final_n, int size_elem) {
|
||||
void *newblock;
|
||||
size_t oldsize = cast_sizet((*size) * size_elem);
|
||||
size_t newsize = cast_sizet(final_n * size_elem);
|
||||
lua_assert(newsize <= oldsize);
|
||||
newblock = luaM_saferealloc_(L, block, oldsize, newsize);
|
||||
*size = final_n;
|
||||
return newblock;
|
||||
}
|
||||
|
||||
/* }================================================================== */
|
||||
|
||||
|
||||
l_noret luaM_toobig (lua_State *L) {
|
||||
luaG_runerror(L, "memory allocation error: block too big");
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Free memory
|
||||
*/
|
||||
void luaM_free_ (lua_State *L, void *block, size_t osize) {
|
||||
global_State *g = G(L);
|
||||
lua_assert((osize == 0) == (block == NULL));
|
||||
callfrealloc(g, block, osize, 0);
|
||||
g->GCdebt -= osize;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** In case of allocation fail, this function will do an emergency
|
||||
** collection to free some memory and then try the allocation again.
|
||||
*/
|
||||
static void *tryagain (lua_State *L, void *block,
|
||||
size_t osize, size_t nsize) {
|
||||
global_State *g = G(L);
|
||||
if (cantryagain(g)) {
|
||||
luaC_fullgc(L, 1); /* try to free some memory... */
|
||||
return callfrealloc(g, block, osize, nsize); /* try again */
|
||||
}
|
||||
else return NULL; /* cannot run an emergency collection */
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Generic allocation routine.
|
||||
*/
|
||||
void *luaM_realloc_ (lua_State *L, void *block, size_t osize, size_t nsize) {
|
||||
void *newblock;
|
||||
global_State *g = G(L);
|
||||
lua_assert((osize == 0) == (block == NULL));
|
||||
newblock = firsttry(g, block, osize, nsize);
|
||||
if (l_unlikely(newblock == NULL && nsize > 0)) {
|
||||
newblock = tryagain(L, block, osize, nsize);
|
||||
if (newblock == NULL) /* still no memory? */
|
||||
return NULL; /* do not update 'GCdebt' */
|
||||
}
|
||||
lua_assert((nsize == 0) == (newblock == NULL));
|
||||
g->GCdebt = (g->GCdebt + nsize) - osize;
|
||||
return newblock;
|
||||
}
|
||||
|
||||
|
||||
void *luaM_saferealloc_ (lua_State *L, void *block, size_t osize,
|
||||
size_t nsize) {
|
||||
void *newblock = luaM_realloc_(L, block, osize, nsize);
|
||||
if (l_unlikely(newblock == NULL && nsize > 0)) /* allocation failed? */
|
||||
luaM_error(L);
|
||||
return newblock;
|
||||
}
|
||||
|
||||
|
||||
void *luaM_malloc_ (lua_State *L, size_t size, int tag) {
|
||||
if (size == 0)
|
||||
return NULL; /* that's all */
|
||||
else {
|
||||
global_State *g = G(L);
|
||||
void *newblock = firsttry(g, NULL, tag, size);
|
||||
if (l_unlikely(newblock == NULL)) {
|
||||
newblock = tryagain(L, NULL, tag, size);
|
||||
if (newblock == NULL)
|
||||
luaM_error(L);
|
||||
}
|
||||
g->GCdebt += size;
|
||||
return newblock;
|
||||
}
|
||||
}
|
||||
@ -1,93 +0,0 @@
|
||||
/*
|
||||
** $Id: lmem.h $
|
||||
** Interface to Memory Manager
|
||||
** See Copyright Notice in lua.h
|
||||
*/
|
||||
|
||||
#ifndef lmem_h
|
||||
#define lmem_h
|
||||
|
||||
|
||||
#include <stddef.h>
|
||||
|
||||
#include "llimits.h"
|
||||
#include "lua.h"
|
||||
|
||||
|
||||
#define luaM_error(L) luaD_throw(L, LUA_ERRMEM)
|
||||
|
||||
|
||||
/*
|
||||
** This macro tests whether it is safe to multiply 'n' by the size of
|
||||
** type 't' without overflows. Because 'e' is always constant, it avoids
|
||||
** the runtime division MAX_SIZET/(e).
|
||||
** (The macro is somewhat complex to avoid warnings: The 'sizeof'
|
||||
** comparison avoids a runtime comparison when overflow cannot occur.
|
||||
** The compiler should be able to optimize the real test by itself, but
|
||||
** when it does it, it may give a warning about "comparison is always
|
||||
** false due to limited range of data type"; the +1 tricks the compiler,
|
||||
** avoiding this warning but also this optimization.)
|
||||
*/
|
||||
#define luaM_testsize(n,e) \
|
||||
(sizeof(n) >= sizeof(size_t) && cast_sizet((n)) + 1 > MAX_SIZET/(e))
|
||||
|
||||
#define luaM_checksize(L,n,e) \
|
||||
(luaM_testsize(n,e) ? luaM_toobig(L) : cast_void(0))
|
||||
|
||||
|
||||
/*
|
||||
** Computes the minimum between 'n' and 'MAX_SIZET/sizeof(t)', so that
|
||||
** the result is not larger than 'n' and cannot overflow a 'size_t'
|
||||
** when multiplied by the size of type 't'. (Assumes that 'n' is an
|
||||
** 'int' or 'unsigned int' and that 'int' is not larger than 'size_t'.)
|
||||
*/
|
||||
#define luaM_limitN(n,t) \
|
||||
((cast_sizet(n) <= MAX_SIZET/sizeof(t)) ? (n) : \
|
||||
cast_uint((MAX_SIZET/sizeof(t))))
|
||||
|
||||
|
||||
/*
|
||||
** Arrays of chars do not need any test
|
||||
*/
|
||||
#define luaM_reallocvchar(L,b,on,n) \
|
||||
cast_charp(luaM_saferealloc_(L, (b), (on)*sizeof(char), (n)*sizeof(char)))
|
||||
|
||||
#define luaM_freemem(L, b, s) luaM_free_(L, (b), (s))
|
||||
#define luaM_free(L, b) luaM_free_(L, (b), sizeof(*(b)))
|
||||
#define luaM_freearray(L, b, n) luaM_free_(L, (b), (n)*sizeof(*(b)))
|
||||
|
||||
#define luaM_new(L,t) cast(t*, luaM_malloc_(L, sizeof(t), 0))
|
||||
#define luaM_newvector(L,n,t) cast(t*, luaM_malloc_(L, (n)*sizeof(t), 0))
|
||||
#define luaM_newvectorchecked(L,n,t) \
|
||||
(luaM_checksize(L,n,sizeof(t)), luaM_newvector(L,n,t))
|
||||
|
||||
#define luaM_newobject(L,tag,s) luaM_malloc_(L, (s), tag)
|
||||
|
||||
#define luaM_growvector(L,v,nelems,size,t,limit,e) \
|
||||
((v)=cast(t *, luaM_growaux_(L,v,nelems,&(size),sizeof(t), \
|
||||
luaM_limitN(limit,t),e)))
|
||||
|
||||
#define luaM_reallocvector(L, v,oldn,n,t) \
|
||||
(cast(t *, luaM_realloc_(L, v, cast_sizet(oldn) * sizeof(t), \
|
||||
cast_sizet(n) * sizeof(t))))
|
||||
|
||||
#define luaM_shrinkvector(L,v,size,fs,t) \
|
||||
((v)=cast(t *, luaM_shrinkvector_(L, v, &(size), fs, sizeof(t))))
|
||||
|
||||
LUAI_FUNC l_noret luaM_toobig (lua_State *L);
|
||||
|
||||
/* not to be called directly */
|
||||
LUAI_FUNC void *luaM_realloc_ (lua_State *L, void *block, size_t oldsize,
|
||||
size_t size);
|
||||
LUAI_FUNC void *luaM_saferealloc_ (lua_State *L, void *block, size_t oldsize,
|
||||
size_t size);
|
||||
LUAI_FUNC void luaM_free_ (lua_State *L, void *block, size_t osize);
|
||||
LUAI_FUNC void *luaM_growaux_ (lua_State *L, void *block, int nelems,
|
||||
int *size, int size_elem, int limit,
|
||||
const char *what);
|
||||
LUAI_FUNC void *luaM_shrinkvector_ (lua_State *L, void *block, int *nelem,
|
||||
int final_n, int size_elem);
|
||||
LUAI_FUNC void *luaM_malloc_ (lua_State *L, size_t size, int tag);
|
||||
|
||||
#endif
|
||||
|
||||
@ -1,758 +0,0 @@
|
||||
/*
|
||||
** $Id: loadlib.c $
|
||||
** Dynamic library loader for Lua
|
||||
** See Copyright Notice in lua.h
|
||||
**
|
||||
** This module contains an implementation of loadlib for Unix systems
|
||||
** that have dlfcn, an implementation for Windows, and a stub for other
|
||||
** systems.
|
||||
*/
|
||||
|
||||
#define loadlib_c
|
||||
#define LUA_LIB
|
||||
|
||||
#include "lprefix.h"
|
||||
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "lua.h"
|
||||
|
||||
#include "lauxlib.h"
|
||||
#include "lualib.h"
|
||||
|
||||
|
||||
/*
|
||||
** LUA_CSUBSEP is the character that replaces dots in submodule names
|
||||
** when searching for a C loader.
|
||||
** LUA_LSUBSEP is the character that replaces dots in submodule names
|
||||
** when searching for a Lua loader.
|
||||
*/
|
||||
#if !defined(LUA_CSUBSEP)
|
||||
#define LUA_CSUBSEP LUA_DIRSEP
|
||||
#endif
|
||||
|
||||
#if !defined(LUA_LSUBSEP)
|
||||
#define LUA_LSUBSEP LUA_DIRSEP
|
||||
#endif
|
||||
|
||||
|
||||
/* prefix for open functions in C libraries */
|
||||
#define LUA_POF "luaopen_"
|
||||
|
||||
/* separator for open functions in C libraries */
|
||||
#define LUA_OFSEP "_"
|
||||
|
||||
|
||||
/*
|
||||
** key for table in the registry that keeps handles
|
||||
** for all loaded C libraries
|
||||
*/
|
||||
static const char *const CLIBS = "_CLIBS";
|
||||
|
||||
#define LIB_FAIL "open"
|
||||
|
||||
|
||||
#define setprogdir(L) ((void)0)
|
||||
|
||||
|
||||
/*
|
||||
** Special type equivalent to '(void*)' for functions in gcc
|
||||
** (to suppress warnings when converting function pointers)
|
||||
*/
|
||||
typedef void (*voidf)(void);
|
||||
|
||||
|
||||
/*
|
||||
** system-dependent functions
|
||||
*/
|
||||
|
||||
/*
|
||||
** unload library 'lib'
|
||||
*/
|
||||
static void lsys_unloadlib (void *lib);
|
||||
|
||||
/*
|
||||
** load C library in file 'path'. If 'seeglb', load with all names in
|
||||
** the library global.
|
||||
** Returns the library; in case of error, returns NULL plus an
|
||||
** error string in the stack.
|
||||
*/
|
||||
static void *lsys_load (lua_State *L, const char *path, int seeglb);
|
||||
|
||||
/*
|
||||
** Try to find a function named 'sym' in library 'lib'.
|
||||
** Returns the function; in case of error, returns NULL plus an
|
||||
** error string in the stack.
|
||||
*/
|
||||
static lua_CFunction lsys_sym (lua_State *L, void *lib, const char *sym);
|
||||
|
||||
|
||||
|
||||
|
||||
#if defined(LUA_USE_DLOPEN) /* { */
|
||||
/*
|
||||
** {========================================================================
|
||||
** This is an implementation of loadlib based on the dlfcn interface.
|
||||
** The dlfcn interface is available in Linux, SunOS, Solaris, IRIX, FreeBSD,
|
||||
** NetBSD, AIX 4.2, HPUX 11, and probably most other Unix flavors, at least
|
||||
** as an emulation layer on top of native functions.
|
||||
** =========================================================================
|
||||
*/
|
||||
|
||||
#include <dlfcn.h>
|
||||
|
||||
/*
|
||||
** Macro to convert pointer-to-void* to pointer-to-function. This cast
|
||||
** is undefined according to ISO C, but POSIX assumes that it works.
|
||||
** (The '__extension__' in gnu compilers is only to avoid warnings.)
|
||||
*/
|
||||
#if defined(__GNUC__)
|
||||
#define cast_func(p) (__extension__ (lua_CFunction)(p))
|
||||
#else
|
||||
#define cast_func(p) ((lua_CFunction)(p))
|
||||
#endif
|
||||
|
||||
|
||||
static void lsys_unloadlib (void *lib) {
|
||||
dlclose(lib);
|
||||
}
|
||||
|
||||
|
||||
static void *lsys_load (lua_State *L, const char *path, int seeglb) {
|
||||
void *lib = dlopen(path, RTLD_NOW | (seeglb ? RTLD_GLOBAL : RTLD_LOCAL));
|
||||
if (l_unlikely(lib == NULL))
|
||||
lua_pushstring(L, dlerror());
|
||||
return lib;
|
||||
}
|
||||
|
||||
|
||||
static lua_CFunction lsys_sym (lua_State *L, void *lib, const char *sym) {
|
||||
lua_CFunction f = cast_func(dlsym(lib, sym));
|
||||
if (l_unlikely(f == NULL))
|
||||
lua_pushstring(L, dlerror());
|
||||
return f;
|
||||
}
|
||||
|
||||
/* }====================================================== */
|
||||
|
||||
|
||||
|
||||
#elif defined(LUA_DL_DLL) /* }{ */
|
||||
/*
|
||||
** {======================================================================
|
||||
** This is an implementation of loadlib for Windows using native functions.
|
||||
** =======================================================================
|
||||
*/
|
||||
|
||||
#include <windows.h>
|
||||
|
||||
|
||||
/*
|
||||
** optional flags for LoadLibraryEx
|
||||
*/
|
||||
#if !defined(LUA_LLE_FLAGS)
|
||||
#define LUA_LLE_FLAGS 0
|
||||
#endif
|
||||
|
||||
|
||||
#undef setprogdir
|
||||
|
||||
|
||||
/*
|
||||
** Replace in the path (on the top of the stack) any occurrence
|
||||
** of LUA_EXEC_DIR with the executable's path.
|
||||
*/
|
||||
static void setprogdir (lua_State *L) {
|
||||
char buff[MAX_PATH + 1];
|
||||
char *lb;
|
||||
DWORD nsize = sizeof(buff)/sizeof(char);
|
||||
DWORD n = GetModuleFileNameA(NULL, buff, nsize); /* get exec. name */
|
||||
if (n == 0 || n == nsize || (lb = strrchr(buff, '\\')) == NULL)
|
||||
luaL_error(L, "unable to get ModuleFileName");
|
||||
else {
|
||||
*lb = '\0'; /* cut name on the last '\\' to get the path */
|
||||
luaL_gsub(L, lua_tostring(L, -1), LUA_EXEC_DIR, buff);
|
||||
lua_remove(L, -2); /* remove original string */
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
static void pusherror (lua_State *L) {
|
||||
int error = GetLastError();
|
||||
char buffer[128];
|
||||
if (FormatMessageA(FORMAT_MESSAGE_IGNORE_INSERTS | FORMAT_MESSAGE_FROM_SYSTEM,
|
||||
NULL, error, 0, buffer, sizeof(buffer)/sizeof(char), NULL))
|
||||
lua_pushstring(L, buffer);
|
||||
else
|
||||
lua_pushfstring(L, "system error %d\n", error);
|
||||
}
|
||||
|
||||
static void lsys_unloadlib (void *lib) {
|
||||
FreeLibrary((HMODULE)lib);
|
||||
}
|
||||
|
||||
|
||||
static void *lsys_load (lua_State *L, const char *path, int seeglb) {
|
||||
HMODULE lib = LoadLibraryExA(path, NULL, LUA_LLE_FLAGS);
|
||||
(void)(seeglb); /* not used: symbols are 'global' by default */
|
||||
if (lib == NULL) pusherror(L);
|
||||
return lib;
|
||||
}
|
||||
|
||||
|
||||
static lua_CFunction lsys_sym (lua_State *L, void *lib, const char *sym) {
|
||||
lua_CFunction f = (lua_CFunction)(voidf)GetProcAddress((HMODULE)lib, sym);
|
||||
if (f == NULL) pusherror(L);
|
||||
return f;
|
||||
}
|
||||
|
||||
/* }====================================================== */
|
||||
|
||||
|
||||
#else /* }{ */
|
||||
/*
|
||||
** {======================================================
|
||||
** Fallback for other systems
|
||||
** =======================================================
|
||||
*/
|
||||
|
||||
#undef LIB_FAIL
|
||||
#define LIB_FAIL "absent"
|
||||
|
||||
|
||||
#define DLMSG "dynamic libraries not enabled; check your Lua installation"
|
||||
|
||||
|
||||
static void lsys_unloadlib (void *lib) {
|
||||
(void)(lib); /* not used */
|
||||
}
|
||||
|
||||
|
||||
static void *lsys_load (lua_State *L, const char *path, int seeglb) {
|
||||
(void)(path); (void)(seeglb); /* not used */
|
||||
lua_pushliteral(L, DLMSG);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
||||
static lua_CFunction lsys_sym (lua_State *L, void *lib, const char *sym) {
|
||||
(void)(lib); (void)(sym); /* not used */
|
||||
lua_pushliteral(L, DLMSG);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* }====================================================== */
|
||||
#endif /* } */
|
||||
|
||||
|
||||
/*
|
||||
** {==================================================================
|
||||
** Set Paths
|
||||
** ===================================================================
|
||||
*/
|
||||
|
||||
/*
|
||||
** LUA_PATH_VAR and LUA_CPATH_VAR are the names of the environment
|
||||
** variables that Lua check to set its paths.
|
||||
*/
|
||||
#if !defined(LUA_PATH_VAR)
|
||||
#define LUA_PATH_VAR "LUA_PATH"
|
||||
#endif
|
||||
|
||||
#if !defined(LUA_CPATH_VAR)
|
||||
#define LUA_CPATH_VAR "LUA_CPATH"
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
/*
|
||||
** return registry.LUA_NOENV as a boolean
|
||||
*/
|
||||
static int noenv (lua_State *L) {
|
||||
int b;
|
||||
lua_getfield(L, LUA_REGISTRYINDEX, "LUA_NOENV");
|
||||
b = lua_toboolean(L, -1);
|
||||
lua_pop(L, 1); /* remove value */
|
||||
return b;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Set a path
|
||||
*/
|
||||
static void setpath (lua_State *L, const char *fieldname,
|
||||
const char *envname,
|
||||
const char *dft) {
|
||||
const char *dftmark;
|
||||
const char *nver = lua_pushfstring(L, "%s%s", envname, LUA_VERSUFFIX);
|
||||
const char *path = getenv(nver); /* try versioned name */
|
||||
if (path == NULL) /* no versioned environment variable? */
|
||||
path = getenv(envname); /* try unversioned name */
|
||||
if (path == NULL || noenv(L)) /* no environment variable? */
|
||||
lua_pushstring(L, dft); /* use default */
|
||||
else if ((dftmark = strstr(path, LUA_PATH_SEP LUA_PATH_SEP)) == NULL)
|
||||
lua_pushstring(L, path); /* nothing to change */
|
||||
else { /* path contains a ";;": insert default path in its place */
|
||||
size_t len = strlen(path);
|
||||
luaL_Buffer b;
|
||||
luaL_buffinit(L, &b);
|
||||
if (path < dftmark) { /* is there a prefix before ';;'? */
|
||||
luaL_addlstring(&b, path, dftmark - path); /* add it */
|
||||
luaL_addchar(&b, *LUA_PATH_SEP);
|
||||
}
|
||||
luaL_addstring(&b, dft); /* add default */
|
||||
if (dftmark < path + len - 2) { /* is there a suffix after ';;'? */
|
||||
luaL_addchar(&b, *LUA_PATH_SEP);
|
||||
luaL_addlstring(&b, dftmark + 2, (path + len - 2) - dftmark);
|
||||
}
|
||||
luaL_pushresult(&b);
|
||||
}
|
||||
setprogdir(L);
|
||||
lua_setfield(L, -3, fieldname); /* package[fieldname] = path value */
|
||||
lua_pop(L, 1); /* pop versioned variable name ('nver') */
|
||||
}
|
||||
|
||||
/* }================================================================== */
|
||||
|
||||
|
||||
/*
|
||||
** return registry.CLIBS[path]
|
||||
*/
|
||||
static void *checkclib (lua_State *L, const char *path) {
|
||||
void *plib;
|
||||
lua_getfield(L, LUA_REGISTRYINDEX, CLIBS);
|
||||
lua_getfield(L, -1, path);
|
||||
plib = lua_touserdata(L, -1); /* plib = CLIBS[path] */
|
||||
lua_pop(L, 2); /* pop CLIBS table and 'plib' */
|
||||
return plib;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** registry.CLIBS[path] = plib -- for queries
|
||||
** registry.CLIBS[#CLIBS + 1] = plib -- also keep a list of all libraries
|
||||
*/
|
||||
static void addtoclib (lua_State *L, const char *path, void *plib) {
|
||||
lua_getfield(L, LUA_REGISTRYINDEX, CLIBS);
|
||||
lua_pushlightuserdata(L, plib);
|
||||
lua_pushvalue(L, -1);
|
||||
lua_setfield(L, -3, path); /* CLIBS[path] = plib */
|
||||
lua_rawseti(L, -2, luaL_len(L, -2) + 1); /* CLIBS[#CLIBS + 1] = plib */
|
||||
lua_pop(L, 1); /* pop CLIBS table */
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** __gc tag method for CLIBS table: calls 'lsys_unloadlib' for all lib
|
||||
** handles in list CLIBS
|
||||
*/
|
||||
static int gctm (lua_State *L) {
|
||||
lua_Integer n = luaL_len(L, 1);
|
||||
for (; n >= 1; n--) { /* for each handle, in reverse order */
|
||||
lua_rawgeti(L, 1, n); /* get handle CLIBS[n] */
|
||||
lsys_unloadlib(lua_touserdata(L, -1));
|
||||
lua_pop(L, 1); /* pop handle */
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/* error codes for 'lookforfunc' */
|
||||
#define ERRLIB 1
|
||||
#define ERRFUNC 2
|
||||
|
||||
/*
|
||||
** Look for a C function named 'sym' in a dynamically loaded library
|
||||
** 'path'.
|
||||
** First, check whether the library is already loaded; if not, try
|
||||
** to load it.
|
||||
** Then, if 'sym' is '*', return true (as library has been loaded).
|
||||
** Otherwise, look for symbol 'sym' in the library and push a
|
||||
** C function with that symbol.
|
||||
** Return 0 and 'true' or a function in the stack; in case of
|
||||
** errors, return an error code and an error message in the stack.
|
||||
*/
|
||||
static int lookforfunc (lua_State *L, const char *path, const char *sym) {
|
||||
void *reg = checkclib(L, path); /* check loaded C libraries */
|
||||
if (reg == NULL) { /* must load library? */
|
||||
reg = lsys_load(L, path, *sym == '*'); /* global symbols if 'sym'=='*' */
|
||||
if (reg == NULL) return ERRLIB; /* unable to load library */
|
||||
addtoclib(L, path, reg);
|
||||
}
|
||||
if (*sym == '*') { /* loading only library (no function)? */
|
||||
lua_pushboolean(L, 1); /* return 'true' */
|
||||
return 0; /* no errors */
|
||||
}
|
||||
else {
|
||||
lua_CFunction f = lsys_sym(L, reg, sym);
|
||||
if (f == NULL)
|
||||
return ERRFUNC; /* unable to find function */
|
||||
lua_pushcfunction(L, f); /* else create new function */
|
||||
return 0; /* no errors */
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static int ll_loadlib (lua_State *L) {
|
||||
const char *path = luaL_checkstring(L, 1);
|
||||
const char *init = luaL_checkstring(L, 2);
|
||||
int stat = lookforfunc(L, path, init);
|
||||
if (l_likely(stat == 0)) /* no errors? */
|
||||
return 1; /* return the loaded function */
|
||||
else { /* error; error message is on stack top */
|
||||
luaL_pushfail(L);
|
||||
lua_insert(L, -2);
|
||||
lua_pushstring(L, (stat == ERRLIB) ? LIB_FAIL : "init");
|
||||
return 3; /* return fail, error message, and where */
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*
|
||||
** {======================================================
|
||||
** 'require' function
|
||||
** =======================================================
|
||||
*/
|
||||
|
||||
|
||||
static int readable (const char *filename) {
|
||||
FILE *f = fopen(filename, "r"); /* try to open file */
|
||||
if (f == NULL) return 0; /* open failed */
|
||||
fclose(f);
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Get the next name in '*path' = 'name1;name2;name3;...', changing
|
||||
** the ending ';' to '\0' to create a zero-terminated string. Return
|
||||
** NULL when list ends.
|
||||
*/
|
||||
static const char *getnextfilename (char **path, char *end) {
|
||||
char *sep;
|
||||
char *name = *path;
|
||||
if (name == end)
|
||||
return NULL; /* no more names */
|
||||
else if (*name == '\0') { /* from previous iteration? */
|
||||
*name = *LUA_PATH_SEP; /* restore separator */
|
||||
name++; /* skip it */
|
||||
}
|
||||
sep = strchr(name, *LUA_PATH_SEP); /* find next separator */
|
||||
if (sep == NULL) /* separator not found? */
|
||||
sep = end; /* name goes until the end */
|
||||
*sep = '\0'; /* finish file name */
|
||||
*path = sep; /* will start next search from here */
|
||||
return name;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Given a path such as ";blabla.so;blublu.so", pushes the string
|
||||
**
|
||||
** no file 'blabla.so'
|
||||
** no file 'blublu.so'
|
||||
*/
|
||||
static void pusherrornotfound (lua_State *L, const char *path) {
|
||||
luaL_Buffer b;
|
||||
luaL_buffinit(L, &b);
|
||||
luaL_addstring(&b, "no file '");
|
||||
luaL_addgsub(&b, path, LUA_PATH_SEP, "'\n\tno file '");
|
||||
luaL_addstring(&b, "'");
|
||||
luaL_pushresult(&b);
|
||||
}
|
||||
|
||||
|
||||
static const char *searchpath (lua_State *L, const char *name,
|
||||
const char *path,
|
||||
const char *sep,
|
||||
const char *dirsep) {
|
||||
luaL_Buffer buff;
|
||||
char *pathname; /* path with name inserted */
|
||||
char *endpathname; /* its end */
|
||||
const char *filename;
|
||||
/* separator is non-empty and appears in 'name'? */
|
||||
if (*sep != '\0' && strchr(name, *sep) != NULL)
|
||||
name = luaL_gsub(L, name, sep, dirsep); /* replace it by 'dirsep' */
|
||||
luaL_buffinit(L, &buff);
|
||||
/* add path to the buffer, replacing marks ('?') with the file name */
|
||||
luaL_addgsub(&buff, path, LUA_PATH_MARK, name);
|
||||
luaL_addchar(&buff, '\0');
|
||||
pathname = luaL_buffaddr(&buff); /* writable list of file names */
|
||||
endpathname = pathname + luaL_bufflen(&buff) - 1;
|
||||
while ((filename = getnextfilename(&pathname, endpathname)) != NULL) {
|
||||
if (readable(filename)) /* does file exist and is readable? */
|
||||
return lua_pushstring(L, filename); /* save and return name */
|
||||
}
|
||||
luaL_pushresult(&buff); /* push path to create error message */
|
||||
pusherrornotfound(L, lua_tostring(L, -1)); /* create error message */
|
||||
return NULL; /* not found */
|
||||
}
|
||||
|
||||
|
||||
static int ll_searchpath (lua_State *L) {
|
||||
const char *f = searchpath(L, luaL_checkstring(L, 1),
|
||||
luaL_checkstring(L, 2),
|
||||
luaL_optstring(L, 3, "."),
|
||||
luaL_optstring(L, 4, LUA_DIRSEP));
|
||||
if (f != NULL) return 1;
|
||||
else { /* error message is on top of the stack */
|
||||
luaL_pushfail(L);
|
||||
lua_insert(L, -2);
|
||||
return 2; /* return fail + error message */
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static const char *findfile (lua_State *L, const char *name,
|
||||
const char *pname,
|
||||
const char *dirsep) {
|
||||
const char *path;
|
||||
lua_getfield(L, lua_upvalueindex(1), pname);
|
||||
path = lua_tostring(L, -1);
|
||||
if (l_unlikely(path == NULL))
|
||||
luaL_error(L, "'package.%s' must be a string", pname);
|
||||
return searchpath(L, name, path, ".", dirsep);
|
||||
}
|
||||
|
||||
|
||||
static int checkload (lua_State *L, int stat, const char *filename) {
|
||||
if (l_likely(stat)) { /* module loaded successfully? */
|
||||
lua_pushstring(L, filename); /* will be 2nd argument to module */
|
||||
return 2; /* return open function and file name */
|
||||
}
|
||||
else
|
||||
return luaL_error(L, "error loading module '%s' from file '%s':\n\t%s",
|
||||
lua_tostring(L, 1), filename, lua_tostring(L, -1));
|
||||
}
|
||||
|
||||
|
||||
static int searcher_Lua (lua_State *L) {
|
||||
const char *filename;
|
||||
const char *name = luaL_checkstring(L, 1);
|
||||
filename = findfile(L, name, "path", LUA_LSUBSEP);
|
||||
if (filename == NULL) return 1; /* module not found in this path */
|
||||
return checkload(L, (luaL_loadfile(L, filename) == LUA_OK), filename);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Try to find a load function for module 'modname' at file 'filename'.
|
||||
** First, change '.' to '_' in 'modname'; then, if 'modname' has
|
||||
** the form X-Y (that is, it has an "ignore mark"), build a function
|
||||
** name "luaopen_X" and look for it. (For compatibility, if that
|
||||
** fails, it also tries "luaopen_Y".) If there is no ignore mark,
|
||||
** look for a function named "luaopen_modname".
|
||||
*/
|
||||
static int loadfunc (lua_State *L, const char *filename, const char *modname) {
|
||||
const char *openfunc;
|
||||
const char *mark;
|
||||
modname = luaL_gsub(L, modname, ".", LUA_OFSEP);
|
||||
mark = strchr(modname, *LUA_IGMARK);
|
||||
if (mark) {
|
||||
int stat;
|
||||
openfunc = lua_pushlstring(L, modname, mark - modname);
|
||||
openfunc = lua_pushfstring(L, LUA_POF"%s", openfunc);
|
||||
stat = lookforfunc(L, filename, openfunc);
|
||||
if (stat != ERRFUNC) return stat;
|
||||
modname = mark + 1; /* else go ahead and try old-style name */
|
||||
}
|
||||
openfunc = lua_pushfstring(L, LUA_POF"%s", modname);
|
||||
return lookforfunc(L, filename, openfunc);
|
||||
}
|
||||
|
||||
|
||||
static int searcher_C (lua_State *L) {
|
||||
const char *name = luaL_checkstring(L, 1);
|
||||
const char *filename = findfile(L, name, "cpath", LUA_CSUBSEP);
|
||||
if (filename == NULL) return 1; /* module not found in this path */
|
||||
return checkload(L, (loadfunc(L, filename, name) == 0), filename);
|
||||
}
|
||||
|
||||
|
||||
static int searcher_Croot (lua_State *L) {
|
||||
const char *filename;
|
||||
const char *name = luaL_checkstring(L, 1);
|
||||
const char *p = strchr(name, '.');
|
||||
int stat;
|
||||
if (p == NULL) return 0; /* is root */
|
||||
lua_pushlstring(L, name, p - name);
|
||||
filename = findfile(L, lua_tostring(L, -1), "cpath", LUA_CSUBSEP);
|
||||
if (filename == NULL) return 1; /* root not found */
|
||||
if ((stat = loadfunc(L, filename, name)) != 0) {
|
||||
if (stat != ERRFUNC)
|
||||
return checkload(L, 0, filename); /* real error */
|
||||
else { /* open function not found */
|
||||
lua_pushfstring(L, "no module '%s' in file '%s'", name, filename);
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
lua_pushstring(L, filename); /* will be 2nd argument to module */
|
||||
return 2;
|
||||
}
|
||||
|
||||
|
||||
static int searcher_preload (lua_State *L) {
|
||||
const char *name = luaL_checkstring(L, 1);
|
||||
lua_getfield(L, LUA_REGISTRYINDEX, LUA_PRELOAD_TABLE);
|
||||
if (lua_getfield(L, -1, name) == LUA_TNIL) { /* not found? */
|
||||
lua_pushfstring(L, "no field package.preload['%s']", name);
|
||||
return 1;
|
||||
}
|
||||
else {
|
||||
lua_pushliteral(L, ":preload:");
|
||||
return 2;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static void findloader (lua_State *L, const char *name) {
|
||||
int i;
|
||||
luaL_Buffer msg; /* to build error message */
|
||||
/* push 'package.searchers' to index 3 in the stack */
|
||||
if (l_unlikely(lua_getfield(L, lua_upvalueindex(1), "searchers")
|
||||
!= LUA_TTABLE))
|
||||
luaL_error(L, "'package.searchers' must be a table");
|
||||
luaL_buffinit(L, &msg);
|
||||
/* iterate over available searchers to find a loader */
|
||||
for (i = 1; ; i++) {
|
||||
luaL_addstring(&msg, "\n\t"); /* error-message prefix */
|
||||
if (l_unlikely(lua_rawgeti(L, 3, i) == LUA_TNIL)) { /* no more searchers? */
|
||||
lua_pop(L, 1); /* remove nil */
|
||||
luaL_buffsub(&msg, 2); /* remove prefix */
|
||||
luaL_pushresult(&msg); /* create error message */
|
||||
luaL_error(L, "module '%s' not found:%s", name, lua_tostring(L, -1));
|
||||
}
|
||||
lua_pushstring(L, name);
|
||||
lua_call(L, 1, 2); /* call it */
|
||||
if (lua_isfunction(L, -2)) /* did it find a loader? */
|
||||
return; /* module loader found */
|
||||
else if (lua_isstring(L, -2)) { /* searcher returned error message? */
|
||||
lua_pop(L, 1); /* remove extra return */
|
||||
luaL_addvalue(&msg); /* concatenate error message */
|
||||
}
|
||||
else { /* no error message */
|
||||
lua_pop(L, 2); /* remove both returns */
|
||||
luaL_buffsub(&msg, 2); /* remove prefix */
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static int ll_require (lua_State *L) {
|
||||
const char *name = luaL_checkstring(L, 1);
|
||||
lua_settop(L, 1); /* LOADED table will be at index 2 */
|
||||
lua_getfield(L, LUA_REGISTRYINDEX, LUA_LOADED_TABLE);
|
||||
lua_getfield(L, 2, name); /* LOADED[name] */
|
||||
if (lua_toboolean(L, -1)) /* is it there? */
|
||||
return 1; /* package is already loaded */
|
||||
/* else must load package */
|
||||
lua_pop(L, 1); /* remove 'getfield' result */
|
||||
findloader(L, name);
|
||||
lua_rotate(L, -2, 1); /* function <-> loader data */
|
||||
lua_pushvalue(L, 1); /* name is 1st argument to module loader */
|
||||
lua_pushvalue(L, -3); /* loader data is 2nd argument */
|
||||
/* stack: ...; loader data; loader function; mod. name; loader data */
|
||||
lua_call(L, 2, 1); /* run loader to load module */
|
||||
/* stack: ...; loader data; result from loader */
|
||||
if (!lua_isnil(L, -1)) /* non-nil return? */
|
||||
lua_setfield(L, 2, name); /* LOADED[name] = returned value */
|
||||
else
|
||||
lua_pop(L, 1); /* pop nil */
|
||||
if (lua_getfield(L, 2, name) == LUA_TNIL) { /* module set no value? */
|
||||
lua_pushboolean(L, 1); /* use true as result */
|
||||
lua_copy(L, -1, -2); /* replace loader result */
|
||||
lua_setfield(L, 2, name); /* LOADED[name] = true */
|
||||
}
|
||||
lua_rotate(L, -2, 1); /* loader data <-> module result */
|
||||
return 2; /* return module result and loader data */
|
||||
}
|
||||
|
||||
/* }====================================================== */
|
||||
|
||||
|
||||
|
||||
|
||||
static const luaL_Reg pk_funcs[] = {
|
||||
{"loadlib", ll_loadlib},
|
||||
{"searchpath", ll_searchpath},
|
||||
/* placeholders */
|
||||
{"preload", NULL},
|
||||
{"cpath", NULL},
|
||||
{"path", NULL},
|
||||
{"searchers", NULL},
|
||||
{"loaded", NULL},
|
||||
{NULL, NULL}
|
||||
};
|
||||
|
||||
|
||||
static const luaL_Reg ll_funcs[] = {
|
||||
{"require", ll_require},
|
||||
{NULL, NULL}
|
||||
};
|
||||
|
||||
|
||||
static void createsearcherstable (lua_State *L) {
|
||||
static const lua_CFunction searchers[] = {
|
||||
searcher_preload,
|
||||
searcher_Lua,
|
||||
searcher_C,
|
||||
searcher_Croot,
|
||||
NULL
|
||||
};
|
||||
int i;
|
||||
/* create 'searchers' table */
|
||||
lua_createtable(L, sizeof(searchers)/sizeof(searchers[0]) - 1, 0);
|
||||
/* fill it with predefined searchers */
|
||||
for (i=0; searchers[i] != NULL; i++) {
|
||||
lua_pushvalue(L, -2); /* set 'package' as upvalue for all searchers */
|
||||
lua_pushcclosure(L, searchers[i], 1);
|
||||
lua_rawseti(L, -2, i+1);
|
||||
}
|
||||
lua_setfield(L, -2, "searchers"); /* put it in field 'searchers' */
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** create table CLIBS to keep track of loaded C libraries,
|
||||
** setting a finalizer to close all libraries when closing state.
|
||||
*/
|
||||
static void createclibstable (lua_State *L) {
|
||||
luaL_getsubtable(L, LUA_REGISTRYINDEX, CLIBS); /* create CLIBS table */
|
||||
lua_createtable(L, 0, 1); /* create metatable for CLIBS */
|
||||
lua_pushcfunction(L, gctm);
|
||||
lua_setfield(L, -2, "__gc"); /* set finalizer for CLIBS table */
|
||||
lua_setmetatable(L, -2);
|
||||
}
|
||||
|
||||
|
||||
LUAMOD_API int luaopen_package (lua_State *L) {
|
||||
createclibstable(L);
|
||||
luaL_newlib(L, pk_funcs); /* create 'package' table */
|
||||
createsearcherstable(L);
|
||||
/* set paths */
|
||||
setpath(L, "path", LUA_PATH_VAR, LUA_PATH_DEFAULT);
|
||||
setpath(L, "cpath", LUA_CPATH_VAR, LUA_CPATH_DEFAULT);
|
||||
/* store config information */
|
||||
lua_pushliteral(L, LUA_DIRSEP "\n" LUA_PATH_SEP "\n" LUA_PATH_MARK "\n"
|
||||
LUA_EXEC_DIR "\n" LUA_IGMARK "\n");
|
||||
lua_setfield(L, -2, "config");
|
||||
/* set field 'loaded' */
|
||||
luaL_getsubtable(L, LUA_REGISTRYINDEX, LUA_LOADED_TABLE);
|
||||
lua_setfield(L, -2, "loaded");
|
||||
/* set field 'preload' */
|
||||
luaL_getsubtable(L, LUA_REGISTRYINDEX, LUA_PRELOAD_TABLE);
|
||||
lua_setfield(L, -2, "preload");
|
||||
lua_pushglobaltable(L);
|
||||
lua_pushvalue(L, -2); /* set 'package' as upvalue for next lib */
|
||||
luaL_setfuncs(L, ll_funcs, 1); /* open lib into global table */
|
||||
lua_pop(L, 1); /* pop global table */
|
||||
return 1; /* return 'package' table */
|
||||
}
|
||||
|
||||
@ -1,602 +0,0 @@
|
||||
/*
|
||||
** $Id: lobject.c $
|
||||
** Some generic functions over Lua objects
|
||||
** See Copyright Notice in lua.h
|
||||
*/
|
||||
|
||||
#define lobject_c
|
||||
#define LUA_CORE
|
||||
|
||||
#include "lprefix.h"
|
||||
|
||||
|
||||
#include <locale.h>
|
||||
#include <math.h>
|
||||
#include <stdarg.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "lua.h"
|
||||
|
||||
#include "lctype.h"
|
||||
#include "ldebug.h"
|
||||
#include "ldo.h"
|
||||
#include "lmem.h"
|
||||
#include "lobject.h"
|
||||
#include "lstate.h"
|
||||
#include "lstring.h"
|
||||
#include "lvm.h"
|
||||
|
||||
|
||||
/*
|
||||
** Computes ceil(log2(x))
|
||||
*/
|
||||
int luaO_ceillog2 (unsigned int x) {
|
||||
static const lu_byte log_2[256] = { /* log_2[i] = ceil(log2(i - 1)) */
|
||||
0,1,2,2,3,3,3,3,4,4,4,4,4,4,4,4,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
|
||||
6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
|
||||
7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
|
||||
7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
|
||||
8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
|
||||
8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
|
||||
8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
|
||||
8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8
|
||||
};
|
||||
int l = 0;
|
||||
x--;
|
||||
while (x >= 256) { l += 8; x >>= 8; }
|
||||
return l + log_2[x];
|
||||
}
|
||||
|
||||
|
||||
static lua_Integer intarith (lua_State *L, int op, lua_Integer v1,
|
||||
lua_Integer v2) {
|
||||
switch (op) {
|
||||
case LUA_OPADD: return intop(+, v1, v2);
|
||||
case LUA_OPSUB:return intop(-, v1, v2);
|
||||
case LUA_OPMUL:return intop(*, v1, v2);
|
||||
case LUA_OPMOD: return luaV_mod(L, v1, v2);
|
||||
case LUA_OPIDIV: return luaV_idiv(L, v1, v2);
|
||||
case LUA_OPBAND: return intop(&, v1, v2);
|
||||
case LUA_OPBOR: return intop(|, v1, v2);
|
||||
case LUA_OPBXOR: return intop(^, v1, v2);
|
||||
case LUA_OPSHL: return luaV_shiftl(v1, v2);
|
||||
case LUA_OPSHR: return luaV_shiftr(v1, v2);
|
||||
case LUA_OPUNM: return intop(-, 0, v1);
|
||||
case LUA_OPBNOT: return intop(^, ~l_castS2U(0), v1);
|
||||
default: lua_assert(0); return 0;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static lua_Number numarith (lua_State *L, int op, lua_Number v1,
|
||||
lua_Number v2) {
|
||||
switch (op) {
|
||||
case LUA_OPADD: return luai_numadd(L, v1, v2);
|
||||
case LUA_OPSUB: return luai_numsub(L, v1, v2);
|
||||
case LUA_OPMUL: return luai_nummul(L, v1, v2);
|
||||
case LUA_OPDIV: return luai_numdiv(L, v1, v2);
|
||||
case LUA_OPPOW: return luai_numpow(L, v1, v2);
|
||||
case LUA_OPIDIV: return luai_numidiv(L, v1, v2);
|
||||
case LUA_OPUNM: return luai_numunm(L, v1);
|
||||
case LUA_OPMOD: return luaV_modf(L, v1, v2);
|
||||
default: lua_assert(0); return 0;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
int luaO_rawarith (lua_State *L, int op, const TValue *p1, const TValue *p2,
|
||||
TValue *res) {
|
||||
switch (op) {
|
||||
case LUA_OPBAND: case LUA_OPBOR: case LUA_OPBXOR:
|
||||
case LUA_OPSHL: case LUA_OPSHR:
|
||||
case LUA_OPBNOT: { /* operate only on integers */
|
||||
lua_Integer i1; lua_Integer i2;
|
||||
if (tointegerns(p1, &i1) && tointegerns(p2, &i2)) {
|
||||
setivalue(res, intarith(L, op, i1, i2));
|
||||
return 1;
|
||||
}
|
||||
else return 0; /* fail */
|
||||
}
|
||||
case LUA_OPDIV: case LUA_OPPOW: { /* operate only on floats */
|
||||
lua_Number n1; lua_Number n2;
|
||||
if (tonumberns(p1, n1) && tonumberns(p2, n2)) {
|
||||
setfltvalue(res, numarith(L, op, n1, n2));
|
||||
return 1;
|
||||
}
|
||||
else return 0; /* fail */
|
||||
}
|
||||
default: { /* other operations */
|
||||
lua_Number n1; lua_Number n2;
|
||||
if (ttisinteger(p1) && ttisinteger(p2)) {
|
||||
setivalue(res, intarith(L, op, ivalue(p1), ivalue(p2)));
|
||||
return 1;
|
||||
}
|
||||
else if (tonumberns(p1, n1) && tonumberns(p2, n2)) {
|
||||
setfltvalue(res, numarith(L, op, n1, n2));
|
||||
return 1;
|
||||
}
|
||||
else return 0; /* fail */
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void luaO_arith (lua_State *L, int op, const TValue *p1, const TValue *p2,
|
||||
StkId res) {
|
||||
if (!luaO_rawarith(L, op, p1, p2, s2v(res))) {
|
||||
/* could not perform raw operation; try metamethod */
|
||||
luaT_trybinTM(L, p1, p2, res, cast(TMS, (op - LUA_OPADD) + TM_ADD));
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
int luaO_hexavalue (int c) {
|
||||
if (lisdigit(c)) return c - '0';
|
||||
else return (ltolower(c) - 'a') + 10;
|
||||
}
|
||||
|
||||
|
||||
static int isneg (const char **s) {
|
||||
if (**s == '-') { (*s)++; return 1; }
|
||||
else if (**s == '+') (*s)++;
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*
|
||||
** {==================================================================
|
||||
** Lua's implementation for 'lua_strx2number'
|
||||
** ===================================================================
|
||||
*/
|
||||
|
||||
#if !defined(lua_strx2number)
|
||||
|
||||
/* maximum number of significant digits to read (to avoid overflows
|
||||
even with single floats) */
|
||||
#define MAXSIGDIG 30
|
||||
|
||||
/*
|
||||
** convert a hexadecimal numeric string to a number, following
|
||||
** C99 specification for 'strtod'
|
||||
*/
|
||||
static lua_Number lua_strx2number (const char *s, char **endptr) {
|
||||
int dot = lua_getlocaledecpoint();
|
||||
lua_Number r = l_mathop(0.0); /* result (accumulator) */
|
||||
int sigdig = 0; /* number of significant digits */
|
||||
int nosigdig = 0; /* number of non-significant digits */
|
||||
int e = 0; /* exponent correction */
|
||||
int neg; /* 1 if number is negative */
|
||||
int hasdot = 0; /* true after seen a dot */
|
||||
*endptr = cast_charp(s); /* nothing is valid yet */
|
||||
while (lisspace(cast_uchar(*s))) s++; /* skip initial spaces */
|
||||
neg = isneg(&s); /* check sign */
|
||||
if (!(*s == '0' && (*(s + 1) == 'x' || *(s + 1) == 'X'))) /* check '0x' */
|
||||
return l_mathop(0.0); /* invalid format (no '0x') */
|
||||
for (s += 2; ; s++) { /* skip '0x' and read numeral */
|
||||
if (*s == dot) {
|
||||
if (hasdot) break; /* second dot? stop loop */
|
||||
else hasdot = 1;
|
||||
}
|
||||
else if (lisxdigit(cast_uchar(*s))) {
|
||||
if (sigdig == 0 && *s == '0') /* non-significant digit (zero)? */
|
||||
nosigdig++;
|
||||
else if (++sigdig <= MAXSIGDIG) /* can read it without overflow? */
|
||||
r = (r * l_mathop(16.0)) + luaO_hexavalue(*s);
|
||||
else e++; /* too many digits; ignore, but still count for exponent */
|
||||
if (hasdot) e--; /* decimal digit? correct exponent */
|
||||
}
|
||||
else break; /* neither a dot nor a digit */
|
||||
}
|
||||
if (nosigdig + sigdig == 0) /* no digits? */
|
||||
return l_mathop(0.0); /* invalid format */
|
||||
*endptr = cast_charp(s); /* valid up to here */
|
||||
e *= 4; /* each digit multiplies/divides value by 2^4 */
|
||||
if (*s == 'p' || *s == 'P') { /* exponent part? */
|
||||
int exp1 = 0; /* exponent value */
|
||||
int neg1; /* exponent sign */
|
||||
s++; /* skip 'p' */
|
||||
neg1 = isneg(&s); /* sign */
|
||||
if (!lisdigit(cast_uchar(*s)))
|
||||
return l_mathop(0.0); /* invalid; must have at least one digit */
|
||||
while (lisdigit(cast_uchar(*s))) /* read exponent */
|
||||
exp1 = exp1 * 10 + *(s++) - '0';
|
||||
if (neg1) exp1 = -exp1;
|
||||
e += exp1;
|
||||
*endptr = cast_charp(s); /* valid up to here */
|
||||
}
|
||||
if (neg) r = -r;
|
||||
return l_mathop(ldexp)(r, e);
|
||||
}
|
||||
|
||||
#endif
|
||||
/* }====================================================== */
|
||||
|
||||
|
||||
/* maximum length of a numeral to be converted to a number */
|
||||
#if !defined (L_MAXLENNUM)
|
||||
#define L_MAXLENNUM 200
|
||||
#endif
|
||||
|
||||
/*
|
||||
** Convert string 's' to a Lua number (put in 'result'). Return NULL on
|
||||
** fail or the address of the ending '\0' on success. ('mode' == 'x')
|
||||
** means a hexadecimal numeral.
|
||||
*/
|
||||
static const char *l_str2dloc (const char *s, lua_Number *result, int mode) {
|
||||
char *endptr;
|
||||
*result = (mode == 'x') ? lua_strx2number(s, &endptr) /* try to convert */
|
||||
: lua_str2number(s, &endptr);
|
||||
if (endptr == s) return NULL; /* nothing recognized? */
|
||||
while (lisspace(cast_uchar(*endptr))) endptr++; /* skip trailing spaces */
|
||||
return (*endptr == '\0') ? endptr : NULL; /* OK iff no trailing chars */
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Convert string 's' to a Lua number (put in 'result') handling the
|
||||
** current locale.
|
||||
** This function accepts both the current locale or a dot as the radix
|
||||
** mark. If the conversion fails, it may mean number has a dot but
|
||||
** locale accepts something else. In that case, the code copies 's'
|
||||
** to a buffer (because 's' is read-only), changes the dot to the
|
||||
** current locale radix mark, and tries to convert again.
|
||||
** The variable 'mode' checks for special characters in the string:
|
||||
** - 'n' means 'inf' or 'nan' (which should be rejected)
|
||||
** - 'x' means a hexadecimal numeral
|
||||
** - '.' just optimizes the search for the common case (no special chars)
|
||||
*/
|
||||
static const char *l_str2d (const char *s, lua_Number *result) {
|
||||
const char *endptr;
|
||||
const char *pmode = strpbrk(s, ".xXnN"); /* look for special chars */
|
||||
int mode = pmode ? ltolower(cast_uchar(*pmode)) : 0;
|
||||
if (mode == 'n') /* reject 'inf' and 'nan' */
|
||||
return NULL;
|
||||
endptr = l_str2dloc(s, result, mode); /* try to convert */
|
||||
if (endptr == NULL) { /* failed? may be a different locale */
|
||||
char buff[L_MAXLENNUM + 1];
|
||||
const char *pdot = strchr(s, '.');
|
||||
if (pdot == NULL || strlen(s) > L_MAXLENNUM)
|
||||
return NULL; /* string too long or no dot; fail */
|
||||
strcpy(buff, s); /* copy string to buffer */
|
||||
buff[pdot - s] = lua_getlocaledecpoint(); /* correct decimal point */
|
||||
endptr = l_str2dloc(buff, result, mode); /* try again */
|
||||
if (endptr != NULL)
|
||||
endptr = s + (endptr - buff); /* make relative to 's' */
|
||||
}
|
||||
return endptr;
|
||||
}
|
||||
|
||||
|
||||
#define MAXBY10 cast(lua_Unsigned, LUA_MAXINTEGER / 10)
|
||||
#define MAXLASTD cast_int(LUA_MAXINTEGER % 10)
|
||||
|
||||
static const char *l_str2int (const char *s, lua_Integer *result) {
|
||||
lua_Unsigned a = 0;
|
||||
int empty = 1;
|
||||
int neg;
|
||||
while (lisspace(cast_uchar(*s))) s++; /* skip initial spaces */
|
||||
neg = isneg(&s);
|
||||
if (s[0] == '0' &&
|
||||
(s[1] == 'x' || s[1] == 'X')) { /* hex? */
|
||||
s += 2; /* skip '0x' */
|
||||
for (; lisxdigit(cast_uchar(*s)); s++) {
|
||||
a = a * 16 + luaO_hexavalue(*s);
|
||||
empty = 0;
|
||||
}
|
||||
}
|
||||
else { /* decimal */
|
||||
for (; lisdigit(cast_uchar(*s)); s++) {
|
||||
int d = *s - '0';
|
||||
if (a >= MAXBY10 && (a > MAXBY10 || d > MAXLASTD + neg)) /* overflow? */
|
||||
return NULL; /* do not accept it (as integer) */
|
||||
a = a * 10 + d;
|
||||
empty = 0;
|
||||
}
|
||||
}
|
||||
while (lisspace(cast_uchar(*s))) s++; /* skip trailing spaces */
|
||||
if (empty || *s != '\0') return NULL; /* something wrong in the numeral */
|
||||
else {
|
||||
*result = l_castU2S((neg) ? 0u - a : a);
|
||||
return s;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
size_t luaO_str2num (const char *s, TValue *o) {
|
||||
lua_Integer i; lua_Number n;
|
||||
const char *e;
|
||||
if ((e = l_str2int(s, &i)) != NULL) { /* try as an integer */
|
||||
setivalue(o, i);
|
||||
}
|
||||
else if ((e = l_str2d(s, &n)) != NULL) { /* else try as a float */
|
||||
setfltvalue(o, n);
|
||||
}
|
||||
else
|
||||
return 0; /* conversion failed */
|
||||
return (e - s) + 1; /* success; return string size */
|
||||
}
|
||||
|
||||
|
||||
int luaO_utf8esc (char *buff, unsigned long x) {
|
||||
int n = 1; /* number of bytes put in buffer (backwards) */
|
||||
lua_assert(x <= 0x7FFFFFFFu);
|
||||
if (x < 0x80) /* ascii? */
|
||||
buff[UTF8BUFFSZ - 1] = cast_char(x);
|
||||
else { /* need continuation bytes */
|
||||
unsigned int mfb = 0x3f; /* maximum that fits in first byte */
|
||||
do { /* add continuation bytes */
|
||||
buff[UTF8BUFFSZ - (n++)] = cast_char(0x80 | (x & 0x3f));
|
||||
x >>= 6; /* remove added bits */
|
||||
mfb >>= 1; /* now there is one less bit available in first byte */
|
||||
} while (x > mfb); /* still needs continuation byte? */
|
||||
buff[UTF8BUFFSZ - n] = cast_char((~mfb << 1) | x); /* add first byte */
|
||||
}
|
||||
return n;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Maximum length of the conversion of a number to a string. Must be
|
||||
** enough to accommodate both LUA_INTEGER_FMT and LUA_NUMBER_FMT.
|
||||
** (For a long long int, this is 19 digits plus a sign and a final '\0',
|
||||
** adding to 21. For a long double, it can go to a sign, 33 digits,
|
||||
** the dot, an exponent letter, an exponent sign, 5 exponent digits,
|
||||
** and a final '\0', adding to 43.)
|
||||
*/
|
||||
#define MAXNUMBER2STR 44
|
||||
|
||||
|
||||
/*
|
||||
** Convert a number object to a string, adding it to a buffer
|
||||
*/
|
||||
static int tostringbuff (TValue *obj, char *buff) {
|
||||
int len;
|
||||
lua_assert(ttisnumber(obj));
|
||||
if (ttisinteger(obj))
|
||||
len = lua_integer2str(buff, MAXNUMBER2STR, ivalue(obj));
|
||||
else {
|
||||
len = lua_number2str(buff, MAXNUMBER2STR, fltvalue(obj));
|
||||
if (buff[strspn(buff, "-0123456789")] == '\0') { /* looks like an int? */
|
||||
buff[len++] = lua_getlocaledecpoint();
|
||||
buff[len++] = '0'; /* adds '.0' to result */
|
||||
}
|
||||
}
|
||||
return len;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Convert a number object to a Lua string, replacing the value at 'obj'
|
||||
*/
|
||||
void luaO_tostring (lua_State *L, TValue *obj) {
|
||||
char buff[MAXNUMBER2STR];
|
||||
int len = tostringbuff(obj, buff);
|
||||
setsvalue(L, obj, luaS_newlstr(L, buff, len));
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
/*
|
||||
** {==================================================================
|
||||
** 'luaO_pushvfstring'
|
||||
** ===================================================================
|
||||
*/
|
||||
|
||||
/*
|
||||
** Size for buffer space used by 'luaO_pushvfstring'. It should be
|
||||
** (LUA_IDSIZE + MAXNUMBER2STR) + a minimal space for basic messages,
|
||||
** so that 'luaG_addinfo' can work directly on the buffer.
|
||||
*/
|
||||
#define BUFVFS (LUA_IDSIZE + MAXNUMBER2STR + 95)
|
||||
|
||||
/* buffer used by 'luaO_pushvfstring' */
|
||||
typedef struct BuffFS {
|
||||
lua_State *L;
|
||||
int pushed; /* true if there is a part of the result on the stack */
|
||||
int blen; /* length of partial string in 'space' */
|
||||
char space[BUFVFS]; /* holds last part of the result */
|
||||
} BuffFS;
|
||||
|
||||
|
||||
/*
|
||||
** Push given string to the stack, as part of the result, and
|
||||
** join it to previous partial result if there is one.
|
||||
** It may call 'luaV_concat' while using one slot from EXTRA_STACK.
|
||||
** This call cannot invoke metamethods, as both operands must be
|
||||
** strings. It can, however, raise an error if the result is too
|
||||
** long. In that case, 'luaV_concat' frees the extra slot before
|
||||
** raising the error.
|
||||
*/
|
||||
static void pushstr (BuffFS *buff, const char *str, size_t lstr) {
|
||||
lua_State *L = buff->L;
|
||||
setsvalue2s(L, L->top.p, luaS_newlstr(L, str, lstr));
|
||||
L->top.p++; /* may use one slot from EXTRA_STACK */
|
||||
if (!buff->pushed) /* no previous string on the stack? */
|
||||
buff->pushed = 1; /* now there is one */
|
||||
else /* join previous string with new one */
|
||||
luaV_concat(L, 2);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** empty the buffer space into the stack
|
||||
*/
|
||||
static void clearbuff (BuffFS *buff) {
|
||||
pushstr(buff, buff->space, buff->blen); /* push buffer contents */
|
||||
buff->blen = 0; /* space now is empty */
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Get a space of size 'sz' in the buffer. If buffer has not enough
|
||||
** space, empty it. 'sz' must fit in an empty buffer.
|
||||
*/
|
||||
static char *getbuff (BuffFS *buff, int sz) {
|
||||
lua_assert(buff->blen <= BUFVFS); lua_assert(sz <= BUFVFS);
|
||||
if (sz > BUFVFS - buff->blen) /* not enough space? */
|
||||
clearbuff(buff);
|
||||
return buff->space + buff->blen;
|
||||
}
|
||||
|
||||
|
||||
#define addsize(b,sz) ((b)->blen += (sz))
|
||||
|
||||
|
||||
/*
|
||||
** Add 'str' to the buffer. If string is larger than the buffer space,
|
||||
** push the string directly to the stack.
|
||||
*/
|
||||
static void addstr2buff (BuffFS *buff, const char *str, size_t slen) {
|
||||
if (slen <= BUFVFS) { /* does string fit into buffer? */
|
||||
char *bf = getbuff(buff, cast_int(slen));
|
||||
memcpy(bf, str, slen); /* add string to buffer */
|
||||
addsize(buff, cast_int(slen));
|
||||
}
|
||||
else { /* string larger than buffer */
|
||||
clearbuff(buff); /* string comes after buffer's content */
|
||||
pushstr(buff, str, slen); /* push string */
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Add a numeral to the buffer.
|
||||
*/
|
||||
static void addnum2buff (BuffFS *buff, TValue *num) {
|
||||
char *numbuff = getbuff(buff, MAXNUMBER2STR);
|
||||
int len = tostringbuff(num, numbuff); /* format number into 'numbuff' */
|
||||
addsize(buff, len);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** this function handles only '%d', '%c', '%f', '%p', '%s', and '%%'
|
||||
conventional formats, plus Lua-specific '%I' and '%U'
|
||||
*/
|
||||
const char *luaO_pushvfstring (lua_State *L, const char *fmt, va_list argp) {
|
||||
BuffFS buff; /* holds last part of the result */
|
||||
const char *e; /* points to next '%' */
|
||||
buff.pushed = buff.blen = 0;
|
||||
buff.L = L;
|
||||
while ((e = strchr(fmt, '%')) != NULL) {
|
||||
addstr2buff(&buff, fmt, e - fmt); /* add 'fmt' up to '%' */
|
||||
switch (*(e + 1)) { /* conversion specifier */
|
||||
case 's': { /* zero-terminated string */
|
||||
const char *s = va_arg(argp, char *);
|
||||
if (s == NULL) s = "(null)";
|
||||
addstr2buff(&buff, s, strlen(s));
|
||||
break;
|
||||
}
|
||||
case 'c': { /* an 'int' as a character */
|
||||
char c = cast_uchar(va_arg(argp, int));
|
||||
addstr2buff(&buff, &c, sizeof(char));
|
||||
break;
|
||||
}
|
||||
case 'd': { /* an 'int' */
|
||||
TValue num;
|
||||
setivalue(&num, va_arg(argp, int));
|
||||
addnum2buff(&buff, &num);
|
||||
break;
|
||||
}
|
||||
case 'I': { /* a 'lua_Integer' */
|
||||
TValue num;
|
||||
setivalue(&num, cast(lua_Integer, va_arg(argp, l_uacInt)));
|
||||
addnum2buff(&buff, &num);
|
||||
break;
|
||||
}
|
||||
case 'f': { /* a 'lua_Number' */
|
||||
TValue num;
|
||||
setfltvalue(&num, cast_num(va_arg(argp, l_uacNumber)));
|
||||
addnum2buff(&buff, &num);
|
||||
break;
|
||||
}
|
||||
case 'p': { /* a pointer */
|
||||
const int sz = 3 * sizeof(void*) + 8; /* enough space for '%p' */
|
||||
char *bf = getbuff(&buff, sz);
|
||||
void *p = va_arg(argp, void *);
|
||||
int len = lua_pointer2str(bf, sz, p);
|
||||
addsize(&buff, len);
|
||||
break;
|
||||
}
|
||||
case 'U': { /* a 'long' as a UTF-8 sequence */
|
||||
char bf[UTF8BUFFSZ];
|
||||
int len = luaO_utf8esc(bf, va_arg(argp, long));
|
||||
addstr2buff(&buff, bf + UTF8BUFFSZ - len, len);
|
||||
break;
|
||||
}
|
||||
case '%': {
|
||||
addstr2buff(&buff, "%", 1);
|
||||
break;
|
||||
}
|
||||
default: {
|
||||
luaG_runerror(L, "invalid option '%%%c' to 'lua_pushfstring'",
|
||||
*(e + 1));
|
||||
}
|
||||
}
|
||||
fmt = e + 2; /* skip '%' and the specifier */
|
||||
}
|
||||
addstr2buff(&buff, fmt, strlen(fmt)); /* rest of 'fmt' */
|
||||
clearbuff(&buff); /* empty buffer into the stack */
|
||||
lua_assert(buff.pushed == 1);
|
||||
return getstr(tsvalue(s2v(L->top.p - 1)));
|
||||
}
|
||||
|
||||
|
||||
const char *luaO_pushfstring (lua_State *L, const char *fmt, ...) {
|
||||
const char *msg;
|
||||
va_list argp;
|
||||
va_start(argp, fmt);
|
||||
msg = luaO_pushvfstring(L, fmt, argp);
|
||||
va_end(argp);
|
||||
return msg;
|
||||
}
|
||||
|
||||
/* }================================================================== */
|
||||
|
||||
|
||||
#define RETS "..."
|
||||
#define PRE "[string \""
|
||||
#define POS "\"]"
|
||||
|
||||
#define addstr(a,b,l) ( memcpy(a,b,(l) * sizeof(char)), a += (l) )
|
||||
|
||||
void luaO_chunkid (char *out, const char *source, size_t srclen) {
|
||||
size_t bufflen = LUA_IDSIZE; /* free space in buffer */
|
||||
if (*source == '=') { /* 'literal' source */
|
||||
if (srclen <= bufflen) /* small enough? */
|
||||
memcpy(out, source + 1, srclen * sizeof(char));
|
||||
else { /* truncate it */
|
||||
addstr(out, source + 1, bufflen - 1);
|
||||
*out = '\0';
|
||||
}
|
||||
}
|
||||
else if (*source == '@') { /* file name */
|
||||
if (srclen <= bufflen) /* small enough? */
|
||||
memcpy(out, source + 1, srclen * sizeof(char));
|
||||
else { /* add '...' before rest of name */
|
||||
addstr(out, RETS, LL(RETS));
|
||||
bufflen -= LL(RETS);
|
||||
memcpy(out, source + 1 + srclen - bufflen, bufflen * sizeof(char));
|
||||
}
|
||||
}
|
||||
else { /* string; format as [string "source"] */
|
||||
const char *nl = strchr(source, '\n'); /* find first new line (if any) */
|
||||
addstr(out, PRE, LL(PRE)); /* add prefix */
|
||||
bufflen -= LL(PRE RETS POS) + 1; /* save space for prefix+suffix+'\0' */
|
||||
if (srclen < bufflen && nl == NULL) { /* small one-line source? */
|
||||
addstr(out, source, srclen); /* keep it */
|
||||
}
|
||||
else {
|
||||
if (nl != NULL) srclen = nl - source; /* stop at first newline */
|
||||
if (srclen > bufflen) srclen = bufflen;
|
||||
addstr(out, source, srclen);
|
||||
addstr(out, RETS, LL(RETS));
|
||||
}
|
||||
memcpy(out, POS, (LL(POS) + 1) * sizeof(char));
|
||||
}
|
||||
}
|
||||
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
x
Reference in New Issue
Block a user