mescc-tools-1.5.2/.gitignore 0000644 0000000 0000000 00000002212 14522760670 012633 0 ustar ## Copyright (C) 2017 Jeremiah Orians
## This file is part of mescc-tools.
##
## mescc-tools is free software: you can redistribute it and/or modify
## it under the terms of the GNU General Public License as published by
## the Free Software Foundation, either version 3 of the License, or
## (at your option) any later version.
##
## mescc-tools is distributed in the hope that it will be useful,
## but WITHOUT ANY WARRANTY; without even the implied warranty of
## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
## GNU General Public License for more details.
##
## You should have received a copy of the GNU General Public License
## along with mescc-tools. If not, see
Added catm NASM prototype to simplify build
Added catm M1 prototype to reduce bootstrap dependency
Added catm hex0 prototype to eliminate bootstrap dependencies down to hex0
Added M0 NASM prototype to simplify build
Added M0 M1 prototype to reduce bootstrap dependency
Added M0 hex2 prototype to eliminate bootstrap dependencies down to hex2
Verified ARM port to support M2-Planet
** Changed
Updated build.sh and kaem.run to the current mescc-tools syntax
Reduced get_machine's build dependencies
Cleaned up x86 elf headers
Removed kaem's dependence on getopt
Replaced --Architecture with --architecture
changed get_machine's default output to filter machine names into known families
Reduced M1 null padding of strings to a single null for all architectures except Knight
Updated AMD64 bootstrap kaem.run to include steps from hex0 to M0
** Fixed
Fixed broken test9 thanks to janneke
Fixed wrong displacement calculations for ARM immediates
Fixed typo in license header
Fixed kaem.run to actually function and produce identical results
Fixed regression caused by linux 4.17
Removed false newline added in numerate_number for zero case
Fixed broken bootstrap script
** Removed
Removed final dependency on getopt
Removed need to know architecture numbers as that was a bad idea
* 0.5 - 2018-06-15
** Added
Added INSTALL notes
Added HACKING notes
Added examples of minimal Hex1, Hex2 and M1-macro programs that may need to be
written to bootstrap a particular architecture.
Added useful functions to reduce bootstrap dependencies
Added support for binary output in M1-macro
** Changed
Changed Knight architecture offset calculation to match new standard
Updated test3 lisp.s to include more functionality
Updated test3 definitions file to reflect changes in Knight instruction encoding
enhanced README to be more useful
Pulled numerate_string functionality out of hex2 and M1 into a shared library
Eliminated getopt from M1-Macro, hex2-linker and blood-elf; use --Architecture 1 instead of --Architecture=1
** Fixed
Corrected M1-macro incorrectly expressing negative numbers
Updated test3 checksum to reflect new version of lisp.s
fixed check.sh to actually perform all checks.
Fixed build.sh to function in a self-hosting fashion
** Removed
Removed blood-elf's dependency on getopt
Removed C preprocessor macro from blood-elf needed for mescc support
Removed hex2's dependency on getopt
Removed C preprocessor macro from hex2 needed for mescc support
Removed need for octal support in the building of hex2
Removed M1's dependency on getopt
Removed C preprocessor macro from M1 needed for mescc support
Removed need for sprintf from M1
* 0.4 - 2018-02-24
** Added
Added file checks to reduce the number of error messageless faults
Added a current generation M1.M1 file as a test for mescc-tools
Added prototype kaem build script
M1-macro now catches undefined macros to allow easier troubleshooting
Added kaem build tool
Added ability to track build progress in kaem
Added support for line escapes in kaem
Added support for --strict in kaem to halt in the event of errors
Added selectable script file support in kaem
Added support for PATH search to kaem with fallbacks in the event of NULL environments
** Changed
flipped blood-elf from ignoring :: to :_
converted test8 into a full test
Added bash style line comments to kaem
Added support for raw strings to kaem
Stopped showing comment lines in kaem --verbose
Removed dependence on getenv to have more control over environmental lookup
** Fixed
Fixed stack overflow bug caused by too deeply nested recursion by transforming into iteration
Fixed default repo to point to current repo
Added missing license header to kaem.c
Fixed infinite looping in kaem scripts that hit an error that resets the file descriptor
** Removed
Removed need for strtol
Removed need for a global variable in M1-Macro
Removed legacy functions from kaem
* 0.3 - 2017-12-01
** Added
Incorporated a hex0 test which implements hex1 functionality
Added --output and --exec_enable options to hex2
Added --output option to M1
Wrote Hex1 in Hex0 for AMD64/ELF
Added the ability to specify an output file
Added exec_enable to allow the arbitrary setting of executable bits
Added get_machine to enable better scripting
Incorporated janneke's build scripts
Added a test to test for unusual nybble and byte order/formatting issues
Added blood-elf to generate elf footer capable of being used by objdump
** Changed
Renamed MESCC_Tools to mescc-tools to harmonize with guix package name
Now all tests will be architecture specific
Modified sprintf to behave correctly for negative numbers
Converted blood-elf to read M1-macro input and output M1-macro output
replaced uint with unsigned to better match the standard
Harmonized MAXSTRING to 4096bytess
** Fixed
Incorporated janneke's patchs to fix mescc compatibility
Fixed test on ARM platforms
Fixed range check to behave correctly with unsigned ints
** Removed
Removed the need to redirect hex2 output into a file
Removed the need for chmod u+x in development paths
Removed the need to redirect M1 output into a file
Removed the need for chmod entirely from bootstrap path
Removed dependency on shell supporting redirects
Removed need for stdint and stdbool
Removed need for enum support
Removed need for strtol in M1-macro
* 0.2 - 2017-07-25
** Added
created test2 (a 32bit x86 hex assembler) with its associated build and test changes
Fixed proof answers for test1 and test2
Added support to M0 for multiple architectures
Added range checking into M0 to make sure immediates will fit into specified space
Added a basic tutorial for generating new M0 definitions
Created a M1 compatible version of test0
Added an amd64 program for enabling execute bits (might need to later alter the 0777)
Added an i386 program for enabling execute bits (might need to later alter the 0777)
Added rain1's improvements to gcc flags
Added rain1's stack reduction recommendations
Incorporated an AMD64/elf hex1 example program as a test
Incorporated Test7 into make test and make clean flows
** Changed
Adjusted tags to reflect current CHANGELOG
Make test now depends upon test2 completing
Changed how M0 processes input to reduce stack usage and improve performance
Renamed M0 to M1 to reflect the additional functionality it provides
Applied Janneke's patch for accepting hex numerics in M1
Refactored x86/amd64 elf headers to a standard to avoid duplication
Standardized C flags for compiling M1 and Hex2
Made eval_immediates iterative instead of recursive
Made identify_macros iterative instead of recursive
Made process_string iterative instead of recursive
Made preserve_other iterative instead of recursive
Made print_hex iterative instead of recursive
Incremented version numbers for hex2 and M1
Updated guix.scm to match the new version and finish the release
Converted guix.scm definition for mescc_tools to use uri method instead of git
** Fixed
Removed unrequired temp file in test1
Clarified meaning of Label>base displacement conditional
Corrected error in test0 elf32
Test1 and Test2 to reflect the fact that /bin/bash doesn't exist in guix
Fixed M0 regression to continue to support original test code
Corrected makefile and build scripts to reflect rename
Modified test make scripts to reflect new standard elf headers
Fixed base address needed by test5 and its associated checksum
Harmonized flags for displaying version with standard
** Removed
Removed bashisms from Test1 and Test2 to allow proper behavior on debian based systems
Removed alerting on missing files in cleanup target
Removed massive M0 Definition lists as they don't serve a useful purpose
* 0.1 - 2017-06-25
** Added
Incorporated support for little Endian output format in hex2
Incorporated support for multiple input files in hex2
Added range checking for Hex2
Added support for 1 and 4 byte relative displacements
Added Hex2 Test
Added the ability to specify a new base address
Added example M0 x86 opcode definitions
Incorporated support for multiple input files in M0
Added support for little Endian immediate output in M0
Added Hex assembler example test
Added support for Label>base in Hex2
Added Version info
Added install target
Added inital guix package definition
** Changed
Displacement calculations are now based on architecture specific rules
M0 Immediates now need prefixes to specify the storage space to use for the immediate
** Fixed
Behavior regarding !label displacements
** Removed
* 0.0 - 2017-05-10
Initial release of MESCC Tools from stage0 High Level prototypes
mescc-tools-1.5.2/COPYING 0000644 0000000 0000000 00000104513 14522760670 011705 0 ustar GNU GENERAL PUBLIC LICENSE
Version 3, 29 June 2007
Copyright (C) 2007 Free Software Foundation, Inc.
Copyright (C)
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see Copyright (C)
This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
This is free software, and you are welcome to redistribute it
under certain conditions; type `show c' for details.
The hypothetical commands `show w' and `show c' should show the appropriate
parts of the General Public License. Of course, your program's commands
might be different; for a GUI interface, you would use an "about box".
You should also get your employer (if you work as a programmer) or school,
if any, to sign a "copyright disclaimer" for the program, if necessary.
For more information on this, and how to apply and follow the GNU GPL, see
.
mescc-tools-1.5.2/Generating_M0_Definitions.org 0000644 0000000 0000000 00000025526 14522760670 016343 0 ustar * License
## Copyright (C) 2017 Jeremiah Orians
## This file is part of mescc-tools.
##
## mescc-tools is free software: you can redistribute it and/or modify
## it under the terms of the GNU General Public License as published by
## the Free Software Foundation, either version 3 of the License, or
## (at your option) any later version.
##
## mescc-tools is distributed in the hope that it will be useful,
## but WITHOUT ANY WARRANTY; without even the implied warranty of
## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
## GNU General Public License for more details.
##
## You should have received a copy of the GNU General Public License
## along with mescc-tools. If not, see :
8048074: 30 31 xor %dh,(%ecx)
8048076: 32 33 xor (%ebx),%dh
8048078: 34 35 xor $0x35,%al
804807a: 36 37 ss aaa
804807c: 38 39 cmp %bh,(%ecx)
804807e: 41 inc %ecx
804807f: 42 inc %edx
8048080: 43 inc %ebx
8048081: 44 inc %esp
8048082: 45 inc %ebp
8048083: 46 inc %esi
8048084: 0a .byte 0xa
08048085 :
8048085: ba 01 00 00 00 mov $0x1,%edx
804808a: 89 c1 mov %eax,%ecx
804808c: bb 01 00 00 00 mov $0x1,%ebx
8048091: b8 04 00 00 00 mov $0x4,%eax
8048096: cd 80 int $0x80
8048098: c3 ret
08048099 :
8048099: ba 01 00 00 00 mov $0x1,%edx
804809e: b9 f3 90 04 08 mov $0x80490f3,%ecx
80480a3: bb 00 00 00 00 mov $0x0,%ebx
80480a8: b8 03 00 00 00 mov $0x3,%eax
80480ad: cd 80 int $0x80
80480af: 85 c0 test %eax,%eax
80480b1: 74 34 je 80480e7
80480b3: a0 f3 90 04 08 mov 0x80490f3,%al
80480b8: 0f b6 c0 movzbl %al,%eax
80480bb: c3 ret
080480bc <_start>:
80480bc: e8 d8 ff ff ff call 8048099
80480c1: 89 c6 mov %eax,%esi
80480c3: 89 c5 mov %eax,%ebp
80480c5: c1 ee 04 shr $0x4,%esi
80480c8: 83 e5 0f and $0xf,%ebp
80480cb: 81 c6 74 80 04 08 add $0x8048074,%esi
80480d1: 81 c5 74 80 04 08 add $0x8048074,%ebp
80480d7: 89 f0 mov %esi,%eax
80480d9: e8 a7 ff ff ff call 8048085
80480de: 89 e8 mov %ebp,%eax
80480e0: e8 a0 ff ff ff call 8048085
80480e5: eb d5 jmp 80480bc <_start>
080480e7 :
80480e7: bb 00 00 00 00 mov $0x0,%ebx
80480ec: b8 01 00 00 00 mov $0x1,%eax
80480f1: cd 80 int $0x80
** making sense of the objdump information
*** Labels
When you see 08048074 :
It indicates that at address 0x08048074 the definition of the function output resides.
*** 1OP Instructions
When you see 8048098: c3 ret
It indicates that at address 0x8048098 there is a Return instruction which as the Hex opcode encoding of C3 and could be implemented in M1 as:
DEFINE RETURN C3
Or any other mnemonic term that is more optimal for the problem at hand.
*** 2OP Instructions
When you see 80480c1: 89 c6 mov %eax,%esi
It indicate that at address 0x80480C1 there is a Move instruction that copies the value of register eax to register esi and has the Hex opcode encoding of 89C6 and therefor can be defined in M1 as:
DEFINE COPY_EAX_To_ESI 89C6
or
If we assume (eax=>R0, ebx=>R1, ecx=>R2, edx=>R3, esi=>R4, edi=>R5, ebp=>R6, and esp=>R7)
DEFINE COPY_R0_To_R4 89C6
*** Instructions with Immediates or displacements
Immediates occur in variable sizes but an immediate can not exist without an instruction
**** Trivial example
Most immediates are common values such as 1 (01) or -1 (FF..FF) that are immediately obvious:
80480a8: b8 03 00 00 00 mov $0x3,%eax
8048091: b8 04 00 00 00 mov $0x4,%eax
80480ec: b8 01 00 00 00 mov $0x1,%eax
Espcially when there is a very familiar pattern and leading (or in x86's case trailing zeros)
It should be immediately obvious that B8 is the opcode for loading a 32bit immediate value into eax, which can be written in M1 as:
DEFINE MOV_Immediate32_EAX B8
or
DEFINE LOADI32_R0 B8
You only need to remember to follow that mnemonic with a 32bit immediate (%4 works)
**** Easy example
For some immediate instructions the size and placement of the immediate is obvious (or perhaps obvious once you realize the Endianness of the instruction set you are working with)
For example:
80480b3: a0 f3 90 04 08 mov 0x80490f3,%al
Knowing that x86 is little endian, the 08 should pop out at you.
f3 90 04 08 is the little endian encoding of the number 0x080490F3
and thus we know that the opcode is A0 and it requires a 32bit value (An absolute address) and that it writes that result to al (which is the bottom 8bits of the eax register)
Thus we can express this opcode as:
DEFINE MOV_Absolute32_al A0
or
LOAD8_R0_Absolute32 A0
Which then always has to be followed by a 32bit absolute address ($foo works)
**** Annoying example
For some instructions, you may have to lookup the opcode to determine its length and thus the length of its immediate such as:
80480b1: 74 34 je 80480e7
Which when confronted with such a case, simply lookup the 74 in http://ref.x86asm.net/coder32.html
thus resolving to it is both jz and je and it takes a 8bit relative address (the 34).
Thus we can define our newly determined opcode in M1 as:
DEFINE JE8 74
DEFINE JZ8 74
or
DEFINE Jump_if_Zero8 74
but we need to make sure that whenever we use our mnemonic we follow it with a 8bit relative value (!label works well)
*** Things objdump gets wrong
The thing all disassemblers tend to get wrong and dependes entirely on heuristics is the identification of strings and byte constants.
In our case, it has identified our table as a set of instructions (also correctly determined their representation)
08048074 :
8048074: 30 31 xor %dh,(%ecx)
8048076: 32 33 xor (%ebx),%dh
8048078: 34 35 xor $0x35,%al
804807a: 36 37 ss aaa
804807c: 38 39 cmp %bh,(%ecx)
804807e: 41 inc %ecx
804807f: 42 inc %edx
8048080: 43 inc %ebx
8048081: 44 inc %esp
8048082: 45 inc %ebp
8048083: 46 inc %esi
8048084: 0a .byte 0xa
In M1 we have the ability to do things like strings to store such a table.
Which would probably be the following:
:output
"0123456789ABCDEF"
Which certainly alot easier to read and understand than
output: .byte 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x0A
* Using that opcode information to write a M1 program
Thus we would come to a defintion list that looks something like this:
DEFINE MOVZBL_al_To_eax 0FB6C0
DEFINE JE8 74
DEFINE ADD_Immediate32_To_ebp 81C5
DEFINE ADD_Immediate32_To_esi 81C6
DEFINE ANDI8_ebp 83E5
DEFINE TEST_eax_eax 85C0
DEFINE MOV_eax_To_ecx 89C1
DEFINE MOV_eax_To_ebp 89C5
DEFINE MOV_eax_To_esi 89C6
DEFINE MOV_ebp_To_eax 89E8
DEFINE MOV_esi_To_eax 89F0
DEFINE LOAD8_al A0
DEFINE LOADI32_eax B8
DEFINE LOADI32_ecx B9
DEFINE LOADI32_edx BA
DEFINE LOADI32_ebx BB
DEFINE SHIFT_RIGHT_Immediate8_esi C1EE
DEFINE RETURN C3
DEFINE INT_80 CD80
DEFINE CALLI32 E8
DEFINE JUMP8 EB
** emacs tips
Using the objdump output, first clear the labels and not instruction data.
Then leverage C-x ( and C-x ) to define a keyboard macro that deletes the address from the start of the line. C-x e followed by e repeatedly to clear all of the lines.
M-x sort-lines, will sort all selected lines (very useful as now all instructions with the same opcode are next to each other for easy pruning)
M-x delete-duplicate-lines will purge all exact duplicates (very handy for compiler output)
Then all that remains is determining the immediates and figuring out what line actually does. This is left as an exercise for the reader.
mescc-tools-1.5.2/HACKING 0000644 0000000 0000000 00000005310 14522760670 011634 0 ustar -*-mode:org-*-
## Copyright (C) 2017 Jeremiah Orians
## This file is part of mescc-tools.
##
## mescc-tools is free software: you can redistribute it and/or modify
## it under the terms of the GNU General Public License as published by
## the Free Software Foundation, either version 3 of the License, or
## (at your option) any later version.
##
## mescc-tools is distributed in the hope that it will be useful,
## but WITHOUT ANY WARRANTY; without even the implied warranty of
## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
## GNU General Public License for more details.
##
## You should have received a copy of the GNU General Public License
## along with mescc-tools. If not, see
#include
#include
#include
#include
#include "kaem.h"
/* Prototypes from other files */
void handle_variables(char** argv, struct Token* n);
/*
* UTILITY FUNCTIONS
*/
/* Function to find a character in a string */
char* find_char(char* string, char a)
{
if(0 == string[0])
{
return NULL;
}
while(a != string[0])
{
string = string + 1;
if(0 == string[0])
{
return string;
}
}
return string;
}
/* Function to find the length of a char**; an array of strings */
int array_length(char** array)
{
int length = 0;
while(array[length] != NULL)
{
length = length + 1;
}
return length;
}
/* Search for a variable in the token linked-list */
char* token_lookup(char* variable, struct Token* token)
{
/* Start at the head */
struct Token* n = token;
/* Loop over the linked-list */
while(n != NULL)
{
if(match(variable, n->var))
{
/* We have found the correct node */
return n->value; /* Done */
}
/* Nope, try the next */
n = n->next;
}
/* We didn't find anything! */
return NULL;
}
/* Search for a variable in the env linked-list */
char* env_lookup(char* variable)
{
return token_lookup(variable, env);
}
/* Search for a variable in the alias linked-list */
char* alias_lookup(char* variable)
{
return token_lookup(variable, alias);
}
/* Find the full path to an executable */
char* find_executable(char* name)
{
if(match("", name))
{
return NULL;
}
if(('.' == name[0]) || ('/' == name[0]))
{
/* assume names that start with . or / are relative or absolute */
return name;
}
char* trial = calloc(MAX_STRING, sizeof(char));
char* MPATH = calloc(MAX_STRING, sizeof(char)); /* Modified PATH */
require(MPATH != NULL, "Memory initialization of MPATH in find_executable failed\n");
strcpy(MPATH, PATH);
FILE* t;
char* next = find_char(MPATH, ':');
int index;
int offset;
int mpath_length;
int name_length;
int trial_length;
while(NULL != next)
{
/* Reset trial */
trial_length = strlen(trial);
for(index = 0; index < trial_length; index = index + 1)
{
trial[index] = 0;
}
next[0] = 0;
/* prepend_string(MPATH, prepend_string("/", name)) */
mpath_length = strlen(MPATH);
for(index = 0; index < mpath_length; index = index + 1)
{
require(MAX_STRING > index, "Element of PATH is too long\n");
trial[index] = MPATH[index];
}
trial[index] = '/';
offset = strlen(trial);
name_length = strlen(name);
for(index = 0; index < name_length; index = index + 1)
{
require(MAX_STRING > index, "Element of PATH is too long\n");
trial[index + offset] = name[index];
}
/* Try the trial */
require(strlen(trial) < MAX_STRING, "COMMAND TOO LONG!\nABORTING HARD\n");
t = fopen(trial, "r");
if(NULL != t)
{
fclose(t);
return trial;
}
MPATH = next + 1;
next = find_char(MPATH, ':');
}
return NULL;
}
/* Function to convert a Token linked-list into an array of strings */
char** list_to_array(struct Token* s)
{
struct Token* n;
n = s;
char** array = calloc(MAX_ARRAY, sizeof(char*));
require(array != NULL, "Memory initialization of array in conversion of list to array failed\n");
char* element = calloc(MAX_STRING, sizeof(char));
require(element != NULL, "Memory initialization of element in conversion of list to array failed\n");
int index = 0;
int i;
int value_length;
int var_length;
int offset;
while(n != NULL)
{
/* Loop through each node and assign it to an array index */
array[index] = calloc(MAX_STRING, sizeof(char));
require(array[index] != NULL, "Memory initialization of array[index] in conversion of list to array failed\n");
/* Bounds checking */
/* No easy way to tell which it is, output generic message */
require(index < MAX_ARRAY, "SCRIPT TOO LONG or TOO MANY ENVARS\nABORTING HARD\n");
if(n->var == NULL)
{
/* It is a line */
array[index] = n->value;
}
else
{
/* It is a var */
/* prepend_string(n->var, prepend_string("=", n->value)) */
var_length = strlen(n->var);
for(i = 0; i < var_length; i = i + 1)
{
element[i] = n->var[i];
}
element[i] = '=';
i = i + 1;
offset = i;
value_length = strlen(n->value);
for(i = 0; i < value_length; i = i + 1)
{
element[i + offset] = n->value[i];
}
}
/* Insert elements if not empty */
if(!match("", element))
{
strcpy(array[index], element);
}
n = n->next;
index = index + 1;
/* Reset element */
for(i = 0; i < MAX_STRING; i = i + 1)
{
element[i] = 0;
}
}
return array;
}
/* Function to handle the correct options for escapes */
int handle_escape(int c)
{
if(c == '\n')
{
/* Do nothing - eat up the newline */
return -1;
}
else if('n' == c)
{
/* Add a newline to the token */
return '\n';
}
else if('r' == c)
{
/* Add a return to the token */
return '\r';
}
else if('\\' == c)
{
/* Add a real backslash to the token */
return '\\';
}
else
{
/* Just add it to the token (eg, quotes) */
return c;
}
}
/*
* TOKEN COLLECTION FUNCTIONS
*/
/* Function for skipping over line comments */
void collect_comment(FILE* input)
{
int c;
/* Eat up the comment, one character at a time */
/*
* Sanity check that the comment ends with \n.
* Remove the comment from the FILE*
*/
do
{
c = fgetc(input);
/* We reached an EOF!! */
require(EOF != c, "IMPROPERLY TERMINATED LINE COMMENT!\nABORTING HARD\n");
} while('\n' != c); /* We can now be sure it ended with \n -- and have purged the comment */
}
/* Function for collecting strings and removing the "" pair that goes with them */
int collect_string(FILE* input, char* n, int index)
{
int string_done = FALSE;
int c;
do
{
/* Bounds check */
require(MAX_STRING > index, "LINE IS TOO LONG\nABORTING HARD\n");
c = fgetc(input);
require(EOF != c, "IMPROPERLY TERMINATED STRING!\nABORTING HARD\n");
if('\\' == c)
{
/* We are escaping the next character */
/* This correctly handles escaped quotes as it just returns the quote */
c = fgetc(input);
c = handle_escape(c);
n[index] = c;
index = index + 1;
}
else if('"' == c)
{
/* End of string */
string_done = TRUE;
}
else
{
n[index] = c;
index = index + 1;
}
} while(string_done == FALSE);
return index;
}
/* Function to parse and assign token->value */
int collect_token(FILE* input, char* n, int last_index)
{
int c;
int cc;
int token_done = FALSE;
int index = 0;
do
{
/* Loop over each character in the token */
c = fgetc(input);
/* Bounds checking */
require(MAX_STRING > index, "LINE IS TOO LONG\nABORTING HARD\n");
if(EOF == c)
{
/* End of file -- this means script complete */
/* We don't actually exit here. This logically makes more sense;
* let the code follow its natural path of execution and exit
* sucessfuly at the end of main().
*/
token_done = TRUE;
command_done = TRUE;
return -1;
}
else if((' ' == c) || ('\t' == c))
{
/* Space and tab are token separators */
token_done = TRUE;
}
else if(('\n' == c) || (';' == c))
{
/* Command terminates at the end of a line or at semicolon */
command_done = TRUE;
token_done = TRUE;
if(0 == index)
{
index = last_index;
}
}
else if('"' == c)
{
/* Handle strings -- everything between a pair of "" */
index = collect_string(input, n, index);
token_done = TRUE;
}
else if('#' == c)
{
/* Handle line comments */
collect_comment(input);
command_done = TRUE;
token_done = TRUE;
if(0 == index)
{
index = last_index;
}
}
else if('\\' == c)
{
/* Support for escapes */
c = fgetc(input); /* Skips over \, gets the next char */
cc = handle_escape(c);
if(-1 != cc)
{
/* We need to put it into the token */
n[index] = cc;
}
index = index + 1;
}
else if(0 == c)
{
/* We have come to the end of the token */
token_done = TRUE;
}
else
{
/* It's a character to assign */
n[index] = c;
index = index + 1;
}
} while(token_done == FALSE);
return index;
}
/* Function to parse string and assign token->value */
int collect_alias_token(char* input, char* n, int index)
{
int c;
int cc;
int token_done = FALSE;
int output_index = 0;
do
{
/* Loop over each character in the token */
c = input[index];
index = index + 1;
if((' ' == c) || ('\t' == c))
{
/* Space and tab are token separators */
token_done = TRUE;
}
else if('\\' == c)
{
/* Support for escapes */
c = input[index];
index = index + 1;
cc = handle_escape(c);
/* We need to put it into the token */
n[output_index] = cc;
output_index = output_index + 1;
}
else if(0 == c)
{
/* We have come to the end of the token */
token_done = TRUE;
index = 0;
}
else
{
/* It's a character to assign */
n[output_index] = c;
output_index = output_index + 1;
}
} while(token_done == FALSE);
/* Terminate the output with a NULL */
n[output_index] = 0;
return index;
}
/*
* EXECUTION FUNCTIONS
* Note: All of the builtins return SUCCESS (0) when they exit successfully
* and FAILURE (1) when they fail.
*/
/* Function to check if the token is an envar */
int is_envar(char* token)
{
int i = 0;
int token_length = strlen(token);
while(i < token_length)
{
if(token[i] == '=')
{
return FAILURE;
}
i = i + 1;
}
return SUCCESS;
}
/* Add an envar */
void add_envar()
{
/* Pointers to strings we want */
char* name = calloc(strlen(token->value) + 4, sizeof(char));
char* value = token->value;
char* newvalue;
int i = 0;
/* Isolate the name */
while('=' != value[i])
{
name[i] = value[i];
i = i + 1;
}
/* Isolate the value */
newvalue = name + i + 2;
value = value + i + 1;
i = 0;
require(0 != value[i], "add_envar received improper variable\n");
while(0 != value[i])
{
newvalue[i] = value[i];
i = i + 1;
}
/* If we are in init-mode and this is the first var env == NULL, rectify */
if(env == NULL)
{
env = calloc(1, sizeof(struct Token));
require(env != NULL, "Memory initialization of env failed\n");
env->var = name; /* Add our first variable */
}
/*
* If the name of the envar is PATH, then we need to set our (internal)
* global PATH value.
*/
if(match(name, "PATH"))
{
strcpy(PATH, newvalue);
}
struct Token* n = env;
/* Find match if possible */
while(!match(name, n->var))
{
if(NULL == n->next)
{
n->next = calloc(1, sizeof(struct Token));
require(n->next != NULL, "Memory initialization of next env node in add_envar failed\n");
n->next->var = name;
} /* Loop will match and exit */
n = n->next;
}
/* Since we found the variable we need only to set it to its new value */
n->value = newvalue;
}
/* Add an alias */
void add_alias()
{
token = token->next; /* Skip the actual alias */
if(token->next == NULL)
{
/* No arguments */
char** array = list_to_array(alias);
int index = 0;
while(array[index] != NULL) {
fputs(array[index], stdout);
fputc('\n', stdout);
index = index + 1;
}
fflush(stdout);
return;
}
if(!is_envar(token->value)) {
char** array = list_to_array(token);
int index = 0;
while(array[index] != NULL) {
fputs(array[index], stdout);
fputc(' ', stdout);
index = index + 1;
}
fputc('\n', stdout);
fflush(stdout);
return;
}
/* Pointers to strings we want */
char* name = calloc(strlen(token->value) + 4, sizeof(char));
char* value = token->value;
char* newvalue;
int i = 0;
/* Isolate the name */
while('=' != value[i])
{
name[i] = value[i];
i = i + 1;
}
/* Isolate the value */
newvalue = name + i + 2;
value = value + i + 1;
i = 0;
require(0 != value[i], "add_alias received improper variable\n");
while(0 != value[i])
{
newvalue[i] = value[i];
i = i + 1;
}
/* If this is the first alias, rectify */
if(alias == NULL)
{
alias = calloc(1, sizeof(struct Token));
require(alias != NULL, "Memory initialization of alias failed\n");
alias->var = name; /* Add our first variable */
}
struct Token* n = alias;
/* Find match if possible */
while(!match(name, n->var))
{
if(NULL == n->next)
{
n->next = calloc(1, sizeof(struct Token));
require(n->next != NULL, "Memory initialization of next alias node in alias failed\n");
n->next->var = name;
} /* Loop will match and exit */
n = n->next;
}
/* Since we found the variable we need only to set it to its new value */
n->value = newvalue;
}
/* cd builtin */
int cd()
{
if(NULL == token->next)
{
return FAILURE;
}
token = token->next;
if(NULL == token->value)
{
return FAILURE;
}
int ret = chdir(token->value);
if(0 > ret)
{
return FAILURE;
}
return SUCCESS;
}
/* pwd builtin */
int pwd()
{
char* path = calloc(MAX_STRING, sizeof(char));
require(path != NULL, "Memory initialization of path in pwd failed\n");
getcwd(path, MAX_STRING);
require(!match("", path), "getcwd() failed\n");
fputs(path, stdout);
fputs("\n", stdout);
return SUCCESS;
}
/* set builtin */
int set()
{
/* Get the options */
int i;
if(NULL == token->next)
{
goto cleanup_set;
}
token = token->next;
if(NULL == token->value)
{
goto cleanup_set;
}
char* options = calloc(MAX_STRING, sizeof(char));
require(options != NULL, "Memory initialization of options in set failed\n");
int last_position = strlen(token->value) - 1;
for(i = 0; i < last_position; i = i + 1)
{
options[i] = token->value[i + 1];
}
/* Parse the options */
int options_length = strlen(options);
for(i = 0; i < options_length; i = i + 1)
{
if(options[i] == 'a')
{
/* set -a is on by default and cannot be disabled at this time */
if(WARNINGS)
{
fputs("set -a is on by default and cannot be disabled\n", stdout);
}
continue;
}
else if(options[i] == 'e')
{
/* Fail on failure */
STRICT = TRUE;
}
else if(options[i] == 'x')
{
/* Show commands as executed */
/* TODO: this currently behaves like -v. Make it do what it should */
VERBOSE = TRUE;
/*
* Output the set -x because VERBOSE didn't catch it before.
* We don't do just -x because we support multiple options in one command,
* eg set -ex.
*/
fputs(" +> set -", stdout);
fputs(options, stdout);
fputs("\n", stdout);
fflush(stdout);
}
else
{
/* Invalid */
fputc(options[i], stderr);
fputs(" is an invalid set option!\n", stderr);
exit(EXIT_FAILURE);
}
}
return SUCCESS;
cleanup_set:
return FAILURE;
}
/* echo builtin */
void echo()
{
if(token->next == NULL)
{
/* No arguments */
fputs("\n", stdout);
return;
}
if(token->next->value == NULL)
{
/* No arguments */
fputs("\n", stdout);
return;
}
token = token->next; /* Skip the actual echo */
while(token != NULL)
{
/* Output each argument to echo to stdout */
if(token->value == NULL)
{
break;
}
fputs(token->value, stdout);
if(NULL != token->next)
{
/* M2-Planet doesn't short circuit */
if(NULL != token->next->value) fputc(' ', stdout);
}
token = token->next;
}
fputs("\n", stdout);
}
/* unset builtin */
void unset()
{
struct Token* e;
/* We support multiple variables on the same line */
struct Token* t;
for(t = token->next; t != NULL; t = t->next)
{
if(NULL == t->value)
{
continue;
}
e = env;
/* Look for the variable; we operate on ->next because we need to remove ->next */
while(e->next != NULL)
{
if(match(e->next->var, t->value))
{
break;
}
e = e->next;
}
if(e->next != NULL)
{
/* There is something to unset */
e->next = e->next->next;
}
}
}
void execute(FILE* script, char** argv);
int _execute(FILE* script, char** argv);
int collect_command(FILE* script, char** argv);
/* if builtin */
void if_cmd(FILE* script, char** argv)
{
int index;
int old_VERBOSE;
token = token->next; /* Skip the actual if */
/* Do not check for successful exit status */
int if_status = _execute(script, argv);
old_VERBOSE = VERBOSE;
VERBOSE = VERBOSE && !if_status;
do
{
index = collect_command(script, argv);
require(index != -1, "Unexpected EOF, improperly terminated if statement.\n");
if(0 == index)
{
continue;
}
if(0 == if_status)
{
/* Stuff to exec */
execute(script, argv);
}
if(match(token->value, "else"))
{
if_status = !if_status;
}
} while(!match(token->value, "fi"));
VERBOSE = old_VERBOSE;
}
int what_exit(char* program, int status)
{
/***********************************************************************************
* If the low-order 8 bits of w_status are equal to 0x7F or zero, the child *
* process has stopped. If the low-order 8 bits of w_status are non-zero and are *
* not equal to 0x7F, the child process terminated due to a signal otherwise, the *
* child process terminated due to an exit() call. *
* *
* In the event it was a signal that stopped the process the top 8 bits of *
* w_status contain the signal that caused the process to stop. *
* *
* In the event it was terminated the bottom 7 bits of w_status contain the *
* terminating error number for the process. *
* *
* If bit 0x80 of w_status is set, a core dump was produced. *
***********************************************************************************/
int WIFEXITED = !(status & 0x7F);
int WEXITSTATUS = (status & 0xFF00) >> 8;
int WTERMSIG = status & 0x7F;
int WCOREDUMP = status & 0x80;
int WIFSIGNALED = !((0x7F == WTERMSIG) || (0 == WTERMSIG));
int WIFSTOPPED = ((0x7F == WTERMSIG) && (0 == WCOREDUMP));
if(WIFEXITED)
{
if(VERBOSE_EXIT)
{
fputc('\n', stderr);
fputs(program, stderr);
fputs(" normal termination, exit status = ", stderr);
fputs(int2str(WEXITSTATUS, 10, TRUE), stderr);
fputs("\n\n\n", stderr);
}
return WEXITSTATUS;
}
else if (WIFSIGNALED)
{
fputc('\n', stderr);
fputs(program, stderr);
fputs(" abnormal termination, signal number = ", stderr);
fputs(int2str(WTERMSIG, 10, TRUE), stderr);
fputc('\n', stderr);
if(WCOREDUMP) fputs("core dumped\n", stderr);
return WTERMSIG;
}
else if(WIFSTOPPED)
{
fputc('\n', stderr);
fputs(program, stderr);
fputs(" child stopped, signal number = ", stderr);
fputs(int2str(WEXITSTATUS, 10, TRUE), stderr);
fputc('\n', stderr);
return WEXITSTATUS;
}
fputc('\n', stderr);
fputs(program, stderr);
fputs(" :: something crazy happened with execve\nI'm just gonna get the hell out of here\n", stderr);
exit(EXIT_FAILURE);
}
/* Execute program and check for error */
void execute(FILE* script, char** argv)
{
int status = _execute(script, argv);
if(STRICT == TRUE && (0 != status))
{
/* Clearly the script hit an issue that should never have happened */
fputs("Subprocess error ", stderr);
fputs(int2str(status, 10, TRUE), stderr);
fputs("\nABORTING HARD\n", stderr);
exit(EXIT_FAILURE);
}
}
/* Execute program */
int _execute(FILE* script, char** argv)
{
/* Run the command */
/* rc = return code */
int rc;
/* exec without forking */
int exec = FALSE;
/* Actually do the execution */
if(is_envar(token->value) == TRUE)
{
add_envar();
return 0;
}
else if(match(token->value, "cd"))
{
rc = cd();
if(STRICT)
{
require(rc == SUCCESS, "cd failed!\n");
}
return 0;
}
else if(match(token->value, "set"))
{
rc = set();
if(STRICT)
{
require(rc == SUCCESS, "set failed!\n");
}
return 0;
}
else if(match(token->value, "alias"))
{
add_alias();
return 0;
}
else if(match(token->value, "pwd"))
{
rc = pwd();
if(STRICT)
{
require(rc == SUCCESS, "pwd failed!\n");
}
return 0;
}
else if(match(token->value, "echo"))
{
echo();
return 0;
}
else if(match(token->value, "unset"))
{
unset();
return 0;
}
else if(match(token->value, "exec"))
{
token = token->next; /* Skip the actual exec */
exec = TRUE;
}
else if(match(token->value, "if"))
{
if_cmd(script, argv);
return 0;
}
else if(match(token->value, "then"))
{
/* ignore */
return 0;
}
else if(match(token->value, "else"))
{
/* ignore */
return 0;
}
else if(match(token->value, "fi"))
{
/* ignore */
return 0;
}
/* If it is not a builtin, run it as an executable */
int status; /* i.e. return code */
char** array;
char** envp;
/* Get the full path to the executable */
char* program = find_executable(token->value);
/* Check we can find the executable */
if(NULL == program)
{
if(STRICT == TRUE)
{
fputs("WHILE EXECUTING ", stderr);
fputs(token->value, stderr);
fputs(" NOT FOUND!\nABORTING HARD\n", stderr);
exit(EXIT_FAILURE);
}
/* If we are not strict simply return */
return 0;
}
int f = 0;
#ifdef __uefi__
array = list_to_array(token);
envp = list_to_array(env);
return spawn(program, array, envp);
#else
if(!exec)
{
f = fork();
}
/* Ensure fork succeeded */
if(f == -1)
{
fputs("WHILE EXECUTING ", stderr);
fputs(token->value, stderr);
fputs(" fork() FAILED\nABORTING HARD\n", stderr);
exit(EXIT_FAILURE);
}
else if(f == 0)
{
/* Child */
/**************************************************************
* Fuzzing produces random stuff; we don't want it running *
* dangerous commands. So we just don't execve. *
* But, we still do the list_to_array calls to check for *
* segfaults. *
**************************************************************/
array = list_to_array(token);
envp = list_to_array(env);
if(FALSE == FUZZING)
{
/* We are not fuzzing */
/* execve() returns only on error */
execve(program, array, envp);
}
/* Prevent infinite loops */
_exit(EXIT_FAILURE);
}
/* Otherwise we are the parent */
/* And we should wait for it to complete */
waitpid(f, &status, 0);
return what_exit(program, status);
#endif
}
int collect_command(FILE* script, char** argv)
{
command_done = FALSE;
/* Initialize token */
struct Token* n;
n = calloc(1, sizeof(struct Token));
require(n != NULL, "Memory initialization of token in collect_command failed\n");
char* s = calloc(MAX_STRING, sizeof(char));
require(s != NULL, "Memory initialization of token in collect_command failed\n");
token = n;
int index = 0;
int alias_index;
char* alias_string;
/* Get the tokens */
while(command_done == FALSE)
{
index = collect_token(script, s, index);
/* Don't allocate another node if the current one yielded nothing, OR
* if we are done.
*/
if(match(s, ""))
{
continue;
}
alias_string = alias_lookup(s);
alias_index = 0;
do
{
if(alias_string != NULL)
{
alias_index = collect_alias_token(alias_string, s, alias_index);
}
/* add to token */
n->value = s;
s = calloc(MAX_STRING, sizeof(char));
require(s != NULL, "Memory initialization of next token node in collect_command failed\n");
/* Deal with variables */
handle_variables(argv, n);
/* If the variable expands into nothing */
if(match(n->value, " "))
{
n->value = NULL;
continue;
}
/* Prepare for next loop */
n->next = calloc(1, sizeof(struct Token));
require(n->next != NULL, "Memory initialization of next token node in collect_command failed\n");
n = n->next;
}
while(alias_index != 0);
}
/* -1 means the script is done */
if(EOF == index)
{
return index;
}
/* Output the command if verbose is set */
/* Also if there is nothing in the command skip over */
if(VERBOSE && !match(token->value, "") && !match(token->value, NULL))
{
n = token;
fputs(" +>", stdout);
while(n != NULL)
{
/* Print out each token token */
fputs(" ", stdout);
/* M2-Planet doesn't let us do this in the while */
if(n->value != NULL)
{
if(!match(n->value, ""))
{
fputs(n->value, stdout);
}
}
n = n->next;
}
fputc('\n', stdout);
fflush(stdout);
}
return index;
}
/* Function for executing our programs with desired arguments */
void run_script(FILE* script, char** argv)
{
int index;
while(TRUE)
{
/*
* Tokens has to be reset each time, as we need a new linked-list for
* each line.
* See, the program flows like this as a high level overview:
* Get line -> Sanitize line and perform variable replacement etc ->
* Execute line -> Next.
* We don't need the previous lines once they are done with, so tokens
* are hence for each line.
*/
index = collect_command(script, argv);
/* -1 means the script is done */
if(EOF == index)
{
break;
}
if(0 == index)
{
continue;
}
/* Stuff to exec */
execute(script, argv);
}
}
/* Function to populate env */
void populate_env(char** envp)
{
/* You can't populate a NULL environment */
if(NULL == envp)
{
return;
}
/* avoid empty arrays */
int max = array_length(envp);
if(0 == max)
{
return;
}
/* Initialize env and n */
env = calloc(1, sizeof(struct Token));
require(env != NULL, "Memory initialization of env failed\n");
struct Token* n;
n = env;
int i;
int j;
int k;
char* envp_line;
for(i = 0; i < max; i = i + 1)
{
n->var = calloc(MAX_STRING, sizeof(char));
require(n->var != NULL, "Memory initialization of n->var in population of env failed\n");
n->value = calloc(MAX_STRING, sizeof(char));
require(n->value != NULL, "Memory initialization of n->var in population of env failed\n");
j = 0;
/*
* envp is weird.
* When referencing envp[i]'s characters directly, they were all jumbled.
* So just copy envp[i] to envp_line, and work with that - that seems
* to fix it.
*/
envp_line = calloc(MAX_STRING, sizeof(char));
require(envp_line != NULL, "Memory initialization of envp_line in population of env failed\n");
require(strlen(envp[i]) < MAX_STRING, "Environment variable exceeds length restriction\n");
strcpy(envp_line, envp[i]);
while(envp_line[j] != '=')
{
/* Copy over everything up to = to var */
n->var[j] = envp_line[j];
j = j + 1;
}
/* If we get strange input, we need to ignore it */
if(n->var == NULL)
{
continue;
}
j = j + 1; /* Skip over = */
k = 0; /* As envp[i] will continue as j but n->value begins at 0 */
while(envp_line[j] != 0)
{
/* Copy everything else to value */
n->value[k] = envp_line[j];
j = j + 1;
k = k + 1;
}
/* Sometimes, we get lines like VAR=, indicating nothing is in the variable */
if(n->value == NULL)
{
n->value = "";
}
/* Advance to next part of linked list */
n->next = calloc(1, sizeof(struct Token));
require(n->next != NULL, "Memory initialization of n->next in population of env failed\n");
n = n->next;
}
/* Get rid of node on the end */
n = NULL;
/* Also destroy the n->next reference */
n = env;
while(n->next->var != NULL)
{
n = n->next;
}
n->next = NULL;
}
int main(int argc, char** argv, char** envp)
{
VERBOSE = FALSE;
VERBOSE_EXIT = FALSE;
STRICT = TRUE;
FUZZING = FALSE;
WARNINGS = FALSE;
char* filename = "kaem.run";
FILE* script = NULL;
/* Initalize structs */
token = calloc(1, sizeof(struct Token));
require(token != NULL, "Memory initialization of token failed\n");
if(NULL != argv[0]) KAEM_BINARY = argv[0];
else KAEM_BINARY = "./bin/kaem";
int i = 1;
/* Loop over arguments */
while(i <= argc)
{
if(NULL == argv[i])
{
/* Ignore the argument */
i = i + 1;
}
else if(match(argv[i], "-h") || match(argv[i], "--help"))
{
/* Help information */
fputs("Usage: ", stdout);
fputs(argv[0], stdout);
fputs(" [-h | --help] [-V | --version] [--file filename | -f filename] [-i | --init-mode] [-v | --verbose] [--non-strict] [--warn] [--fuzz]\n", stdout);
exit(EXIT_SUCCESS);
}
else if(match(argv[i], "-f") || match(argv[i], "--file"))
{
/* Set the filename */
if(argv[i + 1] != NULL)
{
filename = argv[i + 1];
}
i = i + 2;
}
else if(match(argv[i], "-i") || match(argv[i], "--init-mode"))
{
/* init mode does not populate env */
INIT_MODE = TRUE;
i = i + 1;
}
else if(match(argv[i], "-V") || match(argv[i], "--version"))
{
/* Output version */
fputs("kaem version 1.5.0\n", stdout);
exit(EXIT_SUCCESS);
}
else if(match(argv[i], "-v") || match(argv[i], "--verbose"))
{
/* Set verbose */
VERBOSE = TRUE;
i = i + 1;
}
else if(match(argv[i], "--strict"))
{
/* it is a NOP */
STRICT = TRUE;
i = i + 1;
}
else if(match(argv[i], "--non-strict"))
{
/* Set strict */
STRICT = FALSE;
i = i + 1;
}
else if(match(argv[i], "--warn"))
{
/* Set warnings */
WARNINGS = TRUE;
i = i + 1;
}
else if(match(argv[i], "--fuzz"))
{
/* Set fuzzing */
FUZZING = TRUE;
i = i + 1;
}
else if(match(argv[i], "--show-exit-codes"))
{
/* show exit codes */
VERBOSE_EXIT = TRUE;
i = i + 1;
}
else if(match(argv[i], "--"))
{
/* Nothing more after this */
break;
}
else
{
/* We don't know this argument */
fputs("UNKNOWN ARGUMENT\n", stdout);
exit(EXIT_FAILURE);
}
}
/* Populate env */
if(INIT_MODE == FALSE)
{
populate_env(envp);
}
/* make sure SHELL is set */
if(NULL == env_lookup("SHELL"))
{
struct Token* shell = calloc(1, sizeof(struct Token));
require(NULL != shell, "unable to create SHELL environment variable\n");
shell->next = env;
shell->var = "SHELL";
shell->value= KAEM_BINARY;
env = shell;
}
/* Populate PATH variable
* We don't need to calloc() because env_lookup() does this for us.
*/
PATH = env_lookup("PATH");
/* Populate USERNAME variable */
char* USERNAME = env_lookup("LOGNAME");
/* Handle edge cases */
if((NULL == PATH) && (NULL == USERNAME))
{
/* We didn't find either of PATH or USERNAME -- use a generic PATH */
PATH = calloc(MAX_STRING, sizeof(char));
require(PATH != NULL, "Memory initialization of PATH failed\n");
strcpy(PATH, "/root/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin");
}
else if(NULL == PATH)
{
/* We did find a username but not a PATH -- use a generic PATH but with /home/USERNAME */
PATH = calloc(MAX_STRING, sizeof(char));
PATH = strcat(PATH, "/home/");
PATH = strcat(PATH, USERNAME);
PATH = strcat(PATH, "/bin:/usr/local/bin:/usr/bin:/bin:/usr/local/games:/usr/games");
}
/* Open the script */
script = fopen(filename, "r");
if(NULL == script)
{
fputs("The file: ", stderr);
fputs(filename, stderr);
fputs(" can not be opened!\n", stderr);
exit(EXIT_FAILURE);
}
/* Run the commands */
run_script(script, argv);
/* Cleanup */
fclose(script);
return EXIT_SUCCESS;
}
mescc-tools-1.5.2/Kaem/kaem.h 0000644 0000000 0000000 00000002771 14522760670 012620 0 ustar /* Copyright (C) 2016-2020 Jeremiah Orians
* Copyright (C) 2020 fosslinux
* This file is part of mescc-tools.
*
* mescc-tools is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* mescc-tools is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with mescc-tools. If not, see
#include "../M2libc/bootstrappable.h"
/*
* DEFINES
*/
#define FALSE 0
#define TRUE 1
// CONSTANT SUCCESS 0
#define SUCCESS 0
// CONSTANT FAILURE 1
#define FAILURE 1
#define MAX_STRING 4096
#define MAX_ARRAY 512
/*
* Here is the token struct. It is used for both the token linked-list and
* env linked-list.
*/
struct Token
{
/*
* For the token linked-list, this stores the token; for the env linked-list
* this stores the value of the variable.
*/
char* value;
/*
* Used only for the env linked-list. It holds a string containing the
* name of the var.
*/
char* var;
/*
* This struct stores a node of a singly linked list, store the pointer to
* the next node.
*/
struct Token* next;
};
#include "kaem_globals.h"
mescc-tools-1.5.2/Kaem/kaem_globals.c 0000644 0000000 0000000 00000002156 14522760670 014313 0 ustar /* Copyright (C) 2016-2020 Jeremiah Orians
* Copyright (C) 2020 fosslinux
* This file is part of mescc-tools.
*
* mescc-tools is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* mescc-tools is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with mescc-tools. If not, see
#include
#include
#include
#include "kaem.h"
/* Prototypes from other files */
int array_length(char** array);
char* env_lookup(char* variable);
/*
* VARIABLE HANDLING FUNCTIONS
*/
/* Substitute a variable into n->value */
int run_substitution(char* var_name, struct Token* n)
{
char* value = env_lookup(var_name);
/* If there is nothing to substitute, don't substitute anything! */
if(value != NULL)
{
char* s = calloc(MAX_STRING, sizeof(char));
s = strcat(s, n->value);
s = strcat(s, value);
n->value = s;
return TRUE;
}
return FALSE;
}
/* Handle ${var:-text} format of variables - i.e. ifset format */
int variable_substitute_ifset(char* input, struct Token* n, int index)
{
/*
* In ${var:-text} format, we evaluate like follows.
* If var is set as an envar, then we substitute the contents of that
* envar. If it is not set, we substitute alternative text.
*
* In this function, we assume that input is the raw token,
* n->value is everything already done in variable_substitute,
* index is where we are up to in input. offset is for n->value.
*/
/*
* Check if we should even be performing this function.
* We perform this function when we come across ${var:-text} syntax.
*/
int index_old = index;
int perform = FALSE;
int input_length = strlen(input);
while(index < input_length)
{ /* Loop over each character */
if(input[index] == ':' && input[index + 1] == '-')
{ /* Yes, this is (most likely) ${var:-text} format. */
perform = TRUE;
break;
}
index = index + 1;
}
/* Don't perform it if we shouldn't */
if(perform == FALSE) return index_old;
index = index_old;
/*
* Get offset.
* offset is the difference between the index of the variable we write to
* in the following blocks and input.
* This stays relatively constant.
*/
int offset = index;
/* Get the variable name */
char* var_name = calloc(MAX_STRING, sizeof(char));
require(var_name != NULL, "Memory initialization of var_name in variable_substitute_ifset failed\n");
while(input[index] != ':')
{ /* Copy into var_name until :- */
var_name[index - offset] = input[index];
index = index + 1;
}
/* Skip over :- */
index = index + 2;
offset = index;
/* Get the alternative text */
char* text = calloc(MAX_STRING, sizeof(char));
require(text != NULL, "Memory initialization of text in variable_substitute_ifset failed\n");
while(input[index] != '}')
{ /* Copy into text until } */
require(input_length > index, "IMPROPERLY TERMINATED VARIABLE\nABORTING HARD\n");
text[index - offset] = input[index];
index = index + 1;
}
/* Do the substitution */
if(run_substitution(var_name, n) == FALSE)
{ /* The variable was not found. Substitute the alternative text. */
char* s = calloc(MAX_STRING, sizeof(char));
s = strcat(s, n->value);
s = strcat(s, text);
n->value = s;
}
return index;
}
/* Controls substitution for ${variable} and derivatives */
int variable_substitute(char* input, struct Token* n, int index)
{
/* NOTE: index is the pos of input */
index = index + 1; /* We don't want the { */
/*
* Check for "special" types
* If we do find a special type we delegate the substitution to it
* and return here; as we are done... there's nothing more do do in
* that case.
*/
int index_old = index;
index = variable_substitute_ifset(input, n, index);
if(index != index_old) return index;
/* Reset index */
index = index_old;
/*
* If we reach here it is a normal substitution
* Let's do it!
*/
/* Initialize var_name and offset */
char* var_name = calloc(MAX_STRING, sizeof(char));
require(var_name != NULL, "Memory initialization of var_name in variable_substitute failed\n");
int offset = index;
/* Get the variable name */
int substitute_done = FALSE;
char c;
while(substitute_done == FALSE)
{
c = input[index];
require(MAX_STRING > index, "LINE IS TOO LONG\nABORTING HARD\n");
if(EOF == c || '\n' == c || index > strlen(input))
{ /* We never should hit EOF, EOL or run past the end of the line
while collecting a variable */
fputs("IMPROPERLY TERMINATED VARIABLE!\nABORTING HARD\n", stderr);
exit(EXIT_FAILURE);
}
else if('\\' == c)
{ /* Drop the \ - poor mans escaping. */
index = index + 1;
}
else if('}' == c)
{ /* End of variable name */
substitute_done = TRUE;
}
else
{
var_name[index - offset] = c;
index = index + 1;
}
}
/* Substitute the variable */
run_substitution(var_name, n);
return index;
}
/* Function to concatenate all command line arguments */
void variable_all(char** argv, struct Token* n)
{
fflush(stdout);
/* index refernences the index of n->value, unlike other functions */
int index = 0;
int argv_length = array_length(argv);
int i = 0;
char* argv_element = calloc(MAX_STRING, sizeof(char));
char* hold = argv[i];
n->value = argv_element;
/* Assuming the form kaem -f script or kaem -f script -- 123 we want matching results to bash, so skip the kaem, -f and script */
while(!match("--", hold))
{
i = i + 1;
hold = argv[i];
if(argv_length == i) break;
}
/* put i = i + 1 in the for initialization to skip past the -- */
for(; i < argv_length; i = i + 1)
{
/* Ends up with (n->value) (argv[i]) */
/* If we don't do this we get jumbled results in M2-Planet */
hold = argv[i];
strcpy(argv_element + index, hold);
index = index + strlen(hold);
/* Add space on the end */
n->value[index] = ' ';
index = index + 1;
}
/* Remove trailing space */
index = index - 1;
n->value[index] = 0;
}
/* Function controlling substitution of variables */
void handle_variables(char** argv, struct Token* n)
{
/* NOTE: index is the position of input */
int index = 0;
/* Create input */
char* input = calloc(MAX_STRING, sizeof(char));
require(input != NULL, "Memory initialization of input in collect_variable failed\n");
strcpy(input, n->value);
/* Reset n->value */
n->value = calloc(MAX_STRING, sizeof(char));
require(n->value != NULL, "Memory initialization of n->value in collect_variable failed\n");
/* Copy everything up to the $ */
/*
* TODO: Not need allocation of input before this check if there is no
* variable in it.
*/
while(input[index] != '$')
{
if(input[index] == 0)
{ /* No variable in it */
n->value = input;
return; /* We don't need to do anything more */
}
n->value[index] = input[index];
index = index + 1;
}
/* Must be outside the loop */
int offset;
substitute:
index = index + 1; /* We are uninterested in the $ */
/* Run the substitution */
if(input[index] == '{')
{ /* Handle everything ${ related */
index = variable_substitute(input, n, index);
index = index + 1; /* We don't want the closing } */
}
else if(input[index] == '@')
{ /* Handles $@ */
index = index + 1; /* We don't want the @ */
variable_all(argv, n);
}
else
{ /* We don't know that */
fputs("IMPROPERLY USED VARIABLE!\nOnly ${foo} and $@ format are accepted at this time.\nABORTING HARD\n", stderr);
exit(EXIT_FAILURE);
}
offset = strlen(n->value) - index;
/* Copy everything from the end of the variable to the end of the token */
while(input[index] != 0)
{
if(input[index] == '$')
{ /* We have found another variable */
fflush(stdout);
goto substitute;
}
n->value[index + offset] = input[index];
index = index + 1;
}
}
mescc-tools-1.5.2/M1-macro.c 0000644 0000000 0000000 00000046374 14522760670 012404 0 ustar /* -*- c-file-style: "linux";indent-tabs-mode:t -*- */
/* Copyright (C) 2016 Jeremiah Orians
* Copyright (C) 2017 Jan Nieuwenhuizen
* This file is part of mescc-tools.
*
* mescc-tools is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* mescc-tools is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with mescc-tools. If not, see
#include
#include
#include "M2libc/bootstrappable.h"
/* Internal processing Constants */
// CONSTANT max_string 4096
#define max_string 4096
// CONSTANT STR 2
#define STR 2
// CONSTANT NEWLINE 3
#define NEWLINE 3
/* Unique code for each architecture */
// CONSTANT KNIGHT 0
#define KNIGHT 0
// CONSTANT X86 3
#define X86 0x03
// CONSTANT AMD64 62
#define AMD64 0x3E
// CONSTANT ARMV7L 40
#define ARMV7L 0x28
// CONSTANT AARM64 183
#define AARM64 0xB7
// CONSTANT PPC64LE 21
#define PPC64LE 0x15
// CONSTANT RISCV32 243
#define RISCV32 0xF3
// CONSTANT RISCV64 65779
#define RISCV64 0x100F3 /* Because RISC-V unlike all other architectures does get a seperate e_machine when changing from 32 to 64bit */
/* How do you want that output? */
// CONSTANT HEX 16
#define HEX 16
// CONSTANT OCTAL 8
#define OCTAL 8
// CONSTANT BINARY 2
#define BINARY 2
/* Imported from stringify.c */
int stringify(char* s, int digits, int divisor, int value, int shift);
void LittleEndian(char* start, int ByteMode);
struct blob
{
struct blob* next;
int type;
char* Text;
char* Expression;
struct blob* hash_next;
};
struct Token
{
struct Token* next;
struct blob* contents;
char* filename;
int linenumber;
};
/* Globals */
FILE* source_file;
FILE* destination_file;
int BigEndian;
int ByteMode;
int Architecture;
int linenumber;
struct Token* token_list;
struct blob* blob_list;
struct blob* define_blob;
struct blob* newline_blob;
int blob_count;
char* SCRATCH;
struct blob** hash_table;
void line_error(char* filename, int linenumber)
{
fputs(filename, stderr);
fputs(":", stderr);
fputs(int2str(linenumber,10, FALSE), stderr);
fputs(" :", stderr);
}
void ClearScratch()
{
int i = 0;
int c = SCRATCH[i];
while(0 != c)
{
SCRATCH[i] = 0;
i = i + 1;
c = SCRATCH[i];
}
}
int GetHash(char* s)
{
int i = 5381;
while(0 != s[0])
{
i = (i << 5) + i + s[0];
s = s + 1;
}
return i & 0xFFFF;
}
struct blob* FindBlob()
{
int hash = GetHash(SCRATCH);
struct blob* i = hash_table[hash];
while(NULL != i)
{
if(match(SCRATCH, i->Text)) return i;
i = i->hash_next;
}
return NULL;
}
void AddHash(struct blob* a, char* s)
{
int i = GetHash(s);
a->hash_next = hash_table[i];
hash_table[i] = a;
}
void NewBlob(int size)
{
blob_count = blob_count + 1;
struct blob* a = calloc(1, sizeof(struct blob));
require(NULL != a, "Exhausted available memory\n");
a->Text = calloc(size + 1, sizeof(char));
require(NULL != a->Text, "Exhausted available memory\n");
int i = 0;
while(i <= size)
{
a->Text[i] = SCRATCH[i];
i = i + 1;
}
a->next = blob_list;
blob_list = a;
AddHash(a, SCRATCH);
}
struct Token* newToken(char* filename, int linenumber)
{
struct Token* p;
p = calloc (1, sizeof (struct Token));
require(NULL != p, "Exhausted available memory\n");
p->filename = filename;
p->linenumber = linenumber;
return p;
}
struct Token* reverse_list(struct Token* head)
{
struct Token* root = NULL;
struct Token* next;
while(NULL != head)
{
next = head->next;
head->next = root;
root = head;
head = next;
}
return root;
}
void purge_lineComment()
{
int c = fgetc(source_file);
while(!in_set(c, "\n\r"))
{
if(EOF == c) break;
c = fgetc(source_file);
}
}
struct Token* append_newline(struct Token* head, char* filename)
{
linenumber = linenumber + 1;
if(NULL == head) return NULL;
if(NEWLINE == head->contents->type)
{/* Don't waste whitespace*/
return head;
}
struct Token* lf = newToken(filename, linenumber);
lf->contents = newline_blob;
lf->next = head;
return lf;
}
struct Token* store_atom(struct Token* head, char c, char* filename)
{
ClearScratch();
int ch = c;
int i = 0;
do
{
SCRATCH[i] = ch;
ch = fgetc(source_file);
i = i + 1;
if(i >= max_string)
{
fputs("storing atom of size larger than max_string\n", stderr);
line_error(filename, linenumber);
fputc('\n', stderr);
exit(EXIT_FAILURE);
}
if(EOF == ch) break;
} while (!in_set(ch, "\t\n "));
head->contents = FindBlob();
if(NULL == head->contents)
{
NewBlob(i);
head->contents = blob_list;
}
if('\n' == ch)
{
return append_newline(head, filename);
}
return head;
}
struct blob* store_string(char c, char* filename)
{
ClearScratch();
int ch = c;
int i = 0;
do
{
SCRATCH[i] = ch;
i = i + 1;
if('\n' == ch) linenumber = linenumber + 1;
ch = fgetc(source_file);
require(EOF != ch, "Unmatched \"!\n");
if(max_string == i)
{
line_error(filename, linenumber);
fputs("String: ", stderr);
fputs(SCRATCH, stderr);
fputs(" exceeds max string size\n", stderr);
exit(EXIT_FAILURE);
}
} while(ch != c);
struct blob* a = FindBlob();
if(NULL == a)
{
NewBlob(i);
a = blob_list;
a->type = STR;
}
return a;
}
struct Token* Tokenize_Line(struct Token* head, char* filename)
{
int c;
struct Token* p;
linenumber = 1;
do
{
restart:
c = fgetc(source_file);
if(in_set(c, ";#"))
{
purge_lineComment();
head = append_newline(head, filename);
goto restart;
}
if(in_set(c, "\t "))
{
goto restart;
}
if('\n' == c)
{
head = append_newline(head, filename);
goto restart;
}
if(EOF == c)
{
head = append_newline(head, filename);
goto done;
}
p = newToken(filename, linenumber);
p->next = head;
if(in_set(c, "'\""))
{
p->contents = store_string(c, filename);
}
else
{
p = store_atom(p, c, filename);
}
head = p;
} while(TRUE);
done:
return head;
}
void line_macro(struct Token* p)
{
struct Token* i;
for(i = p; NULL != i; i = i->next)
{
if(define_blob == i->contents)
{
require(NULL != i->next, "Macro name must exist\n");
require(NULL != i->next->next, "Macro value must exist\n");
i->contents = newline_blob;
if (STR == i->next->next->contents->type)
{
i->next->contents->Expression = i->next->next->contents->Text + 1;
}
else
{
i->next->contents->Expression = i->next->next->contents->Text;
}
i->next = i->next->next->next;
}
}
}
void hexify_string(struct blob* p)
{
char* table = "0123456789ABCDEF";
int i = strlen(p->Text);
int size;
if(HEX == ByteMode) size = (((i << 1) + i) + 12);
else if(OCTAL == ByteMode) size = (i << 2) + 1;
else if(BINARY == ByteMode) size = (i << 3) + i + 1;
else size = 1;
require(1 != size, "hexify_string lacked a valid bytemode\n");
char* d = calloc(size, sizeof(char));
require(NULL != d, "Exhausted available memory\n");
p->Expression = d;
char* S = p->Text;
if((KNIGHT == Architecture) && (HEX == ByteMode))
{
i = (((((i - 1) >> 2) + 1) << 3) + i);
while( 0 < i)
{
i = i - 1;
d[i] = '0';
}
}
if(HEX == ByteMode)
{
while(0 != S[0])
{
S = S + 1;
d[0] = table[S[0] >> 4];
d[1] = table[S[0] & 0xF];
d[2] = ' ';
d = d + 3;
}
}
else if(OCTAL == ByteMode)
{
while(0 != S[0])
{
S = S + 1;
d[0] = table[S[0] >> 6];
d[1] = table[(S[0] >> 3) & 0x7];
d[2] = table[S[0] & 0x7];
d[3] = ' ';
d = d + 4;
}
}
else if(BINARY == ByteMode)
{
while(0 != S[0])
{
S = S + 1;
d[0] = table[S[0] >> 7];
d[1] = table[(S[0] >> 6) & 0x1];
d[2] = table[(S[0] >> 5) & 0x1];
d[3] = table[(S[0] >> 4) & 0x1];
d[4] = table[(S[0] >> 3) & 0x1];
d[5] = table[(S[0] >> 2) & 0x1];
d[6] = table[(S[0] >> 1) & 0x1];
d[7] = table[S[0] & 0x1];
d[8] = ' ';
d = d + 9;
}
}
}
void process_string(struct blob* p)
{
struct blob* i;
for(i = p; NULL != i; i = i->next)
{
if(STR == i->type)
{
if('\'' == i->Text[0])
{
i->Expression = i->Text + 1;
}
else if('"' == i->Text[0])
{
hexify_string(i);
}
}
}
}
char* pad_nulls(int size, char* nil)
{
if(0 == size) return nil;
require(size > 0, "negative null padding not possible\n");
if(HEX == ByteMode) size = size * 2;
else if (OCTAL == ByteMode) size = size * 3;
else if (BINARY == ByteMode) size = size * 8;
char* s = calloc(size + 1, sizeof(char));
require(NULL != s, "Exhausted available memory\n");
int i = 0;
while(i < size)
{
s[i] = '0';
i = i + 1;
}
return s;
}
void preserve_other(struct blob* p)
{
struct blob* i;
char c;
for(i = p; NULL != i; i = i->next)
{
if(NULL == i->Expression)
{
c = i->Text[0];
if(in_set(c, "!@$~%&:^"))
{
i->Expression = i->Text;
}
else if('<' == c)
{
i->Expression = pad_nulls(strtoint(i->Text + 1), i->Text);
}
}
}
}
void bound_values(int displacement, int number_of_bytes, int low, int high)
{
if((high < displacement) || (displacement < low))
{
fputs("A displacement of ", stderr);
fputs(int2str(displacement, 10, TRUE), stderr);
fputs(" does not fit in ", stderr);
fputs(int2str(number_of_bytes, 10, TRUE), stderr);
fputs(" bytes\n", stderr);
exit(EXIT_FAILURE);
}
}
void range_check(int displacement, int number_of_bytes, int absolute)
{
if(4 == number_of_bytes) return;
else if(absolute && (3 == number_of_bytes))
{
bound_values(displacement, number_of_bytes, -8388609, 16777217);
return;
}
else if(3 == number_of_bytes)
{
bound_values(displacement, number_of_bytes, -8388609, 8388608);
return;
}
else if(absolute && (2 == number_of_bytes))
{
bound_values(displacement, number_of_bytes, -32769, 65536);
return;
}
else if(2 == number_of_bytes)
{
bound_values(displacement, number_of_bytes, -32769, 32768);
return;
}
else if(absolute && (1 == number_of_bytes))
{
bound_values(displacement, number_of_bytes, -1, 256);
return;
}
else if(1 == number_of_bytes)
{ /* work around current only signed bytes */
bound_values(displacement, number_of_bytes, -129, 256);
return;
}
fputs("Received an invalid number of bytes in range_check\n", stderr);
exit(EXIT_FAILURE);
}
char* express_number(int value, char c)
{
char* ch = calloc(42, sizeof(char));
require(NULL != ch, "Exhausted available memory\n");
int size;
int number_of_bytes;
int shift;
int absolute = FALSE;
if('!' == c) number_of_bytes = 1;
else if('@' == c) number_of_bytes = 2;
else if('$' == c)
{
number_of_bytes = 2;
absolute = TRUE;
}
else if('~' == c) number_of_bytes = 3;
else if('%' == c) number_of_bytes = 4;
else if('&' == c)
{
number_of_bytes = 4;
absolute = TRUE;
}
else
{
fputs("Given symbol ", stderr);
fputc(c, stderr);
fputs(" to express immediate value ", stderr);
fputs(int2str(value, 10, TRUE), stderr);
fputc('\n', stderr);
exit(EXIT_FAILURE);
}
range_check(value, number_of_bytes, absolute);
/* don't truncate prior to range check for -1 behavior */
if('!' == c) value = value & 0xFF;
else if(('@' == c) || ('$' == c)) value = value & 0xFFFF;
else if('~' == c) value = value & 0xFFFFFF;
else if(('%' == c) || ('&' == c)) value = value & 0xFFFFFFFF;
if(HEX == ByteMode)
{
size = number_of_bytes * 2;
shift = 4;
}
else if(OCTAL == ByteMode)
{
size = number_of_bytes * 3;
shift = 3;
}
else if(BINARY == ByteMode)
{
size = number_of_bytes * 8;
shift = 1;
}
else
{
fputs("Got invalid ByteMode in express_number\n", stderr);
exit(EXIT_FAILURE);
}
stringify(ch, size, ByteMode, value, shift);
if(!BigEndian) LittleEndian(ch, ByteMode);
return ch;
}
char* express_word(int value, char c)
{
char* s = calloc(43, sizeof(char));
s[0] = '.';
char* ch = s + 1;
require(NULL != ch, "Exhausted available memory\n");
int size;
int shift;
int immediate;
if('!' == c)
{
/* Corresponds to RISC-V I format */
immediate = (value & 0xFFF) << 20;
}
else if('@' == c)
{
/* Corresponds to RISC-V S format */
immediate = ((value & 0x1F) << 7) | ((value & 0xFE0) << (31 - 11));
}
else if('~' == c)
{
/* Corresponds with RISC-V U format */
if ((value & 0xFFF) < 0x800)
{
immediate = value & 0xFFFFF000;
}
else
{
immediate = (value & 0xFFFFF000) + 0x1000;
}
}
else if('%' == c)
{
/* provides an option for 32bit immediate constants */
immediate = value & 0xFFFFFFFF;
/* Drop the leading . */
ch = s;
}
else
{
fputs("Given symbol ", stderr);
fputc(c, stderr);
fputs(" to express immediate value ", stderr);
fputs(int2str(value, 10, TRUE), stderr);
fputc('\n', stderr);
exit(EXIT_FAILURE);
}
if(HEX == ByteMode)
{
size = 4 * 2;
shift = 4;
}
else if(OCTAL == ByteMode)
{
size = 4 * 3;
shift = 3;
}
else if(BINARY == ByteMode)
{
size = 4 * 8;
shift = 1;
}
else
{
fputs("Got invalid ByteMode in express_number\n", stderr);
exit(EXIT_FAILURE);
}
stringify(ch, size, ByteMode, immediate, shift);
if(!BigEndian) LittleEndian(ch, ByteMode);
return s;
}
void eval_immediates(struct blob* p)
{
struct blob* i;
int value;
for(i = p; NULL != i; i = i->next)
{
if(NEWLINE == i->type) continue;
else if('<' == i->Text[0]) continue;
else if(NULL == i->Expression)
{
if((X86 == Architecture) || (AMD64 == Architecture) || (ARMV7L == Architecture) || (AARM64 == Architecture) || (PPC64LE == Architecture))
{
if(in_set(i->Text[0], "%~@!&$"))
{
value = strtoint(i->Text + 1);
if(('0' == i->Text[1]) || (0 != value))
{
i->Expression = express_number(value, i->Text[0]);
}
}
}
else if((RISCV32 == Architecture) || (RISCV64 == Architecture))
{
if(in_set(i->Text[0], "%~@!"))
{
value = strtoint(i->Text + 1);
if(('0' == i->Text[1]) || (0 != value))
{
i->Expression = express_word(value, i->Text[0]);
}
}
}
else if(KNIGHT == Architecture)
{
value = strtoint(i->Text);
if(('0' == i->Text[0]) || (0 != value))
{
if(value > 65536) continue;
else if(value > 32767) i->Expression = express_number(value, '$');
else i->Expression = express_number(value, '@');
}
}
else
{
fputs("Unknown architecture received in eval_immediates\n", stderr);
exit(EXIT_FAILURE);
}
}
}
}
void print_hex(struct Token* p)
{
struct Token* i;
for(i = p; NULL != i; i = i->next)
{
if(NEWLINE == i->contents->type)
{
if(NULL == i->next) fputc('\n', destination_file);
else if(NEWLINE != i->next->contents->type) fputc('\n', destination_file);
}
else if(NULL != i->contents->Expression)
{
fputs(i->contents->Expression, destination_file);
if(NEWLINE != i->next->contents->type) fputc(' ', destination_file);
}
else
{
line_error(i->filename, i->linenumber);
fputs("Received invalid other; ", stderr);
fputs(i->contents->Text, stderr);
fputs("\n", stderr);
exit(EXIT_FAILURE);
}
}
}
/* Standard C main program */
int main(int argc, char **argv)
{
BigEndian = TRUE;
Architecture = KNIGHT;
destination_file = stdout;
ByteMode = HEX;
char* filename;
char* arch;
blob_count = 2;
hash_table = calloc(65537, sizeof(struct blob*));
require(NULL != hash_table, "failed to allocate hash_table\n");
/* Create newline blob */
newline_blob = calloc(1, sizeof(struct blob));
require(NULL != newline_blob, "failed to allocate newline_blob\n");
newline_blob->Text = "\n";
newline_blob->Expression = "\n";
newline_blob->type = NEWLINE;
AddHash(newline_blob, "\n");
/* Start the blob list with DEFINE and newline */
blob_list = calloc(1, sizeof(struct blob));
require(NULL != blob_list, "failed to allocate DEFINE blob\n");
blob_list->Text = "DEFINE";
define_blob = blob_list;
blob_list->next = newline_blob;
AddHash(define_blob, "DEFINE");
/* Initialize scratch */
SCRATCH = calloc(max_string + 1, sizeof(char));
require(NULL != SCRATCH, "failed to allocate SCRATCH buffer");
int option_index = 1;
while(option_index <= argc)
{
if(NULL == argv[option_index])
{
option_index = option_index + 1;
}
else if(match(argv[option_index], "--big-endian"))
{
BigEndian = TRUE;
option_index = option_index + 1;
}
else if(match(argv[option_index], "--little-endian"))
{
BigEndian = FALSE;
option_index = option_index + 1;
}
else if(match(argv[option_index], "-A") || match(argv[option_index], "--architecture"))
{
arch = argv[option_index + 1];
if(match("knight-native", arch) || match("knight-posix", arch)) Architecture = KNIGHT;
else if(match("x86", arch)) Architecture = X86;
else if(match("amd64", arch)) Architecture = AMD64;
else if(match("armv7l", arch)) Architecture = ARMV7L;
else if(match("aarch64", arch)) Architecture = AARM64;
else if(match("ppc64le", arch)) Architecture = PPC64LE;
else if(match("riscv32", arch)) Architecture = RISCV32;
else if(match("riscv64", arch)) Architecture = RISCV64;
else
{
fputs("Unknown architecture: ", stderr);
fputs(arch, stderr);
fputs(" know values are: knight-native, knight-posix, x86, amd64, armv7l, aarch64, ppc64le, riscv32 and riscv64", stderr);
exit(EXIT_FAILURE);
}
option_index = option_index + 2;
}
else if(match(argv[option_index], "-b") || match(argv[option_index], "--binary"))
{
ByteMode = BINARY;
option_index = option_index + 1;
}
else if(match(argv[option_index], "-h") || match(argv[option_index], "--help"))
{
fputs("Usage: ", stderr);
fputs(argv[0], stderr);
fputs(" --file FILENAME1 {-f FILENAME2} (--big-endian|--little-endian) ", stderr);
fputs("[--architecture name]\nArchitectures: knight-native, knight-posix, x86, amd64, armv7, riscv32 and riscv64\n", stderr);
fputs("To leverage octal or binary output: --octal, --binary\n", stderr);
exit(EXIT_SUCCESS);
}
else if(match(argv[option_index], "-f") || match(argv[option_index], "--file"))
{
filename = argv[option_index + 1];
source_file = fopen(filename, "r");
if(NULL == source_file)
{
fputs("The file: ", stderr);
fputs(argv[option_index + 1], stderr);
fputs(" can not be opened!\n", stderr);
exit(EXIT_FAILURE);
}
token_list = Tokenize_Line(token_list, filename);
fclose(source_file);
option_index = option_index + 2;
}
else if(match(argv[option_index], "-o") || match(argv[option_index], "--output"))
{
destination_file = fopen(argv[option_index + 1], "w");
if(NULL == destination_file)
{
fputs("The file: ", stderr);
fputs(argv[option_index + 1], stderr);
fputs(" can not be opened!\n", stderr);
exit(EXIT_FAILURE);
}
option_index = option_index + 2;
}
else if(match(argv[option_index], "-O") || match(argv[option_index], "--octal"))
{
ByteMode = OCTAL;
option_index = option_index + 1;
}
else if(match(argv[option_index], "-V") || match(argv[option_index], "--version"))
{
fputs("M1 1.5.0\n", stdout);
exit(EXIT_SUCCESS);
}
else
{
fputs("Unknown option\n", stderr);
exit(EXIT_FAILURE);
}
}
if(NULL == token_list)
{
fputs("Either no input files were given or they were empty\n", stderr);
exit(EXIT_FAILURE);
}
token_list = reverse_list(token_list);
line_macro(token_list);
process_string(blob_list);
eval_immediates(blob_list);
preserve_other(blob_list);
print_hex(token_list);
fclose(destination_file);
return EXIT_SUCCESS;
}
mescc-tools-1.5.2/M2libc/ 0000755 0000000 0000000 00000000000 14522760670 011756 5 ustar mescc-tools-1.5.2/M2libc/.git 0000644 0000000 0000000 00000000037 14522760670 012542 0 ustar gitdir: ../.git/modules/M2libc
mescc-tools-1.5.2/M2libc/LICENSE 0000644 0000000 0000000 00000104515 14522760670 012771 0 ustar GNU GENERAL PUBLIC LICENSE
Version 3, 29 June 2007
Copyright (C) 2007 Free Software Foundation, Inc.
Copyright (C)
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see Copyright (C)
This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
This is free software, and you are welcome to redistribute it
under certain conditions; type `show c' for details.
The hypothetical commands `show w' and `show c' should show the appropriate
parts of the General Public License. Of course, your program's commands
might be different; for a GUI interface, you would use an "about box".
You should also get your employer (if you work as a programmer) or school,
if any, to sign a "copyright disclaimer" for the program, if necessary.
For more information on this, and how to apply and follow the GNU GPL, see
.
mescc-tools-1.5.2/M2libc/README.md 0000644 0000000 0000000 00000000221 14522760670 013230 0 ustar Inside is a standard C library for those who need to bootstrap from nothing.
As all of the pieces inside will work with M2-Planet and mescc-tools mescc-tools-1.5.2/M2libc/aarch64/ 0000755 0000000 0000000 00000000000 14522760670 013206 5 ustar mescc-tools-1.5.2/M2libc/aarch64/ELF-aarch64-debug.hex2 0000644 0000000 0000000 00000006405 14522760670 016723 0 ustar ### Copyright (C) 2016 Jeremiah Orians
### Copyright (C) 2017 Jan Nieuwenhuizen
### Copyright (C) 2020 deesix
### This file is part of M2-Planet.
###
### M2-Planet is free software: you can redistribute it and/or modify
### it under the terms of the GNU General Public License as published by
### the Free Software Foundation, either version 3 of the License, or
### (at your option) any later version.
###
### M2-Planet is distributed in the hope that it will be useful,
### but WITHOUT ANY WARRANTY; without even the implied warranty of
### MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
### GNU General Public License for more details.
###
### You should have received a copy of the GNU General Public License
### along with M2-Planet. If not, see 1 byte relative
### $ 2 byte address
### @ 2 byte relative
### & 4 byte address
### % 4 byte relative
### if you wish to use this header, you need to add :ELF_end to the end of your
### M1 or hex2 files.
## ELF Header
:ELF_base
7F 45 4C 46 # e_ident[EI_MAG0-3] ELF's magic number
02 # e_ident[EI_CLASS] Indicating 64 bit
01 # e_ident[EI_DATA] Indicating little endianness
01 # e_ident[EI_VERSION] Indicating original elf
03 # e_ident[EI_OSABI] Set at 3 because FreeBSD is strict
00 # e_ident[EI_ABIVERSION] See above
00 00 00 00 00 00 00 # e_ident[EI_PAD]
02 00 # e_type Indicating Executable
B7 00 # e_machine Indicating AArch64
01 00 00 00 # e_version Indicating original elf
&_start 00 00 00 00 # e_entry Address of the entry point
%ELF_program_headers>ELF_base 00 00 00 00 # e_phoff Address of program header table
%ELF_section_headers>ELF_base 00 00 00 00 # e_shoff Address of section header table
00 00 00 00 # e_flags
40 00 # e_ehsize Indicating our 64 Byte header
38 00 # e_phentsize size of a program header table
01 00 # e_phnum number of entries in program table
40 00 # e_shentsize size of a section header table
05 00 # e_shnum number of entries in section table
02 00 # e_shstrndx index of the section names
:ELF_program_headers
:ELF_program_header__text
01 00 00 00 # ph_type: PT-LOAD = 1
07 00 00 00 # ph_flags: PF-X|PF-W|PF-R = 7
00 00 00 00 00 00 00 00 # ph_offset
&ELF_base 00 00 00 00 # ph_vaddr
&ELF_base 00 00 00 00 # ph_physaddr
%ELF_end>ELF_base 00 00 00 00 # ph_filesz
%ELF_end>ELF_base 00 00 00 00 # ph_memsz
01 00 00 00 00 00 00 00 # ph_align
:ELF_text
mescc-tools-1.5.2/M2libc/aarch64/ELF-aarch64.hex2 0000644 0000000 0000000 00000006405 14522760670 015637 0 ustar ### Copyright (C) 2016 Jeremiah Orians
### Copyright (C) 2017 Jan Nieuwenhuizen
### Copyright (C) 2020 deesix
### This file is part of M2-Planet.
###
### M2-Planet is free software: you can redistribute it and/or modify
### it under the terms of the GNU General Public License as published by
### the Free Software Foundation, either version 3 of the License, or
### (at your option) any later version.
###
### M2-Planet is distributed in the hope that it will be useful,
### but WITHOUT ANY WARRANTY; without even the implied warranty of
### MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
### GNU General Public License for more details.
###
### You should have received a copy of the GNU General Public License
### along with M2-Planet. If not, see 1 byte relative
### $ 2 byte address
### @ 2 byte relative
### & 4 byte address
### % 4 byte relative
### if you wish to use this header, you need to add :ELF_end to the end of your
### M1 or hex2 files.
## ELF Header
:ELF_base
7F 45 4C 46 # e_ident[EI_MAG0-3] ELF's magic number
02 # e_ident[EI_CLASS] Indicating 64 bit
01 # e_ident[EI_DATA] Indicating little endianness
01 # e_ident[EI_VERSION] Indicating original elf
03 # e_ident[EI_OSABI] Set at 3 because FreeBSD is strict
00 # e_ident[EI_ABIVERSION] See above
00 00 00 00 00 00 00 # e_ident[EI_PAD]
02 00 # e_type Indicating Executable
B7 00 # e_machine Indicating AArch64
01 00 00 00 # e_version Indicating original elf
&_start 00 00 00 00 # e_entry Address of the entry point
%ELF_program_headers>ELF_base 00 00 00 00 # e_phoff Address of program header table
00 00 00 00 00 00 00 00 # e_shoff Address of section header table
00 00 00 00 # e_flags
40 00 # e_ehsize Indicating our 64 Byte header
38 00 # e_phentsize size of a program header table
01 00 # e_phnum number of entries in program table
00 00 # e_shentsize size of a section header table
00 00 # e_shnum number of entries in section table
00 00 # e_shstrndx index of the section names
:ELF_program_headers
:ELF_program_header__text
01 00 00 00 # ph_type: PT-LOAD = 1
07 00 00 00 # ph_flags: PF-X|PF-W|PF-R = 7
00 00 00 00 00 00 00 00 # ph_offset
&ELF_base 00 00 00 00 # ph_vaddr
&ELF_base 00 00 00 00 # ph_physaddr
%ELF_end>ELF_base 00 00 00 00 # ph_filesz
%ELF_end>ELF_base 00 00 00 00 # ph_memsz
01 00 00 00 00 00 00 00 # ph_align
:ELF_text
mescc-tools-1.5.2/M2libc/aarch64/aarch64_defs.M1 0000644 0000000 0000000 00000010457 14522760670 015645 0 ustar ## Copyright (C) 2020 deesix
## Copyright (C) 2020 Sanne Wouda
## This file is part of M2-Planet.
##
## M2-Planet is free software: you can redistribute it and/or modify
## it under the terms of the GNU General Public License as published by
## the Free Software Foundation, either version 3 of the License, or
## (at your option) any later version.
##
## M2-Planet is distributed in the hope that it will be useful,
## but WITHOUT ANY WARRANTY; without even the implied warranty of
## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
## GNU General Public License for more details.
##
## You should have received a copy of the GNU General Public License
## along with M2-Planet. If not, see
## This file is part of M2-Planet.
##
## M2-Planet is free software: you can redistribute it and/or modify
## it under the terms of the GNU General Public License as published by
## the Free Software Foundation, either version 3 of the License, or
## (at your option) any later version.
##
## M2-Planet is distributed in the hope that it will be useful,
## but WITHOUT ANY WARRANTY; without even the implied warranty of
## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
## GNU General Public License for more details.
##
## You should have received a copy of the GNU General Public License
## along with M2-Planet. If not, see
## This file is part of M2-Planet.
##
## M2-Planet is free software: you can redistribute it and/or modify
## it under the terms of the GNU General Public License as published by
## the Free Software Foundation, either version 3 of the License, or
## (at your option) any later version.
##
## M2-Planet is distributed in the hope that it will be useful,
## but WITHOUT ANY WARRANTY; without even the implied warranty of
## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
## GNU General Public License for more details.
##
## You should have received a copy of the GNU General Public License
## along with M2-Planet. If not, see
* This file is part of M2-Planet.
*
* M2-Planet is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* M2-Planet is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with M2-Planet. If not, see
* This file is part of M2-Planet.
*
* M2-Planet is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* M2-Planet is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with M2-Planet. If not, see
#define S_IRWXU 00700
#define S_IXUSR 00100
#define S_IWUSR 00200
#define S_IRUSR 00400
#define S_ISUID 04000
#define S_ISGID 02000
#define S_IXGRP 00010
#define S_IXOTH 00001
#define S_IRGRP 00040
#define S_IROTH 00004
#define S_IWGRP 00020
#define S_IWOTH 00002
#define S_IRWXG 00070
#define S_IRWXO 00007
int chmod(char *pathname, int mode)
{
asm("SET_X0_FROM_BP" "SUB_X0_16" "DEREF_X0"
"SET_X2_FROM_X0"
"SET_X0_FROM_BP" "SUB_X0_8" "DEREF_X0"
"SET_X1_FROM_X0"
"SET_X0_TO_0"
"SET_X3_FROM_X0"
"SET_X0_TO_FCNTL_H_AT_FDCWD"
"SET_X8_TO_SYS_FCHMODAT"
"SYSCALL");
}
int fchmod(int a, mode_t b)
{
asm("SET_X0_FROM_BP" "SUB_X0_16" "DEREF_X0"
"SET_X2_FROM_X0"
"SET_X0_FROM_BP" "SUB_X0_8" "DEREF_X0"
"SET_X1_FROM_X0"
"SET_X0_TO_0"
"SET_X3_FROM_X0"
"SET_X0_TO_FCNTL_H_AT_FDCWD"
"SET_X8_TO_SYS_FCHMOD"
"SYSCALL");
}
int mkdir(char const* a, mode_t b)
{
asm("SET_X0_FROM_BP" "SUB_X0_16" "DEREF_X0"
"SET_X2_FROM_X0"
"SET_X0_FROM_BP" "SUB_X0_8" "DEREF_X0"
"SET_X1_FROM_X0"
"SET_X0_TO_0"
"SET_X3_FROM_X0"
"SET_X0_TO_FCNTL_H_AT_FDCWD"
"SET_X8_TO_SYS_MKDIR"
"SYSCALL");
}
int mknod(char const* a, mode_t b, dev_t c)
{
asm("SET_X0_TO_MINUS_1"
"SET_X3_FROM_X0"
"SET_X0_FROM_BP" "SUB_X0_24" "DEREF_X0"
"SET_X2_FROM_X0"
"SET_X0_FROM_BP" "SUB_X0_16" "DEREF_X0"
"SET_X1_FROM_X0"
"SET_X0_FROM_BP" "SUB_X0_8" "DEREF_X0"
"SET_X8_TO_SYS_MKNOD"
"SYSCALL");
}
mode_t umask(mode_t m)
{
asm("SET_X0_FROM_BP" "SUB_X0_8" "DEREF_X0"
"SET_X8_TO_SYS_UMASK"
"SYSCALL");
}
#endif
mescc-tools-1.5.2/M2libc/aarch64/linux/unistd.c 0000644 0000000 0000000 00000010447 14522760670 016025 0 ustar /* Copyright (C) 2020 Jeremiah Orians
* Copyright (C) 2020 deesix
* This file is part of M2-Planet.
*
* M2-Planet is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* M2-Planet is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with M2-Planet. If not, see
### This file is part of M2-Planet.
###
### M2-Planet is free software: you can redistribute it and/or modify
### it under the terms of the GNU General Public License as published by
### the Free Software Foundation, either version 3 of the License, or
### (at your option) any later version.
###
### M2-Planet is distributed in the hope that it will be useful,
### but WITHOUT ANY WARRANTY; without even the implied warranty of
### MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
### GNU General Public License for more details.
###
### You should have received a copy of the GNU General Public License
### along with M2-Planet. If not, see 1 byte relative
### $ 2 byte address
### @ 2 byte relative
### & 4 byte address
### % 4 byte relative
### if you wish to use this header, you need to add :ELF_end to the end of your
### M1 or hex2 files.
## ELF Header
:ELF_base
7F 45 4C 46 # e_ident[EI_MAG0-3] ELF's magic number
02 # e_ident[EI_CLASS] Indicating 64 bit
01 # e_ident[EI_DATA] Indicating little endianness
01 # e_ident[EI_VERSION] Indicating original elf
03 # e_ident[EI_OSABI] Set at 3 because FreeBSD is strict
00 # e_ident[EI_ABIVERSION] See above
00 00 00 00 00 00 00 # e_ident[EI_PAD]
02 00 # e_type Indicating Executable
3E 00 # e_machine Indicating AMD64
01 00 00 00 # e_version Indicating original elf
&_start 00 00 00 00 # e_entry Address of the entry point
%ELF_program_headers>ELF_base 00 00 00 00 # e_phoff Address of program header table
%ELF_section_headers>ELF_base 00 00 00 00 # e_shoff Address of section header table
00 00 00 00 # e_flags
40 00 # e_ehsize Indicating our 64 Byte header
38 00 # e_phentsize size of a program header table
01 00 # e_phnum number of entries in program table
40 00 # e_shentsize size of a section header table
05 00 # e_shnum number of entries in section table
02 00 # e_shstrndx index of the section names
:ELF_program_headers
:ELF_program_header__text
01 00 00 00 # ph_type: PT-LOAD = 1
07 00 00 00 # ph_flags: PF-X|PF-W|PF-R = 7
00 00 00 00 00 00 00 00 # ph_offset
&ELF_base 00 00 00 00 # ph_vaddr
&ELF_base 00 00 00 00 # ph_physaddr
%ELF_end>ELF_base 00 00 00 00 # ph_filesz
%ELF_end>ELF_base 00 00 00 00 # ph_memsz
01 00 00 00 00 00 00 00 # ph_align
:ELF_text
mescc-tools-1.5.2/M2libc/amd64/ELF-amd64.hex2 0000644 0000000 0000000 00000006324 14522760670 015005 0 ustar ### Copyright (C) 2016 Jeremiah Orians
### Copyright (C) 2017 Jan Nieuwenhuizen
### This file is part of M2-Planet.
###
### M2-Planet is free software: you can redistribute it and/or modify
### it under the terms of the GNU General Public License as published by
### the Free Software Foundation, either version 3 of the License, or
### (at your option) any later version.
###
### M2-Planet is distributed in the hope that it will be useful,
### but WITHOUT ANY WARRANTY; without even the implied warranty of
### MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
### GNU General Public License for more details.
###
### You should have received a copy of the GNU General Public License
### along with M2-Planet. If not, see 1 byte relative
### $ 2 byte address
### @ 2 byte relative
### & 4 byte address
### % 4 byte relative
### if you wish to use this header, you need to add :ELF_end to the end of your
### M1 or hex2 files.
## ELF Header
:ELF_base
7F 45 4C 46 # e_ident[EI_MAG0-3] ELF's magic number
02 # e_ident[EI_CLASS] Indicating 64 bit
01 # e_ident[EI_DATA] Indicating little endianness
01 # e_ident[EI_VERSION] Indicating original elf
03 # e_ident[EI_OSABI] Set at 3 because FreeBSD is strict
00 # e_ident[EI_ABIVERSION] See above
00 00 00 00 00 00 00 # e_ident[EI_PAD]
02 00 # e_type Indicating Executable
3E 00 # e_machine Indicating AMD64
01 00 00 00 # e_version Indicating original elf
&_start 00 00 00 00 # e_entry Address of the entry point
%ELF_program_headers>ELF_base 00 00 00 00 # e_phoff Address of program header table
00 00 00 00 00 00 00 00 # e_shoff Address of section header table
00 00 00 00 # e_flags
40 00 # e_ehsize Indicating our 64 Byte header
38 00 # e_phentsize size of a program header table
01 00 # e_phnum number of entries in program table
00 00 # e_shentsize size of a section header table
00 00 # e_shnum number of entries in section table
00 00 # e_shstrndx index of the section names
:ELF_program_headers
:ELF_program_header__text
01 00 00 00 # ph_type: PT-LOAD = 1
07 00 00 00 # ph_flags: PF-X|PF-W|PF-R = 7
00 00 00 00 00 00 00 00 # ph_offset
&ELF_base 00 00 00 00 # ph_vaddr
&ELF_base 00 00 00 00 # ph_physaddr
%ELF_end>ELF_base 00 00 00 00 # ph_filesz
%ELF_end>ELF_base 00 00 00 00 # ph_memsz
01 00 00 00 00 00 00 00 # ph_align
:ELF_text
mescc-tools-1.5.2/M2libc/amd64/amd64_defs.M1 0000644 0000000 0000000 00000007033 14522760670 015007 0 ustar ## Copyright (C) 2017 Jeremiah Orians
## This file is part of M2-Planet.
##
## M2-Planet is free software: you can redistribute it and/or modify
## it under the terms of the GNU General Public License as published by
## the Free Software Foundation, either version 3 of the License, or
## (at your option) any later version.
##
## M2-Planet is distributed in the hope that it will be useful,
## but WITHOUT ANY WARRANTY; without even the implied warranty of
## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
## GNU General Public License for more details.
##
## You should have received a copy of the GNU General Public License
## along with M2-Planet. If not, see
#define S_IRWXU 00700
#define S_IXUSR 00100
#define S_IWUSR 00200
#define S_IRUSR 00400
#define S_ISUID 04000
#define S_ISGID 02000
#define S_IXGRP 00010
#define S_IXOTH 00001
#define S_IRGRP 00040
#define S_IROTH 00004
#define S_IWGRP 00020
#define S_IWOTH 00002
#define S_IRWXG 00070
#define S_IRWXO 00007
int chmod(char *pathname, int mode)
{
asm("lea_rdi,[rsp+DWORD] %16"
"mov_rdi,[rdi]"
"lea_rsi,[rsp+DWORD] %8"
"mov_rsi,[rsi]"
"mov_rax, %90"
"syscall");
}
int fchmod(int a, mode_t b)
{
asm("lea_rdi,[rsp+DWORD] %16"
"mov_rdi,[rdi]"
"lea_rsi,[rsp+DWORD] %8"
"mov_rsi,[rsi]"
"mov_rax, %91"
"syscall");
}
int mkdir(char const* a, mode_t b)
{
asm("lea_rdi,[rsp+DWORD] %16"
"mov_rdi,[rdi]"
"lea_rsi,[rsp+DWORD] %8"
"mov_rsi,[rsi]"
"mov_rax, %83"
"syscall");
}
int mknod(char const* a, mode_t b, dev_t c)
{
asm("lea_rdi,[rsp+DWORD] %24"
"mov_rdi,[rdi]"
"lea_rsi,[rsp+DWORD] %16"
"mov_rsi,[rsi]"
"lea_rdx,[rsp+DWORD] %8"
"mov_rdx,[rdx]"
"mov_rax, %133"
"syscall");
}
mode_t umask(mode_t m)
{
asm("lea_rdi,[rsp+DWORD] %8"
"mov_rdi,[rdi]"
"mov_rax, %95"
"syscall");
}
#endif
mescc-tools-1.5.2/M2libc/amd64/linux/unistd.c 0000644 0000000 0000000 00000007527 14522760670 015515 0 ustar /* Copyright (C) 2020 Jeremiah Orians
* This file is part of M2-Planet.
*
* M2-Planet is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* M2-Planet is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with M2-Planet. If not, see
### This file is part of M2-Planet.
###
### M2-Planet is free software: you can redistribute it and/or modify
### it under the terms of the GNU General Public License as published by
### the Free Software Foundation, either version 3 of the License, or
### (at your option) any later version.
###
### M2-Planet is distributed in the hope that it will be useful,
### but WITHOUT ANY WARRANTY; without even the implied warranty of
### MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
### GNU General Public License for more details.
###
### You should have received a copy of the GNU General Public License
### along with M2-Planet. If not, see 1 byte relative
### $ 2 byte address
### @ 2 byte relative
### & 4 byte address
### % 4 byte relative
### if you wish to use this header, you need to add :ELF_end to the end of your
### M1 or hex2 files.
## ELF Header
:ELF_base
7F 45 4C 46 # e_ident[EI_MAG0-3] ELF's magic number
01 # e_ident[EI_CLASS] Indicating 32 bit
01 # e_ident[EI_DATA] Indicating little endianness
01 # e_ident[EI_VERSION] Indicating original elf
03 # e_ident[EI_OSABI] Set at 3 because FreeBSD is strict
00 # e_ident[EI_ABIVERSION] See above
00 00 00 00 00 00 00 # e_ident[EI_PAD]
02 00 # e_type Indicating Executable
28 00 # e_machine Indicating 32bit ARM
01 00 00 00 # e_version Indicating original elf
&_start # e_entry Address of the entry point
%ELF_program_headers>ELF_base # e_phoff Address of program header table
%ELF_section_headers>ELF_base # e_shoff Address of section header table
00 02 00 05 # e_flags
34 00 # e_ehsize Indicating our 52 Byte header
20 00 # e_phentsize size of a program header table
01 00 # e_phnum number of entries in program table
28 00 # e_shentsize size of a section header table
05 00 # e_shnum number of entries in section table
02 00 # e_shstrndx index of the section names
:ELF_program_headers
:ELF_program_header__text
01 00 00 00 # ph_type: PT-LOAD = 1
00 00 00 00 # ph_offset
&ELF_base # ph_vaddr
&ELF_base # ph_physaddr
%ELF_end>ELF_base # ph_filesz
%ELF_end>ELF_base # ph_memsz
07 00 00 00 # ph_flags: PF-X|PF-W|PF-R = 7
00 00 01 00 # ph_alignment
:ELF_text
mescc-tools-1.5.2/M2libc/armv7l/ELF-armv7l.hex2 0000644 0000000 0000000 00000005650 14522760670 015600 0 ustar ### Copyright (C) 2016 Jeremiah Orians
### Copyright (C) 2017 Jan Nieuwenhuizen
### This file is part of M2-Planet.
###
### M2-Planet is free software: you can redistribute it and/or modify
### it under the terms of the GNU General Public License as published by
### the Free Software Foundation, either version 3 of the License, or
### (at your option) any later version.
###
### M2-Planet is distributed in the hope that it will be useful,
### but WITHOUT ANY WARRANTY; without even the implied warranty of
### MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
### GNU General Public License for more details.
###
### You should have received a copy of the GNU General Public License
### along with M2-Planet. If not, see 1 byte relative
### $ 2 byte address
### @ 2 byte relative
### & 4 byte address
### % 4 byte relative
### if you wish to use this header, you need to add :ELF_end to the end of your
### M1 or hex2 files.
## ELF Header
:ELF_base
7F 45 4C 46 # e_ident[EI_MAG0-3] ELF's magic number
01 # e_ident[EI_CLASS] Indicating 32 bit
01 # e_ident[EI_DATA] Indicating little endianness
01 # e_ident[EI_VERSION] Indicating original elf
03 # e_ident[EI_OSABI] Set at 3 because FreeBSD is strict
00 # e_ident[EI_ABIVERSION] See above
00 00 00 00 00 00 00 # e_ident[EI_PAD]
02 00 # e_type Indicating Executable
28 00 # e_machine Indicating 32bit ARM
01 00 00 00 # e_version Indicating original elf
&_start # e_entry Address of the entry point
%ELF_program_headers>ELF_base # e_phoff Address of program header table
00 00 00 00 # e_shoff Address of section header table
00 02 00 05 # e_flags
34 00 # e_ehsize Indicating our 52 Byte header
20 00 # e_phentsize size of a program header table
01 00 # e_phnum number of entries in program table
00 00 # e_shentsize size of a section header table
00 00 # e_shnum number of entries in section table
00 00 # e_shstrndx index of the section names
:ELF_program_headers
:ELF_program_header__text
01 00 00 00 # ph_type: PT-LOAD = 1
00 00 00 00 # ph_offset
&ELF_base # ph_vaddr
&ELF_base # ph_physaddr
%ELF_end>ELF_base # ph_filesz
%ELF_end>ELF_base # ph_memsz
07 00 00 00 # ph_flags: PF-X|PF-W|PF-R = 7
00 00 01 00 # ph_alignment
:ELF_text
mescc-tools-1.5.2/M2libc/armv7l/armv7l_defs.M1 0000644 0000000 0000000 00000004644 14522760670 015606 0 ustar ## Copyright (C) 2016 Jeremiah Orians
## This file is part of stage0.
##
## stage0 is free software: you can redistribute it and/or modify
## it under the terms of the GNU General Public License as published by
## the Free Software Foundation, either version 3 of the License, or
## (at your option) any later version.
##
## stage0 is distributed in the hope that it will be useful,
## but WITHOUT ANY WARRANTY; without even the implied warranty of
## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
## GNU General Public License for more details.
##
## You should have received a copy of the GNU General Public License
## along with stage0. If not, see
#define S_IRWXU 00700
#define S_IXUSR 00100
#define S_IWUSR 00200
#define S_IRUSR 00400
#define S_ISUID 04000
#define S_ISGID 02000
#define S_IXGRP 00010
#define S_IXOTH 00001
#define S_IRGRP 00040
#define S_IROTH 00004
#define S_IWGRP 00020
#define S_IWOTH 00002
#define S_IRWXG 00070
#define S_IRWXO 00007
int chmod(char *pathname, int mode)
{
asm("!15 R7 LOADI8_ALWAYS"
"!8 R1 SUB R12 ARITH_ALWAYS"
"!0 R1 LOAD32 R1 MEMORY"
"!4 R0 SUB R12 ARITH_ALWAYS"
"!0 R0 LOAD32 R0 MEMORY"
"SYSCALL_ALWAYS");
}
int fchmod(int a, mode_t b)
{
asm("!94 R7 LOADI8_ALWAYS"
"!8 R1 SUB R12 ARITH_ALWAYS"
"!0 R1 LOAD32 R1 MEMORY"
"!4 R0 SUB R12 ARITH_ALWAYS"
"!0 R0 LOAD32 R0 MEMORY"
"SYSCALL_ALWAYS");
}
int mkdir(char const* a, mode_t b)
{
asm("!39 R7 LOADI8_ALWAYS"
"!8 R1 SUB R12 ARITH_ALWAYS"
"!0 R1 LOAD32 R1 MEMORY"
"!4 R0 SUB R12 ARITH_ALWAYS"
"!0 R0 LOAD32 R0 MEMORY"
"SYSCALL_ALWAYS");
}
int mknod(char const* a, mode_t b, dev_t c)
{
asm("!14 R7 LOADI8_ALWAYS"
"!12 R2 SUB R12 ARITH_ALWAYS"
"!0 R2 LOAD32 R2 MEMORY"
"!8 R1 SUB R12 ARITH_ALWAYS"
"!0 R1 LOAD32 R1 MEMORY"
"!4 R0 SUB R12 ARITH_ALWAYS"
"!0 R0 LOAD32 R0 MEMORY"
"SYSCALL_ALWAYS");
}
mode_t umask(mode_t m)
{
asm("!60 R7 LOADI8_ALWAYS"
"!4 R0 SUB R12 ARITH_ALWAYS"
"!0 R0 LOAD32 R0 MEMORY"
"SYSCALL_ALWAYS");
}
#endif
mescc-tools-1.5.2/M2libc/armv7l/linux/unistd.c 0000644 0000000 0000000 00000010243 14522760670 015777 0 ustar /* Copyright (C) 2020 Jeremiah Orians
* This file is part of M2-Planet.
*
* M2-Planet is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* M2-Planet is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with M2-Planet. If not, see
#include
#define TRUE 1
#define FALSE 0
void require(int bool, char* error)
{
if(!bool)
{
fputs(error, stderr);
exit(EXIT_FAILURE);
}
}
int match(char* a, char* b)
{
if((NULL == a) && (NULL == b)) return TRUE;
if(NULL == a) return FALSE;
if(NULL == b) return FALSE;
int i = -1;
do
{
i = i + 1;
if(a[i] != b[i])
{
return FALSE;
}
} while((0 != a[i]) && (0 !=b[i]));
return TRUE;
}
int in_set(int c, char* s)
{
/* NULL set is always false */
if(NULL == s) return FALSE;
while(0 != s[0])
{
if(c == s[0]) return TRUE;
s = s + 1;
}
return FALSE;
}
/* INTERNAL ONLY */
int __index_number(char* s, char c)
{
int i = 0;
while(s[i] != c)
{
i = i + 1;
if(0 == s[i]) return -1;
}
return i;
}
/* INTERNAL ONLY */
int __toupper(int c)
{
if(in_set(c, "abcdefghijklmnopqrstuvwxyz")) return (c & 0xDF);
return c;
}
/* INTERNAL ONLY */
int __set_reader(char* set, int mult, char* input)
{
int n = 0;
int i = 0;
int hold;
int negative_p = FALSE;
if(input[0] == '-')
{
negative_p = TRUE;
i = i + 1;
}
while(in_set(input[i], set))
{
n = n * mult;
hold = __index_number(set, __toupper(input[i]));
/* Input managed to change between in_set and index_number */
if(-1 == hold) return 0;
n = n + hold;
i = i + 1;
}
/* loop exited before NULL and thus invalid input */
if(0 != input[i]) return 0;
if(negative_p)
{
n = 0 - n;
}
return n;
}
int strtoint(char *a)
{
int result = 0;
/* If NULL string */
if(0 == a[0])
{
result = 0;
}
/* Deal with binary */
else if ('0' == a[0] && 'b' == a[1])
{
result = __set_reader("01", 2, a+2);
}
/* Deal with hex */
else if ('0' == a[0] && 'x' == a[1])
{
result = __set_reader("0123456789ABCDEFabcdef", 16, a+2);
}
/* Deal with octal */
else if('0' == a[0])
{
result = __set_reader("01234567", 8, a+1);
}
/* Deal with decimal */
else
{
result = __set_reader("0123456789", 10, a);
}
/* Deal with sign extension for 64bit hosts */
if(0 != (0x80000000 & result)) result = (0xFFFFFFFF << 31) | result;
return result;
}
char* int2str(int x, int base, int signed_p)
{
require(1 < base, "int2str doesn't support a base less than 2\n");
require(37 > base, "int2str doesn't support a base more than 36\n");
/* Be overly conservative and save space for 32binary digits and padding null */
char* p = calloc(34, sizeof(char));
/* if calloc fails return null to let calling code deal with it */
if(NULL == p) return p;
p = p + 32;
unsigned i;
int sign_p = FALSE;
char* table = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
if(signed_p && (10 == base) && (0 != (x & 0x80000000)))
{
/* Truncate to 31bits */
i = -x & 0x7FFFFFFF;
if(0 == i) return "-2147483648";
sign_p = TRUE;
} /* Truncate to 32bits */
else i = x & (0x7FFFFFFF | (1 << 31));
do
{
p[0] = table[i % base];
p = p - 1;
i = i / base;
} while(0 < i);
if(sign_p)
{
p[0] = '-';
p = p - 1;
}
return p + 1;
}
mescc-tools-1.5.2/M2libc/bootstrappable.h 0000644 0000000 0000000 00000002110 14522760670 015142 0 ustar /* Copyright (C) 2016 Jeremiah Orians
* This file is part of M2-Planet.
*
* M2-Planet is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* M2-Planet is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with M2-Planet. If not, see
#else
/* Universally useful functions */
void require(int bool, char* error);
int match(char* a, char* b);
int in_set(int c, char* s);
int strtoint(char *a);
char* int2str(int x, int base, int signed_p);
#endif
#endif
mescc-tools-1.5.2/M2libc/ctype.c 0000644 0000000 0000000 00000001415 14522760670 013247 0 ustar /* Copyright (C) 2022 Andrius Štikonas
* This file is part of M2-Planet.
*
* M2-Planet is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* M2-Planet is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with M2-Planet. If not, see
#else
#endif
#endif
mescc-tools-1.5.2/M2libc/fcntl.c 0000644 0000000 0000000 00000002723 14522760670 013234 0 ustar /* Copyright (C) 2016 Jeremiah Orians
* This file is part of M2-Planet.
*
* M2-Planet is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* M2-Planet is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with M2-Planet. If not, see
#elif __i386__
#include
#elif __x86_64__
#include
#elif __arm__
#include
#elif __aarch64__
#include
#elif __riscv && __riscv_xlen==32
#include
#elif __riscv && __riscv_xlen==64
#include
#elif __knight_posix__
#include
#elif __knight__
#include
#else
#error arch not supported
#endif
#else
extern int _open(char* name, int flag, int mode);
#endif
int errno;
int open(char* name, int flag, int mode)
{
int fd = _open(name, flag, mode);
if(0 > fd)
{
errno = -fd;
fd = -1;
}
return fd;
}
#endif
mescc-tools-1.5.2/M2libc/fcntl.h 0000644 0000000 0000000 00000002214 14522760670 013234 0 ustar /* Copyright (C) 2016 Jeremiah Orians
* This file is part of M2-Planet.
*
* M2-Planet is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* M2-Planet is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with M2-Planet. If not, see
#else
#define O_RDONLY 0
#define O_WRONLY 1
#define O_RDWR 2
#define O_CREAT 00100
#define O_EXCL 00200
#define O_TRUNC 001000
#define O_APPEND 002000
#define S_IXUSR 00100
#define S_IWUSR 00200
#define S_IRUSR 00400
#define S_IRWXU 00700
extern int open(char* name, int flag, int mode);
#define STDIN_FILENO 0
#define STDOUT_FILENO 1
#define STDERR_FILENO 2
#endif
#endif
mescc-tools-1.5.2/M2libc/gcc_req.h 0000644 0000000 0000000 00000001351 14522760670 013532 0 ustar /* Copyright (C) 2016 Jeremiah Orians
* This file is part of M2-Planet.
*
* M2-Planet is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* M2-Planet is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with M2-Planet. If not, see
### This file is part of M2-Planet.
###
### M2-Planet is free software: you can redistribute it and/or modify
### it under the terms of the GNU General Public License as published by
### the Free Software Foundation, either version 3 of the License, or
### (at your option) any later version.
###
### M2-Planet is distributed in the hope that it will be useful,
### but WITHOUT ANY WARRANTY; without even the implied warranty of
### MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
### GNU General Public License for more details.
###
### You should have received a copy of the GNU General Public License
### along with M2-Planet. If not, see 1 byte relative
### $ 2 byte address
### @ 2 byte relative
### & 4 byte address
### % 4 byte relative
### if you wish to use this header, you need to add :ELF_end to the end of your
### M1 or hex2 files.
mescc-tools-1.5.2/M2libc/knight/knight-native_defs.M1 0000644 0000000 0000000 00000012514 14522760670 017215 0 ustar ## Copyright (C) 2016 Jeremiah Orians
## This file is part of stage0.
##
## stage0 is free software: you can redistribute it and/or modify
## it under the terms of the GNU General Public License as published by
## the Free Software Foundation, either version 3 of the License, or
## (at your option) any later version.
##
## stage0 is distributed in the hope that it will be useful,
## but WITHOUT ANY WARRANTY; without even the implied warranty of
## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
## GNU General Public License for more details.
##
## You should have received a copy of the GNU General Public License
## along with stage0. If not, see
#define S_IRWXU 00700
#define S_IXUSR 00100
#define S_IWUSR 00200
#define S_IRUSR 00400
#define S_ISUID 04000
#define S_ISGID 02000
#define S_IXGRP 00010
#define S_IXOTH 00001
#define S_IRGRP 00040
#define S_IROTH 00004
#define S_IWGRP 00020
#define S_IWOTH 00002
#define S_IRWXG 00070
#define S_IRWXO 00007
int chmod(char *pathname, int mode)
{
asm("LOAD R0 R14 0"
"LOAD R1 R14 4"
"SYS_CHMOD");
}
int fchmod(int a, mode_t b)
{
asm("LOAD R0 R14 0"
"LOAD R1 R14 4"
"SYS_FCHMOD");
}
int mkdir(char const* a, mode_t b)
{
asm("LOAD R0 R14 0"
"LOAD R1 R14 4"
"SYS_MKDIR");
}
int mknod(char const* a, mode_t b, dev_t c)
{
asm("LOAD R0 R14 0"
"LOAD R1 R14 4"
"LOAD R2 R14 8"
"SYS_MKNOD");
}
mode_t umask(mode_t m)
{
asm("LOAD R0 R14 0"
"SYS_UMASK");
}
#endif
mescc-tools-1.5.2/M2libc/knight/linux/unistd.c 0000644 0000000 0000000 00000006201 14522760670 016052 0 ustar /* Copyright (C) 2020 Jeremiah Orians
* This file is part of M2-Planet.
*
* M2-Planet is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* M2-Planet is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with M2-Planet. If not, see
#define S_IRWXU 00700
#define S_IXUSR 00100
#define S_IWUSR 00200
#define S_IRUSR 00400
#define S_ISUID 0400
#define S_ISGID 02000
#define S_IXGRP 00010
#define S_IXOTH 00001
#define S_IRGRP 00040
#define S_IROTH 00004
#define S_IWGRP 00020
#define S_IWOTH 00002
#define S_IRWXG 00070
#define S_IRWXO 00007
int chmod(char *pathname, int mode)
{
/* Completely meaningless on bare metal*/
return 0;
}
int fchmod(int a, mode_t b)
{
/* Completely meaningless on bare metal*/
return 0;
}
int mkdir(char const* a, mode_t b)
{
/* Completely meaningless on bare metal*/
return 0;
}
int mknod(char const* a, mode_t b, dev_t c)
{
/* Completely meaningless on bare metal*/
return 0;
}
mode_t umask(mode_t m)
{
/* Completely meaningless on bare metal*/
return 0;
}
mescc-tools-1.5.2/M2libc/knight/native/unistd.c 0000644 0000000 0000000 00000006312 14522760670 016204 0 ustar /* Copyright (C) 2020 Jeremiah Orians
* Copyright (C) 2021 Andrius Štikonas
* This file is part of M2-Planet.
*
* M2-Planet is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* M2-Planet is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with M2-Planet. If not, see
### This file is part of M2-Planet.
###
### M2-Planet is free software: you can redistribute it and/or modify
### it under the terms of the GNU General Public License as published by
### the Free Software Foundation, either version 3 of the License, or
### (at your option) any later version.
###
### M2-Planet is distributed in the hope that it will be useful,
### but WITHOUT ANY WARRANTY; without even the implied warranty of
### MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
### GNU General Public License for more details.
###
### You should have received a copy of the GNU General Public License
### along with M2-Planet. If not, see
### This file is part of M2-Planet.
###
### M2-Planet is free software: you can redistribute it and/or modify
### it under the terms of the GNU General Public License as published by
### the Free Software Foundation, either version 3 of the License, or
### (at your option) any later version.
###
### M2-Planet is distributed in the hope that it will be useful,
### but WITHOUT ANY WARRANTY; without even the implied warranty of
### MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
### GNU General Public License for more details.
###
### You should have received a copy of the GNU General Public License
### along with M2-Planet. If not, see
#define S_IRWXU 00700
#define S_IXUSR 00100
#define S_IWUSR 00200
#define S_IRUSR 00400
#define S_ISUID 04000
#define S_ISGID 02000
#define S_IXGRP 00010
#define S_IXOTH 00001
#define S_IRGRP 00040
#define S_IROTH 00004
#define S_IWGRP 00020
#define S_IWOTH 00002
#define S_IRWXG 00070
#define S_IRWXO 00007
int chmod(char *pathname, int mode)
{
asm("rd_a0 !-100 addi" /* AT_FDCWD */
"rd_a1 rs1_fp !-4 lw"
"rd_a2 rs1_fp !-8 lw"
"rd_a7 !53 addi"
"ecall");
}
int fchmod(int a, mode_t b)
{
asm("rd_a0 !-100 addi" /* AT_FDCWD */
"rd_a1 rs1_fp !-4 lw"
"rd_a2 rs1_fp !-8 lw"
"rd_a7 !52 addi"
"ecall");
}
int mkdir(char const* a, mode_t b)
{
asm("rd_a0 !-100 addi" /* AT_FDCWD */
"rd_a1 rs1_fp !-4 lw"
"rd_a2 rs1_fp !-8 lw"
"rd_a7 !34 addi"
"ecall");
}
int mknod(char const* a, mode_t b, dev_t c)
{
asm("rd_a0 !-100 addi" /* AT_FDCWD */
"rd_a1 rs1_fp !-4 lw"
"rd_a2 rs1_fp !-8 lw"
"rd_a3 rs1_fp !-12 lw"
"rd_a7 !33 addi"
"ecall");
}
mode_t umask(mode_t m)
{
asm("rd_a0 rs1_fp !-4 lw"
"rd_a7 !166 addi"
"ecall");
}
#endif
mescc-tools-1.5.2/M2libc/riscv32/linux/unistd.c 0000644 0000000 0000000 00000011514 14522760670 016064 0 ustar /* Copyright (C) 2020 Jeremiah Orians
* Copyright (C) 2021 Andrius Štikonas
* This file is part of M2-Planet.
*
* M2-Planet is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* M2-Planet is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with M2-Planet. If not, see
#define NULL 0
#define __PATH_MAX 4096
#define P_PID 1
#define WEXITED 4
#define __SI_SWAP_ERRNO_CODE
void* malloc(unsigned size);
int access(char* pathname, int mode)
{
asm("rd_a0 !-100 addi" /* AT_FDCWD */
"rd_a1 rs1_fp !-4 lw"
"rd_a2 rs1_fp !-8 lw"
"rd_a3 addi" /* flags = 0 */
"rd_a7 !48 addi"
"ecall");
}
int chdir(char* path)
{
asm("rd_a0 rs1_fp !-4 lw"
"rd_a7 !49 addi"
"ecall");
}
int fchdir(int fd)
{
asm("rd_a0 rs1_fp !-4 lw"
"rd_a7 !50 addi"
"ecall");
}
void _exit(int value);
int fork()
{
asm("rd_a7 !220 addi"
"rd_a0 !17 addi" /* SIGCHLD */
"rd_a1 mv" /* Child uses duplicate of parent's stack */
"ecall");
}
int waitid(int idtype, int id, struct siginfo_t *infop, int options, void *rusage)
{
asm("rd_a0 rs1_fp !-4 lw"
"rd_a1 rs1_fp !-8 lw"
"rd_a2 rs1_fp !-12 lw"
"rd_a3 rs1_fp !-16 lw"
"rd_a4 rs1_fp !-20 lw"
"rd_a7 !95 addi"
"ecall");
}
void* calloc(int count, int size);
void free(void* l);
struct siginfo_t *__waitpid_info;
int waitpid(int pid, int* status_ptr, int options)
{
if(NULL == __waitpid_info) __waitpid_info = calloc(1, sizeof(struct siginfo_t));
int r = waitid(P_PID, pid, __waitpid_info, options|WEXITED, NULL);
if(__waitpid_info->si_pid != 0)
{
int sw = 0;
if(__waitpid_info->si_code == CLD_EXITED)
{
sw = (__waitpid_info->si_status & 0xff) << 8;
}
else if(__waitpid_info->si_code == CLD_KILLED)
{
sw = __waitpid_info->si_status & 0x7f;
}
else if(__waitpid_info->si_code == CLD_DUMPED)
{
sw = (__waitpid_info->si_status & 0x7f) | 0x80;
}
else if(__waitpid_info->si_code == CLD_CONTINUED)
{
sw = 0xffff;
}
else if(__waitpid_info->si_code == CLD_STOPPED || __waitpid_info->si_code == CLD_TRAPPED)
{
sw = ((__waitpid_info->si_status & 0xff) << 8) + 0x7f;
}
if(status_ptr != NULL) *status_ptr = sw;
}
int rval = __waitpid_info->si_pid;
if(r < 0)
{
return r;
}
return rval;
}
int execve(char* file_name, char** argv, char** envp)
{
asm("rd_a0 rs1_fp !-4 lw"
"rd_a1 rs1_fp !-8 lw"
"rd_a2 rs1_fp !-12 lw"
"rd_a7 !221 addi"
"ecall");
}
int read(int fd, char* buf, unsigned count)
{
asm("rd_a0 rs1_fp !-4 lw"
"rd_a1 rs1_fp !-8 lw"
"rd_a2 rs1_fp !-12 lw"
"rd_a7 !63 addi"
"ecall");
}
int write(int fd, char* buf, unsigned count)
{
asm("rd_a0 rs1_fp !-4 lw"
"rd_a1 rs1_fp !-8 lw"
"rd_a2 rs1_fp !-12 lw"
"rd_a7 !64 addi"
"ecall");
}
int llseek(int fd, int offset_high, int offset_low, int result, int whence)
{
asm("rd_a0 rs1_fp !-4 lw"
"rd_a1 rs1_fp !-8 lw"
"rd_a2 rs1_fp !-12 lw"
"rd_a3 rs1_fp !-16 lw"
"rd_a4 rs1_fp !-20 lw"
"rd_a7 !62 addi"
"ecall");
}
int lseek(int fd, int offset, int whence)
{
int result;
if(llseek(fd, offset >> 32, offset, &result, whence))
{
return -1;
}
return result;
}
int close(int fd)
{
asm("rd_a0 rs1_fp !-4 lw"
"rd_a7 !57 addi" /* close */
"ecall");
}
int unlink (char* filename)
{
asm("rd_a0 !-100 addi" /* AT_FDCWD */
"rd_a1 rs1_fp !-4 lw"
"rd_a2 !0 addi" /* No flags */
"rd_a7 !35 addi" /* unlinkat */
"ecall");
}
int _getcwd(char* buf, int size)
{
asm("rd_a0 rs1_fp !-4 lw"
"rd_a1 rs1_fp !-8 lw"
"rd_a7 !17 addi"
"ecall");
}
char* getcwd(char* buf, unsigned size)
{
int c = _getcwd(buf, size);
if(0 == c) return NULL;
return buf;
}
char* getwd(char* buf)
{
return getcwd(buf, __PATH_MAX);
}
char* get_current_dir_name()
{
return getcwd(malloc(__PATH_MAX), __PATH_MAX);
}
int brk(void *addr)
{
asm("rd_a0 rs1_fp !-4 lw"
"rd_a7 !214 addi"
"ecall");
}
struct utsname
{
char sysname[65]; /* Operating system name (e.g., "Linux") */
char nodename[65]; /* Name within "some implementation-defined network" */
char release[65]; /* Operating system release (e.g., "2.6.28") */
char version[65]; /* Operating system version */
char machine[65]; /* Hardware identifier */
};
int uname(struct utsname* unameData)
{
asm("rd_a0 rs1_fp !-4 lw"
"rd_a7 !160 addi"
"ecall");
}
#endif
mescc-tools-1.5.2/M2libc/riscv32/riscv32_defs.M1 0000644 0000000 0000000 00000012514 14522760670 015747 0 ustar ## Copyright (C) 2021 Andrius Štikonas
## This file is part of M2-Planet.
##
## M2-Planet is free software: you can redistribute it and/or modify
## it under the terms of the GNU General Public License as published by
## the Free Software Foundation, either version 3 of the License, or
## (at your option) any later version.
##
## M2-Planet is distributed in the hope that it will be useful,
## but WITHOUT ANY WARRANTY; without even the implied warranty of
## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
## GNU General Public License for more details.
##
## You should have received a copy of the GNU General Public License
## along with M2-Planet. If not, see
### This file is part of M2-Planet.
###
### M2-Planet is free software: you can redistribute it and/or modify
### it under the terms of the GNU General Public License as published by
### the Free Software Foundation, either version 3 of the License, or
### (at your option) any later version.
###
### M2-Planet is distributed in the hope that it will be useful,
### but WITHOUT ANY WARRANTY; without even the implied warranty of
### MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
### GNU General Public License for more details.
###
### You should have received a copy of the GNU General Public License
### along with M2-Planet. If not, see
### This file is part of M2-Planet.
###
### M2-Planet is free software: you can redistribute it and/or modify
### it under the terms of the GNU General Public License as published by
### the Free Software Foundation, either version 3 of the License, or
### (at your option) any later version.
###
### M2-Planet is distributed in the hope that it will be useful,
### but WITHOUT ANY WARRANTY; without even the implied warranty of
### MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
### GNU General Public License for more details.
###
### You should have received a copy of the GNU General Public License
### along with M2-Planet. If not, see
#define S_IRWXU 00700
#define S_IXUSR 00100
#define S_IWUSR 00200
#define S_IRUSR 00400
#define S_ISUID 04000
#define S_ISGID 02000
#define S_IXGRP 00010
#define S_IXOTH 00001
#define S_IRGRP 00040
#define S_IROTH 00004
#define S_IWGRP 00020
#define S_IWOTH 00002
#define S_IRWXG 00070
#define S_IRWXO 00007
int chmod(char *pathname, int mode)
{
asm("rd_a0 !-100 addi" /* AT_FDCWD */
"rd_a1 rs1_fp !-8 ld"
"rd_a2 rs1_fp !-16 ld"
"rd_a7 !53 addi"
"ecall");
}
int fchmod(int a, mode_t b)
{
asm("rd_a0 !-100 addi" /* AT_FDCWD */
"rd_a1 rs1_fp !-8 ld"
"rd_a2 rs1_fp !-16 ld"
"rd_a7 !52 addi"
"ecall");
}
int mkdir(char const* a, mode_t b)
{
asm("rd_a0 !-100 addi" /* AT_FDCWD */
"rd_a1 rs1_fp !-8 ld"
"rd_a2 rs1_fp !-16 ld"
"rd_a7 !34 addi"
"ecall");
}
int mknod(char const* a, mode_t b, dev_t c)
{
asm("rd_a0 !-100 addi" /* AT_FDCWD */
"rd_a1 rs1_fp !-8 ld"
"rd_a2 rs1_fp !-16 ld"
"rd_a3 rs1_fp !-24 ld"
"rd_a7 !33 addi"
"ecall");
}
mode_t umask(mode_t m)
{
asm("rd_a0 rs1_fp !-8 ld"
"rd_a7 !166 addi"
"ecall");
}
#endif
mescc-tools-1.5.2/M2libc/riscv64/linux/unistd.c 0000644 0000000 0000000 00000007051 14522760670 016072 0 ustar /* Copyright (C) 2020 Jeremiah Orians
* Copyright (C) 2021 Andrius Štikonas
* This file is part of M2-Planet.
*
* M2-Planet is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* M2-Planet is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with M2-Planet. If not, see
#define NULL 0
typedef long ptrdiff_t;
typedef ulong size_t;
#endif
mescc-tools-1.5.2/M2libc/stdio.c 0000644 0000000 0000000 00000017347 14522760670 013260 0 ustar /* Copyright (C) 2016 Jeremiah Orians
* This file is part of M2-Planet.
*
* M2-Planet is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* M2-Planet is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with M2-Planet. If not, see
#include
#include
#include
#include
#include
/* Required constants */
/* For file I/O*/
#define EOF 0xFFFFFFFF
#define BUFSIZ 0x1000
/* For lseek */
#define SEEK_SET 0
#define SEEK_CUR 1
#define SEEK_END 2
/* Required variables */
FILE* stdin;
FILE* stdout;
FILE* stderr;
FILE* __list;
void __init_io()
{
__list = NULL;
stdin = calloc(1, sizeof(FILE));
stdin->fd = STDIN_FILENO;
stdin->bufmode = O_RDONLY;
stdin->buflen = 1;
stdin->buffer = calloc(2, sizeof(char));
stdout = calloc(1, sizeof(FILE));
stdout->fd = STDOUT_FILENO;
stdout->bufmode = O_WRONLY;
stdout->buflen = 512;
stdout->buffer = calloc(514, sizeof(char));
stderr = calloc(1, sizeof(FILE));
stderr->fd = STDERR_FILENO;
stderr->bufmode = O_WRONLY;
stderr->buflen = 512;
stderr->buffer = calloc(514, sizeof(char));
}
/* Flush all IO on exit */
int fflush(FILE* stream);
void __kill_io()
{
fflush(stdout);
fflush(stderr);
while(NULL != __list)
{
fflush(__list);
__list = __list->next;
}
}
/* Standard C functions */
/* Getting */
int read(int fd, char* buf, unsigned count);
int fgetc(FILE* f)
{
/* Only read on read buffers */
if(O_WRONLY == f->bufmode) return EOF;
/* Deal with stdin */
if(STDIN_FILENO == f->fd)
{
f->bufpos = 0;
int r = read(f->fd, f->buffer, 1);
/* Catch special case of STDIN gets nothing (AN EOF) */
if(0 == r) return EOF;
}
/* Catch EOF */
if(f->buflen <= f->bufpos) return EOF;
/* Deal with standard case */
int ret = f->buffer[f->bufpos];
f->bufpos = f->bufpos + 1;
/* Ensure 0xFF doesn't return EOF */
return (ret & 0xFF);
}
size_t fread( void* buffer, size_t size, size_t count, FILE* stream )
{
if(0 == size) return 0;
if(0 == count) return 0;
long n = size + count - 1;
char* p = buffer;
long i;
unsigned c;
for(i = 0; i < n; i = i + 1)
{
c = fgetc(stream);
if(EOF == c) return (i/size);
p[i] = c;
}
return (i/size);
}
int getchar()
{
return fgetc(stdin);
}
char* fgets(char* str, int count, FILE* stream)
{
int i = 0;
int ch;
while(i < count)
{
ch = fgetc(stream);
if(EOF == ch) break;
str[i] = ch;
i = i + 1;
if('\n' == ch) break;
}
return str;
}
/* Putting */
void fputc(char s, FILE* f)
{
/* Only write on write buffers */
if(O_RDONLY == f->bufmode) return;
/* Add to buffer */
f->buffer[f->bufpos] = s;
f->bufpos = f->bufpos + 1;
/* Flush if full or '\n' */
if(f->bufpos == f->buflen) fflush(f);
else if(('\n' == s) && (2 >= f->fd)) fflush(f);
}
size_t fwrite(void const* buffer, size_t size, size_t count, FILE* stream )
{
long n = size * count;
if(0 == n) return 0;
char* p = buffer;
int c;
long i;
for(i=0; i < n; i = i + 1)
{
c = p[i];
fputc(c, stream);
}
return (i/size);
}
void putchar(char s)
{
fputc(s, stdout);
}
int fputs(char const* str, FILE* stream)
{
while(0 != str[0])
{
fputc(str[0], stream);
str = str + 1;
}
return 0;
}
int puts(char const* str)
{
fputs(str, stdout);
fputc('\n', stdout);
return 0;
}
int lseek(int fd, int offset, int whence);
/* File management */
FILE* fopen(char const* filename, char const* mode)
{
int f;
FILE* fi = calloc(1, sizeof(FILE));
fi->next = __list;
if(NULL != __list) __list->prev = fi;
__list = fi;
int size;
if('w' == mode[0]) f = open(filename, O_WRONLY|O_CREAT|O_TRUNC, 00600);
else f = open(filename, 0, 0); /* Everything else is a read */
/* Negative numbers are error codes */
if(0 > f)
{
return 0;
}
if('w' == mode[0])
{
/* Buffer as much as possible */
fi->buffer = malloc(BUFSIZ * sizeof(char));
fi->buflen = BUFSIZ;
fi->bufmode = O_WRONLY;
}
else
{
/* Get enough buffer to read it all */
size = lseek(f, 0, SEEK_END);
fi->buffer = malloc((size + 1) * sizeof(char));
fi->buflen = size;
fi->bufmode = O_RDONLY;
/* Now read it all */
lseek(f, 0, SEEK_SET);
read(f, fi->buffer, size);
}
fi->fd = f;
return fi;
}
FILE* fdopen(int fd, char* mode)
{
FILE* fi = calloc(1, sizeof(FILE));
fi->next = __list;
if(NULL != __list) __list->prev = fi;
__list = fi;
int size;
if('w' == mode[0])
{
/* Buffer as much as possible */
fi->buffer = malloc(BUFSIZ * sizeof(char));
fi->buflen = BUFSIZ;
fi->bufmode = O_WRONLY;
}
else
{
/* Get enough buffer to read it all */
size = lseek(fd, 0, SEEK_END);
fi->buffer = malloc((size + 1) * sizeof(char));
fi->buflen = size;
fi->bufmode = O_RDONLY;
/* Now read it all */
lseek(fd, 0, SEEK_SET);
read(fd, fi->buffer, size);
}
fi->fd = fd;
return fi;
}
int write(int fd, char* buf, unsigned count);
int fflush(FILE* stream)
{
/* We only need to flush on writes */
if(O_RDONLY == stream->bufmode) return 0;
/* If nothing to flush */
if(0 ==stream->bufpos) return 0;
/* The actual flushing */
int error = write(stream->fd, stream->buffer, stream->bufpos);
/* Keep track of position */
stream->file_pos = stream->file_pos + stream->bufpos;
stream->bufpos = 0;
return error;
}
int close(int fd);
int fclose(FILE* stream)
{
/* Deal with STDIN, STDOUT and STDERR */
/* No close for you */
if(2 >= stream->fd) return 0;
/* We only need to flush on writes */
if(O_WRONLY == stream->bufmode)
{
fflush(stream);
}
/* Need to keep the File Descriptor for a moment */
int fd = stream->fd;
/* Remove from __list */
if(NULL != stream->prev) stream->prev->next = stream->next;
if(NULL != stream->next) stream->next->prev = stream->prev;
/* Deal with special case of first node in __list */
if (__list == stream) __list = __list->next;
/* Free up the buffer and struct used for FILE */
free(stream->buffer);
free(stream);
/* Do the actual closing */
return close(fd);
}
int unlink(char* filename);
/* File Removal */
int remove(char *pathname)
{
return unlink(pathname);
}
/* File Positioning */
int ungetc(int ch, FILE* stream)
{
/* Deal with STDIN, STDOUT and STDERR */
/* No ungetc for you */
if(2 >= stream->fd) return EOF;
/* You can't unget on a write stream! */
if(O_WRONLY == stream->bufmode) return EOF;
/* Don't underflow */
if(0 == stream->bufpos) return EOF;
/* Don't let crap be shoved into read stream */
if(stream->buffer[stream->bufpos - 1] != ch) return EOF;
stream->bufpos = stream->bufpos - 1;
return ch;
}
long ftell(FILE* stream)
{
/* Deal with STDIN, STDOUT and STDERR */
/* No ftell for you */
if(2 >= stream->fd) return 0;
/* Deal with buffered output */
if(O_WRONLY == stream->bufmode) return stream->file_pos + stream->bufpos;
/* Deal with read */
return stream->bufpos;
}
int fseek(FILE* f, long offset, int whence)
{
/* Deal with STDIN, STDOUT and STDERR */
/* No seek and destroy missions */
if(2 >= f->fd) return 0;
/* Deal with ugly case */
if(O_WRONLY == f->bufmode)
{
fflush(f);
return lseek(f->fd, offset, whence);
}
/* Deal with read mode */
int pos;
if(SEEK_SET == whence)
{
pos = offset;
}
else if(SEEK_CUR == whence)
{
pos = f->bufpos + offset;
}
else if(SEEK_END == whence)
{
pos = f->buflen + offset;
}
else return -1;
if(pos < 0) return -1;
if(pos > f->buflen) return -1;
f->bufpos = pos;
return pos;
}
void rewind(FILE* f)
{
fseek(f, 0, SEEK_SET);
}
mescc-tools-1.5.2/M2libc/stdio.h 0000644 0000000 0000000 00000004640 14522760670 013255 0 ustar /* Copyright (C) 2016 Jeremiah Orians
* This file is part of M2-Planet.
*
* M2-Planet is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* M2-Planet is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with M2-Planet. If not, see
#else
#include
#include
#include
#include
#include
/* Required constants */
/* For file I/O*/
#define EOF -1
#define BUFSIZ 4096
/* For lseek */
#define SEEK_SET 0
#define SEEK_CUR 1
#define SEEK_END 2
/* Actual format of FILE */
struct __IO_FILE
{
int fd;
int bufmode; /* 0 = no buffer, 1 = read, 2 = write */
int bufpos;
int buflen;
char* buffer;
};
/* Now give us the FILE we all love */
typedef struct __IO_FILE FILE;
/* Required variables */
extern FILE* stdin;
extern FILE* stdout;
extern FILE* stderr;
/* Standard C functions */
/* Getting */
extern int fgetc(FILE* f);
extern int getchar();
extern char* fgets(char* str, int count, FILE* stream);
extern size_t fread( void* buffer, size_t size, size_t count, FILE* stream );
/* Putting */
extern void fputc(char s, FILE* f);
extern void putchar(char s);
extern int fputs(char const* str, FILE* stream);
extern int puts(char const* str);
extern size_t fwrite(void const* buffer, size_t size, size_t count, FILE* stream );
/* File management */
extern FILE* fopen(char const* filename, char const* mode);
extern int fclose(FILE* stream);
extern int fflush(FILE* stream);
/* File Positioning */
extern int ungetc(int ch, FILE* stream);
extern long ftell(FILE* stream);
extern int fseek(FILE* f, long offset, int whence);
extern void rewind(FILE* f);
#endif
#endif
mescc-tools-1.5.2/M2libc/stdlib.c 0000644 0000000 0000000 00000030416 14522760670 013407 0 ustar /* Copyright (C) 2016 Jeremiah Orians
* This file is part of M2-Planet.
*
* M2-Planet is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* M2-Planet is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with M2-Planet. If not, see
#include
#include
#define EXIT_FAILURE 1
#define EXIT_SUCCESS 0
#define _IN_USE 1
#define _NOT_IN_USE 0
typedef char wchar_t;
void exit(int value);
struct _malloc_node
{
struct _malloc_node *next;
void* block;
size_t size;
int used;
};
struct _malloc_node* _allocated_list;
struct _malloc_node* _free_list;
/********************************
* The core POSIX malloc *
********************************/
long _malloc_ptr;
long _brk_ptr;
void* _malloc_brk(unsigned size)
{
if(NULL == _brk_ptr)
{
_brk_ptr = brk(0);
_malloc_ptr = _brk_ptr;
}
if(_brk_ptr < _malloc_ptr + size)
{
_brk_ptr = brk(_malloc_ptr + size);
if(-1 == _brk_ptr) return 0;
}
long old_malloc = _malloc_ptr;
_malloc_ptr = _malloc_ptr + size;
return old_malloc;
}
void __init_malloc()
{
_free_list = NULL;
_allocated_list = NULL;
return;
}
/************************************************************************
* Handle with the tricky insert behaviors for our nodes *
* As free lists must be sorted from smallest to biggest to enable *
* cheap first fit logic *
* The free function however is rarely called, so it can kick sand and *
* do things the hard way *
************************************************************************/
void _malloc_insert_block(struct _malloc_node* n, int used)
{
/* Allocated block doesn't care about order */
if(_IN_USE == used)
{
/* Literally just be done as fast as possible */
n->next = _allocated_list;
_allocated_list = n;
return;
}
/* sanity check garbage */
if(_NOT_IN_USE != used) exit(EXIT_FAILURE);
if(_NOT_IN_USE != n->used) exit(EXIT_FAILURE);
if(NULL != n->next) exit(EXIT_FAILURE);
/* Free block really does care about order */
struct _malloc_node* i = _free_list;
struct _malloc_node* last = NULL;
while(NULL != i)
{
/* sort smallest to largest */
if(n->size <= i->size)
{
/* Connect */
n->next = i;
/* If smallest yet */
if(NULL == last) _free_list = n;
/* or just another average block */
else last->next = n;
return;
}
/* iterate */
last = i;
i = i->next;
}
/* looks like we are the only one */
if(NULL == last) _free_list = n;
/* or we are the biggest yet */
else last->next = n;
}
/************************************************************************
* We only mark a block as unused, we don't actually deallocate it here *
* But rather shove it into our _free_list *
************************************************************************/
void free(void* ptr)
{
/* just in case someone needs to quickly turn it off */
#ifndef _MALLOC_DISABLE_FREE
struct _malloc_node* i = _allocated_list;
struct _malloc_node* last = NULL;
/* walk the whole freaking list if needed to do so */
while(NULL != i)
{
/* did we find it? */
if(i->block == ptr)
{
/* detach the block */
if(NULL == last) _allocated_list = i->next;
/* in a way that doesn't break the allocated list */
else last->next = i->next;
/* insert into free'd list */
i->used = _NOT_IN_USE;
i->next = NULL;
_malloc_insert_block(i, _NOT_IN_USE);
return;
}
/* iterate */
last = i;
i = i->next;
}
/* we received a pointer to a block that wasn't allocated */
/* Bail *HARD* because I don't want to cover this edge case */
exit(EXIT_FAILURE);
#endif
/* if free is disabled, there is nothing to do */
return;
}
/************************************************************************
* find if there is any "FREED" blocks big enough to sit on our memory *
* budget's face and ruin its life. Respectfully of course *
************************************************************************/
void* _malloc_find_free(unsigned size)
{
struct _malloc_node* i = _free_list;
struct _malloc_node* last = NULL;
/* Walk the whole list if need be */
while(NULL != i)
{
/* see if anything in it is equal or bigger than what I need */
if((_NOT_IN_USE == i->used) && (i->size > size))
{
/* disconnect from list ensuring we don't break free doing so */
if(NULL == last) _free_list = i->next;
else last->next = i->next;
/* insert into allocated list */
i->used = _IN_USE;
i->next = NULL;
_malloc_insert_block(i, _IN_USE);
return i->block;
}
/* iterate (will loop forever if you get this wrong) */
last = i;
i = i->next;
}
/* Couldn't find anything big enough */
return NULL;
}
/************************************************************************
* Well we couldn't find any memory good enough to satisfy our needs so *
* we are going to have to go beg for some memory on the street corner *
************************************************************************/
void* _malloc_add_new(unsigned size)
{
struct _malloc_node* n;
#ifdef __uefi__
n = _malloc_uefi(sizeof(struct _malloc_node));
/* Check if we were beaten */
if(NULL == n) return NULL;
n->block = _malloc_uefi(size);
#else
n = _malloc_brk(sizeof(struct _malloc_node));
/* Check if we were beaten */
if(NULL == n) return NULL;
n->block = _malloc_brk(size);
#endif
/* check if we were robbed */
if(NULL == n->block) return NULL;
/* Looks like we made it home safely */
n->size = size;
n->next = NULL;
n->used = _IN_USE;
/* lets pop the cork and party */
_malloc_insert_block(n, _IN_USE);
return n->block;
}
/************************************************************************
* Safely iterates over all malloc nodes and frees them *
************************************************************************/
void __malloc_node_iter(struct _malloc_node* node, FUNCTION _free)
{
struct _malloc_node* current;
while(node != NULL)
{
current = node;
node = node->next;
_free(current->block);
_free(current);
}
}
/************************************************************************
* Runs a callback with all previously allocated nodes. *
* This can be useful if operating system does not do any clean up. *
************************************************************************/
void* _malloc_release_all(FUNCTION _free)
{
__malloc_node_iter(_allocated_list, _free);
__malloc_node_iter(_free_list, _free);
}
/************************************************************************
* Provide a POSIX standardish malloc function to keep things working *
************************************************************************/
void* malloc(unsigned size)
{
/* skip allocating nothing */
if(0 == size) return NULL;
/* use one of the standard block sizes */
size_t max = 1 << 30;
size_t used = 256;
while(used < size)
{
used = used << 1;
/* fail big allocations */
if(used > max) return NULL;
}
/* try the cabinets around the house */
void* ptr = _malloc_find_free(used);
/* looks like we need to get some more from the street corner */
if(NULL == ptr)
{
ptr = _malloc_add_new(used);
}
/* hopefully you can handle NULL pointers, good luck */
return ptr;
}
/************************************************************************
* Provide a POSIX standardish memset function to keep things working *
************************************************************************/
void* memset(void* ptr, int value, int num)
{
char* s;
/* basically walk the block 1 byte at a time and set it to any value you want */
for(s = ptr; 0 < num; num = num - 1)
{
s[0] = value;
s = s + 1;
}
return ptr;
}
/************************************************************************
* Provide a POSIX standardish calloc function to keep things working *
************************************************************************/
void* calloc(int count, int size)
{
/* if things get allocated, we are good*/
void* ret = malloc(count * size);
/* otherwise good luck */
if(NULL == ret) return NULL;
memset(ret, 0, (count * size));
return ret;
}
/* USED EXCLUSIVELY BY MKSTEMP */
void __set_name(char* s, int i)
{
s[5] = '0' + (i % 10);
i = i / 10;
s[4] = '0' + (i % 10);
i = i / 10;
s[3] = '0' + (i % 10);
i = i / 10;
s[2] = '0' + (i % 10);
i = i / 10;
s[1] = '0' + (i % 10);
i = i / 10;
s[0] = '0' + i;
}
/************************************************************************
* Provide a POSIX standardish mkstemp function to keep things working *
************************************************************************/
int mkstemp(char *template)
{
/* get length of template */
int i = 0;
while(0 != template[i]) i = i + 1;
i = i - 1;
/* String MUST be more than 6 characters in length */
if(i < 6) return -1;
/* Sanity check the string matches the template requirements */
int count = 6;
int c;
while(count > 0)
{
c = template[i];
/* last 6 chars must be X */
if('X' != c) return -1;
template[i] = '0';
i = i - 1;
count = count - 1;
}
int fd = -1;
count = -1;
/* open will return -17 or other values */
while(0 > fd)
{
/* Just give up after the planet has blown up */
if(9000 < count) return -1;
/* Try up to 9000 unique filenames before stopping */
count = count + 1;
__set_name(template+i+1, count);
/* Pray we can */
fd = open(template, O_RDWR | O_CREAT | O_EXCL, 00600);
}
/* well that only took count many tries */
return fd;
}
/************************************************************************
* wcstombs - convert a wide-character string to a multibyte string *
* because seriously UEFI??? UTF-16 is a bad design choice but I guess *
* they were drinking pretty hard when they designed UEFI; it is DOS *
* but somehow they magically found ways of making it worse *
************************************************************************/
size_t wcstombs(char* dest, char* src, size_t n)
{
int i = 0;
do
{
/* UTF-16 is 2bytes per char and that first byte maps good enough to ASCII */
dest[i] = src[2 * i];
if(dest[i] == 0)
{
break;
}
i = i + 1;
n = n - 1;
} while (n != 0);
return i;
}
/************************************************************************
* getenv - get an environmental variable *
************************************************************************/
size_t _strlen(char const* str)
{
size_t i = 0;
while(0 != str[i]) i = i + 1;
return i;
}
int _strncmp(char const* lhs, char const* rhs, size_t count)
{
size_t i = 0;
while(count > i)
{
if(0 == lhs[i]) break;
if(lhs[i] != rhs[i]) return lhs[i] - rhs[i];
i = i + 1;
}
return 0;
}
char** _envp;
char* getenv (char const* name)
{
char** p = _envp;
char* q;
int length = _strlen(name);
while (p[0] != 0)
{
if(_strncmp(name, p[0], length) == 0)
{
q = p[0] + length;
if(q[0] == '=')
return q + 1;
}
p += sizeof(char**); /* M2 pointer arithemtic */
}
return 0;
}
/************************************************************************
* setenv - set an environmental variable *
************************************************************************/
char* _strcpy(char* dest, char const* src)
{
int i = 0;
while (0 != src[i])
{
dest[i] = src[i];
i = i + 1;
}
dest[i] = 0;
return dest;
}
int setenv(char const *s, char const *v, int overwrite_p)
{
char** p = _envp;
int length = _strlen(s);
char* q;
while (p[0] != 0)
{
if (_strncmp (s, p[0], length) == 0)
{
q = p[0] + length;
if (q[0] == '=')
break;
}
p += sizeof(char**); /* M2 pointer arithemtic */
}
char *entry = malloc (length + _strlen(v) + 2);
int end_p = p[0] == 0;
p[0] = entry;
_strcpy(entry, s);
_strcpy(entry + length, "=");
_strcpy(entry + length + 1, v);
entry[length + _strlen(v) + 2] = 0;
if (end_p != 0)
p[1] = 0;
return 0;
}
mescc-tools-1.5.2/M2libc/stdlib.h 0000644 0000000 0000000 00000002275 14522760670 013416 0 ustar /* Copyright (C) 2016 Jeremiah Orians
* This file is part of M2-Planet.
*
* M2-Planet is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* M2-Planet is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with M2-Planet. If not, see
#ifdef __M2__
#include
#else
#define EXIT_FAILURE 1
#define EXIT_SUCCESS 0
extern void exit(int value);
extern long _malloc_ptr;
extern long _brk_ptr;
extern void free(void* l);
extern void* malloc(unsigned size);
extern void* memset(void* ptr, int value, int num);
extern void* calloc(int count, int size);
extern char *getenv(const char *name);
size_t wcstombs(char* dest, const wchar_t* src, size_t n);
#endif
#endif
mescc-tools-1.5.2/M2libc/string.c 0000644 0000000 0000000 00000007710 14522760670 013435 0 ustar /* Copyright (C) 2016 Jeremiah Orians
* This file is part of M2-Planet.
*
* M2-Planet is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* M2-Planet is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with M2-Planet. If not, see
char* strcpy(char* dest, char const* src)
{
int i = 0;
while (0 != src[i])
{
dest[i] = src[i];
i = i + 1;
}
dest[i] = 0;
return dest;
}
char* strncpy(char* dest, char const* src, size_t count)
{
if(0 == count) return dest;
size_t i = 0;
while(0 != src[i])
{
dest[i] = src[i];
i = i + 1;
if(count == i) return dest;
}
while(i <= count)
{
dest[i] = 0;
i = i + 1;
}
return dest;
}
char* strcat(char* dest, char const* src)
{
int i = 0;
int j = 0;
while(0 != dest[i]) i = i + 1;
while(0 != src[j])
{
dest[i] = src[j];
i = i + 1;
j = j + 1;
}
dest[i] = 0;
return dest;
}
char* strncat(char* dest, char const* src, size_t count)
{
size_t i = 0;
size_t j = 0;
while(0 != dest[i]) i = i + 1;
while(0 != src[j])
{
if(count == j)
{
dest[i] = 0;
return dest;
}
dest[i] = src[j];
i = i + 1;
j = j + 1;
}
dest[i] = 0;
return dest;
}
size_t strlen(char const* str )
{
size_t i = 0;
while(0 != str[i]) i = i + 1;
return i;
}
size_t strnlen_s(char const* str, size_t strsz )
{
size_t i = 0;
while(0 != str[i])
{
if(strsz == i) return i;
i = i + 1;
}
return i;
}
int strcmp(char const* lhs, char const* rhs )
{
int i = 0;
while(0 != lhs[i])
{
if(lhs[i] != rhs[i]) return lhs[i] - rhs[i];
i = i + 1;
}
return lhs[i] - rhs[i];
}
int strncmp(char const* lhs, char const* rhs, size_t count)
{
size_t i = 0;
while(count > i)
{
if(0 == lhs[i]) break;
if(lhs[i] != rhs[i]) return lhs[i] - rhs[i];
i = i + 1;
}
return 0;
}
char* strchr(char const* str, int ch)
{
char* p = str;
while(ch != p[0])
{
if(0 == p[0]) return NULL;
p = p + 1;
}
if(0 == p[0]) return NULL;
return p;
}
char* strrchr(char const* str, int ch)
{
char* p = str;
int i = 0;
while(0 != p[i]) i = i + 1;
while(ch != p[i])
{
if(0 == i) return NULL;
i = i - 1;
}
return (p + i);
}
size_t strspn(char const* dest, char const* src)
{
if(0 == dest[0]) return 0;
int i = 0;
while(NULL != strchr(src, dest[i])) i = i + 1;
return i;
}
size_t strcspn(char const* dest, char const* src)
{
int i = 0;
while(NULL == strchr(src, dest[i])) i = i + 1;
return i;
}
char* strpbrk(char const* dest, char const* breakset)
{
char* p = dest;
char* s;
while(0 != p[0])
{
s = strchr(breakset, p[0]);
if(NULL != s) return strchr(p, s[0]);
p = p + 1;
}
return p;
}
void* memset(void* dest, int ch, size_t count)
{
if(NULL == dest) return dest;
size_t i = 0;
char* s = dest;
while(i < count)
{
s[i] = ch;
i = i + 1;
}
return dest;
}
void* memcpy(void* dest, void const* src, size_t count)
{
if(NULL == dest) return dest;
if(NULL == src) return NULL;
char* s1 = dest;
char const* s2 = src;
size_t i = 0;
while(i < count)
{
s1[i] = s2[i];
i = i + 1;
}
return dest;
}
void* memmove(void* dest, void const* src, size_t count)
{
if (dest < src) return memcpy (dest, src, count);
char *p = dest;
char const *q = src;
count = count - 1;
while (count >= 0)
{
p[count] = q[count];
count = count - 1;
}
return dest;
}
int memcmp(void const* lhs, void const* rhs, size_t count)
{
if(0 == count) return 0;
size_t i = 0;
count = count - 1;
char const* s1 = lhs;
char const* s2 = rhs;
while(i < count)
{
if(s1[i] != s2[i]) break;
i = i + 1;
}
return (s1[i] - s2[i]);
}
mescc-tools-1.5.2/M2libc/string.h 0000644 0000000 0000000 00000003425 14522760670 013441 0 ustar /* Copyright (C) 2016 Jeremiah Orians
* This file is part of M2-Planet.
*
* M2-Planet is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* M2-Planet is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with M2-Planet. If not, see
#else
#include
/* String manipulation */
char* strcpy(char* dest, char const* src);
char* strncpy(char* dest, char const* src, size_t count);
char* strcat(char* dest, char const* src);
char* strncat(char* dest, char const* src, size_t count);
/* String examination */
size_t strlen(char const* str );
size_t strnlen_s(char const* str, size_t strsz );
int strcmp(char const* lhs, char const* rhs );
int strncmp(char const* lhs, char const* rhs, size_t count);
char* strchr(char const* str, int ch);
char* strrchr(char const* str, int ch);
size_t strspn(char const* dest, char const* src);
size_t strcspn(char const* dest, char const* src);
char* strpbrk(char const* dest, char const* breakset);
/* Memory manipulation */
void* memset(void* dest, int ch, size_t count);
void* memcpy(void* dest, void const* src, size_t count);
void* memmove(void* dest, void const* src, size_t count);
int memcmp(void const* lhs, void const* rhs, size_t count);
void* memchr(void const* ptr, int ch, size_t count);
#endif
#endif
mescc-tools-1.5.2/M2libc/sys/ 0000755 0000000 0000000 00000000000 14522760670 012574 5 ustar mescc-tools-1.5.2/M2libc/sys/stat.h 0000644 0000000 0000000 00000003271 14522760670 013723 0 ustar /* Copyright (C) 2020 Jeremiah Orians
* This file is part of M2-Planet.
*
* M2-Planet is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* M2-Planet is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with M2-Planet. If not, see
#elif __i386__
#include
#elif __x86_64__
#include
#elif __arm__
#include
#elif __aarch64__
#include
#elif __riscv && __riscv_xlen==32
#include
#elif __riscv && __riscv_xlen==64
#include
#else
#error arch not supported
#endif
#else
#include
#define S_IRWXU 00700
#define S_IXUSR 00100
#define S_IWUSR 00200
#define S_IRUSR 00400
#define S_ISUID 04000
#define S_ISGID 02000
#define S_IXGRP 00010
#define S_IXOTH 00001
#define S_IRGRP 00040
#define S_IROTH 00004
#define S_IWGRP 00020
#define S_IWOTH 00002
#define S_IRWXG 00070
#define S_IRWXO 00007
int chmod(char *pathname, int mode);
int fchmod(int a, mode_t b);
int mkdir(char const* a, mode_t b);
int mknod(char const* a, mode_t b, dev_t c);
mode_t umask(mode_t m);
#endif
#endif
mescc-tools-1.5.2/M2libc/sys/types.h 0000644 0000000 0000000 00000001731 14522760670 014113 0 ustar /* Copyright (C) 2016 Jeremiah Orians
* This file is part of M2-Planet.
*
* M2-Planet is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* M2-Planet is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with M2-Planet. If not, see
void free(void* l);
int __open(struct efi_file_protocol* _rootdir, char* name, long mode, long attributes)
{
struct efi_file_protocol* new_handle;
char* wide_name = _posix_path_to_uefi(name);
unsigned rval = __uefi_5(_rootdir, &new_handle, wide_name, mode, attributes, _rootdir->open);
free(wide_name);
if(rval != EFI_SUCCESS)
{
return -1;
}
return new_handle;
}
int _open(char* name, int flag, int mode)
{
long mode = 0;
long attributes = 0;
if(flag == O_WRONLY|O_CREAT|O_TRUNC)
{
mode = EFI_FILE_MODE_CREATE | EFI_FILE_MODE_WRITE | EFI_FILE_MODE_READ;
}
else
{ /* Everything else is a read */
mode = EFI_FILE_MODE_READ;
attributes = EFI_FILE_READ_ONLY;
}
return __open(_rootdir, name, mode, attributes);
}
#define STDIN_FILENO 0
#define STDOUT_FILENO 1
#define STDERR_FILENO 2
#endif
mescc-tools-1.5.2/M2libc/uefi/string_p.h 0000644 0000000 0000000 00000007710 14522760670 014711 0 ustar /* Copyright (C) 2016 Jeremiah Orians
* This file is part of M2-Planet.
*
* M2-Planet is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* M2-Planet is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with M2-Planet. If not, see
char* strcpy(char* dest, char const* src)
{
int i = 0;
while (0 != src[i])
{
dest[i] = src[i];
i = i + 1;
}
dest[i] = 0;
return dest;
}
char* strncpy(char* dest, char const* src, size_t count)
{
if(0 == count) return dest;
size_t i = 0;
while(0 != src[i])
{
dest[i] = src[i];
i = i + 1;
if(count == i) return dest;
}
while(i <= count)
{
dest[i] = 0;
i = i + 1;
}
return dest;
}
char* strcat(char* dest, char const* src)
{
int i = 0;
int j = 0;
while(0 != dest[i]) i = i + 1;
while(0 != src[j])
{
dest[i] = src[j];
i = i + 1;
j = j + 1;
}
dest[i] = 0;
return dest;
}
char* strncat(char* dest, char const* src, size_t count)
{
size_t i = 0;
size_t j = 0;
while(0 != dest[i]) i = i + 1;
while(0 != src[j])
{
if(count == j)
{
dest[i] = 0;
return dest;
}
dest[i] = src[j];
i = i + 1;
j = j + 1;
}
dest[i] = 0;
return dest;
}
size_t strlen(char const* str )
{
size_t i = 0;
while(0 != str[i]) i = i + 1;
return i;
}
size_t strnlen_s(char const* str, size_t strsz )
{
size_t i = 0;
while(0 != str[i])
{
if(strsz == i) return i;
i = i + 1;
}
return i;
}
int strcmp(char const* lhs, char const* rhs )
{
int i = 0;
while(0 != lhs[i])
{
if(lhs[i] != rhs[i]) return lhs[i] - rhs[i];
i = i + 1;
}
return lhs[i] - rhs[i];
}
int strncmp(char const* lhs, char const* rhs, size_t count)
{
size_t i = 0;
while(count > i)
{
if(0 == lhs[i]) break;
if(lhs[i] != rhs[i]) return lhs[i] - rhs[i];
i = i + 1;
}
return 0;
}
char* strchr(char const* str, int ch)
{
char* p = str;
while(ch != p[0])
{
if(0 == p[0]) return NULL;
p = p + 1;
}
if(0 == p[0]) return NULL;
return p;
}
char* strrchr(char const* str, int ch)
{
char* p = str;
int i = 0;
while(0 != p[i]) i = i + 1;
while(ch != p[i])
{
if(0 == i) return NULL;
i = i - 1;
}
return (p + i);
}
size_t strspn(char const* dest, char const* src)
{
if(0 == dest[0]) return 0;
int i = 0;
while(NULL != strchr(src, dest[i])) i = i + 1;
return i;
}
size_t strcspn(char const* dest, char const* src)
{
int i = 0;
while(NULL == strchr(src, dest[i])) i = i + 1;
return i;
}
char* strpbrk(char const* dest, char const* breakset)
{
char* p = dest;
char* s;
while(0 != p[0])
{
s = strchr(breakset, p[0]);
if(NULL != s) return strchr(p, s[0]);
p = p + 1;
}
return p;
}
void* memset(void* dest, int ch, size_t count)
{
if(NULL == dest) return dest;
size_t i = 0;
char* s = dest;
while(i < count)
{
s[i] = ch;
i = i + 1;
}
return dest;
}
void* memcpy(void* dest, void const* src, size_t count)
{
if(NULL == dest) return dest;
if(NULL == src) return NULL;
char* s1 = dest;
char const* s2 = src;
size_t i = 0;
while(i < count)
{
s1[i] = s2[i];
i = i + 1;
}
return dest;
}
void* memmove(void* dest, void const* src, size_t count)
{
if (dest < src) return memcpy (dest, src, count);
char *p = dest;
char const *q = src;
count = count - 1;
while (count >= 0)
{
p[count] = q[count];
count = count - 1;
}
return dest;
}
int memcmp(void const* lhs, void const* rhs, size_t count)
{
if(0 == count) return 0;
size_t i = 0;
count = count - 1;
char const* s1 = lhs;
char const* s2 = rhs;
while(i < count)
{
if(s1[i] != s2[i]) break;
i = i + 1;
}
return (s1[i] - s2[i]);
}
mescc-tools-1.5.2/M2libc/uefi/sys/ 0000755 0000000 0000000 00000000000 14522760670 013524 5 ustar mescc-tools-1.5.2/M2libc/uefi/sys/stat.c 0000644 0000000 0000000 00000003341 14522760670 014644 0 ustar /* Copyright (C) 2020 Jeremiah Orians
* This file is part of M2-Planet.
*
* M2-Planet is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* M2-Planet is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with M2-Planet. If not, see
#include
#define S_IRWXU 00700
#define S_IXUSR 00100
#define S_IWUSR 00200
#define S_IRUSR 00400
#define S_ISUID 04000
#define S_ISGID 02000
#define S_IXGRP 00010
#define S_IXOTH 00001
#define S_IRGRP 00040
#define S_IROTH 00004
#define S_IWGRP 00020
#define S_IWOTH 00002
#define S_IRWXG 00070
#define S_IRWXO 00007
int chmod(char *pathname, int mode)
{
return 0;
}
int fchmod(int a, mode_t b)
{
return 0;
}
int __open(struct efi_file_protocol* _rootdir, char* name, long mode, long attributes);
int mkdir(char const* name, mode_t _mode)
{
struct efi_file_protocol* new_directory;
long mode = EFI_FILE_MODE_CREATE | EFI_FILE_MODE_WRITE | EFI_FILE_MODE_READ;
long attributes = EFI_FILE_DIRECTORY;
long new_directory = __open(_rootdir, name, mode, attributes);
if(new_directory != -1)
{
_close(new_directory);
return 0;
}
return -1;
}
int mknod(char const* a, mode_t b, dev_t c)
{
return -1;
}
mode_t umask(mode_t m)
{
return 0;
}
#endif
mescc-tools-1.5.2/M2libc/uefi/uefi.c 0000644 0000000 0000000 00000045040 14522760670 014005 0 ustar /* Copyright (C) 2022 Andrius Štikonas
* This file is part of M2-Planet.
*
* M2-Planet is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* M2-Planet is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with M2-Planet. If not, see
#include
#define PAGE_SIZE 4096
#define USER_STACK_SIZE 8388608
#define EFI_OPEN_PROTOCOL_BY_HANDLE_PROTOCOL 1
#define EFI_FILE_MODE_READ 1
#define EFI_FILE_MODE_WRITE 2
#define EFI_FILE_MODE_CREATE (1 << 63)
#define EFI_FILE_READ_ONLY 1
#define EFI_FILE_DIRECTORY 0x10
#define EFI_LOADER_DATA 2
#define EFI_VARIABLE_BOOTSERVICE_ACCESS 2
#define EFI_SUCCESS 0
#define EFI_LOAD_ERROR (1 << 63) | 1
#define EFI_INVALID_PARAMETER (1 << 63) | 2
#define EFI_UNSUPPORTED (1 << 63) | 3
#define EFI_BUFFER_TOO_SMALL (1 << 63) | 5
#define EFI_NOT_FOUND (1 << 31) | 14
#define __PATH_MAX 4096
#define __ENV_NAME_MAX 4096
#define HARDWARE_DEVICE_PATH 1
#define MEMORY_MAPPED 3
#define END_HARDWARE_DEVICE_PATH 0x7F
#define END_ENTIRE_DEVICE_PATH 0xFF
void* _image_handle;
void* _root_device;
void* __user_stack;
int _argc;
char** _argv;
char** _envp;
char* _cwd;
struct efi_simple_text_output_protocol
{
void* reset;
void* output_string;
void* test_string;
void* query_mode;
void* set_mode;
void* set_attribute;
void* clear_screen;
void* set_cursor;
void* enable_cursor;
void* mode;
};
struct efi_table_header
{
unsigned signature;
unsigned revision_and_header_size;
unsigned crc32_and_reserved;
};
struct efi_boot_table
{
struct efi_table_header header;
/* Task Priority Services */
void* raise_tpl;
void* restore_tpl;
/* Memory Services */
void* allocate_pages;
void* free_pages;
void* get_memory_map;
void* allocate_pool;
void* free_pool;
/* Event & Timer Services */
void* create_event;
void* set_timer;
void* wait_for_event;
void* signal_event;
void* close_event;
void* check_event;
/* Protocol Handler Services */
void* install_protocol_interface;
void* reinstall_protocol_interface;
void* uninstall_protocol_interface;
void* handle_protocol;
void* reserved;
void* register_protocol_notify;
void* locate_handle;
void* locate_device_path;
void* install_configuration_table;
/* Image Services */
void* load_image;
void* start_image;
void* exit;
void* unload_image;
void* exit_boot_services;
/* Miscellaneous Services */
void* get_next_monotonic_count;
void* stall;
void* set_watchdog_timer;
/* DriverSupport Services */
void* connect_controller;
void* disconnect_controller;
/* Open and Close Protocol Services */
void* open_protocol;
void* close_protocol;
void* open_protocol_information;
/* Library Services */
void* protocols_per_handle;
void* locate_handle_buffer;
void* locate_protocol;
void* install_multiple_protocol_interfaces;
void* uninstall_multiple_protocol_interfaces;
/* 32-bit CRC Services */
void* copy_mem;
void* set_mem;
void* create_event_ex;
};
struct efi_runtime_table
{
struct efi_table_header header;
/* Time Services */
void* get_time;
void* set_time;
void* get_wakeup_time;
void* set_wakeup_time;
/* Virtual Memory Services */
void* set_virtual_address_map;
void* convert_pointer;
/* Variable Services */
void* get_variable;
void* get_next_variable_name;
void* set_variable;
/* Miscellaneous Services */
void* get_next_high_monotonic_count;
void* reset_system;
/* UEFI 2.0 Capsule Services */
void* update_capsule;
void* query_capsule_capabilities;
/* Miscellaneous UEFI 2.0 Services */
void* query_variable_info;
};
struct efi_system_table
{
struct efi_table_header header;
char* firmware_vendor;
unsigned firmware_revision;
void* console_in_handle;
void* con_in;
void* console_out_handle;
struct efi_simple_text_output_protocol* con_out;
void *standard_error_handle;
struct efi_simple_text_output_protocol* std_err;
struct efi_runtime_table* runtime_services;
struct efi_boot_table* boot_services;
unsigned number_table_entries;
void *configuration_table;
};
struct efi_system_table* _system;
struct efi_guid
{
uint32_t data1;
uint16_t data2;
uint16_t data3;
uint8_t data4[8];
};
struct efi_guid EFI_LOADED_IMAGE_PROTOCOL_GUID;
struct efi_guid EFI_SIMPLE_FILE_SYSTEM_PROTOCOL_GUID;
struct efi_guid EFI_FILE_INFO_GUID;
struct efi_guid EFI_SHELL_VARIABLE_GUID;
struct efi_loaded_image_protocol
{
unsigned revision;
void* parent;
void* system;
void* device;
void* filepath;
void* reserved;
/* Image's load options */
unsigned load_options_size;
void* load_options;
/* Location of the image in memory */
void* image_base;
unsigned image_size;
unsigned image_code_type;
unsigned image_data_type;
void* unload;
};
struct efi_loaded_image_protocol* _image;
struct efi_simple_file_system_protocol
{
unsigned revision;
void* open_volume;
};
struct efi_file_protocol
{
unsigned revision;
void* open;
void* close;
void* delete;
void* read;
void* write;
void* get_position;
void* set_position;
void* get_info;
void* set_info;
void* flush;
void* open_ex;
void* read_ex;
void* write_ex;
void* flush_ex;
};
struct efi_file_protocol* _rootdir;
struct efi_time
{
uint16_t year;
uint8_t month;
uint8_t day;
uint8_t hour;
uint8_t minute;
uint8_t second;
uint8_t pad1;
uint32_t nanosecond;
uint16_t time_zone;
uint8_t daylight;
uint8_t pad2;
};
struct efi_file_info
{
unsigned size;
unsigned file_size;
unsigned physical_size;
struct efi_time create_time;
struct efi_time last_access_time;
struct efi_time modifiction_time;
unsigned attribute;
char file_name[__PATH_MAX];
};
struct efi_device_path_protocol
{
uint8_t type;
uint8_t subtype;
uint16_t length;
uint32_t memory_type;
unsigned start_address;
unsigned end_address;
};
unsigned __uefi_1(void*, void*, FUNCTION f)
{
#ifdef __x86_64__
asm("lea_rcx,[rbp+DWORD] %-8"
"mov_rcx,[rcx]"
"lea_rax,[rbp+DWORD] %-16"
"mov_rax,[rax]"
"sub_rsp, %8"
"call_rax"
"add_rsp, %8");
#else
#error unsupported arch
#endif
}
unsigned __uefi_2(void*, void*, FUNCTION f)
{
#ifdef __x86_64__
asm("lea_rcx,[rbp+DWORD] %-8"
"mov_rcx,[rcx]"
"lea_rdx,[rbp+DWORD] %-16"
"mov_rdx,[rdx]"
"lea_rax,[rbp+DWORD] %-24"
"mov_rax,[rax]"
"sub_rsp, %16"
"call_rax"
"add_rsp, %16");
#else
#error unsupported arch
#endif
}
unsigned __uefi_3(void*, void*, void*, FUNCTION f)
{
#ifdef __x86_64__
asm("lea_rcx,[rbp+DWORD] %-8"
"mov_rcx,[rcx]"
"lea_rdx,[rbp+DWORD] %-16"
"mov_rdx,[rdx]"
"lea_r8,[rbp+DWORD] %-24"
"mov_r8,[r8]"
"lea_rax,[rbp+DWORD] %-32"
"mov_rax,[rax]"
"sub_rsp, %24"
"call_rax"
"add_rsp, %24");
#else
#error unsupported arch
#endif
}
unsigned __uefi_4(void*, void*, void*, void*, FUNCTION f)
{
#ifdef __x86_64__
asm("lea_rcx,[rbp+DWORD] %-8"
"mov_rcx,[rcx]"
"lea_rdx,[rbp+DWORD] %-16"
"mov_rdx,[rdx]"
"lea_r8,[rbp+DWORD] %-24"
"mov_r8,[r8]"
"lea_r9,[rbp+DWORD] %-32"
"mov_r9,[r9]"
"lea_rax,[rbp+DWORD] %-40"
"mov_rax,[rax]"
"sub_rsp, %32"
"call_rax"
"add_rsp, %32");
#else
#error unsupported arch
#endif
}
unsigned __uefi_5(void*, void*, void*, void*, void*, FUNCTION f)
{
#ifdef __x86_64__
asm("lea_rcx,[rbp+DWORD] %-8"
"mov_rcx,[rcx]"
"lea_rdx,[rbp+DWORD] %-16"
"mov_rdx,[rdx]"
"lea_r8,[rbp+DWORD] %-24"
"mov_r8,[r8]"
"lea_r9,[rbp+DWORD] %-32"
"mov_r9,[r9]"
"lea_rax,[rbp+DWORD] %-40"
"mov_rax,[rax]"
"push_rax"
"lea_rax,[rbp+DWORD] %-48"
"mov_rax,[rax]"
"sub_rsp, %32"
"call_rax"
"add_rsp, %40");
#else
#error unsupported arch
#endif
}
unsigned __uefi_6(void*, void*, void*, void*, void*, void*, FUNCTION f)
{
#ifdef __x86_64__
asm("lea_rcx,[rbp+DWORD] %-8"
"mov_rcx,[rcx]"
"lea_rdx,[rbp+DWORD] %-16"
"mov_rdx,[rdx]"
"lea_r8,[rbp+DWORD] %-24"
"mov_r8,[r8]"
"lea_r9,[rbp+DWORD] %-32"
"mov_r9,[r9]"
"lea_rax,[rbp+DWORD] %-48"
"mov_rax,[rax]"
"push_rax"
"lea_rax,[rbp+DWORD] %-40"
"mov_rax,[rax]"
"push_rax"
"lea_rax,[rbp+DWORD] %-56"
"mov_rax,[rax]"
"sub_rsp, %32"
"call_rax"
"add_rsp, %48");
#else
#error unsupported arch
#endif
}
unsigned _allocate_pool(unsigned memory_type, unsigned size, void* pool)
{
return __uefi_3(memory_type, size, pool, _system->boot_services->allocate_pool);
}
void _free_pool(void* memory)
{
return __uefi_1(memory, _system->boot_services->free_pool);
}
unsigned _open_protocol(void* handle, struct efi_guid* protocol, void* agent_handle, void** interface, void* controller_handle, long attributes, FUNCTION open_protocol)
{
return __uefi_6(handle, protocol, agent_handle, interface, controller_handle, attributes, _system->boot_services->open_protocol);
}
unsigned _close_protocol(void* handle, struct efi_guid* protocol, void* agent_handle, void* controller_handle)
{
return __uefi_4(handle, protocol, agent_handle, controller_handle, _system->boot_services->close_protocol);
}
unsigned _open_volume(struct efi_simple_file_system_protocol* rootfs, struct efi_file_protocol** rootdir)
{
return __uefi_2(rootfs, rootdir, rootfs->open_volume);
}
unsigned _close(struct efi_file_protocol* file)
{
return __uefi_1(file, file->close);
}
unsigned _get_next_variable_name(unsigned* size, char* name, struct efi_guid* vendor_guid)
{
return __uefi_3(size, name, vendor_guid, _system->runtime_services->get_next_variable_name);
}
unsigned _get_variable(char* name, struct efi_guid* vendor_guid, uint32_t* attributes, unsigned* data_size, void* data)
{
return __uefi_5(name, vendor_guid, attributes, data_size, data, _system->runtime_services->get_variable);
}
char* _string2wide(char* narrow_string);
size_t strlen(char const* str);
void free(void* ptr);
unsigned _set_variable(char* name, void* data)
{
char* wide_name = _string2wide(name);
char* wide_data = _string2wide(data);
unsigned data_size = strlen(data) * 2;
uint32_t attributes = EFI_VARIABLE_BOOTSERVICE_ACCESS;
unsigned rval = __uefi_5(wide_name, &EFI_SHELL_VARIABLE_GUID, attributes, data_size, wide_data, _system->runtime_services->set_variable);
free(wide_name);
free(wide_data);
return rval;
}
void exit(unsigned value)
{
goto FUNCTION__exit;
}
char* strcat(char* dest, char const* src);
char* strcpy(char* dest, char const* src);
size_t strlen(char const* str);
void* calloc(int count, int size);
char* _relative_path_to_absolute(char* narrow_string)
{
char* absolute_path = calloc(__PATH_MAX, 1);
if(narrow_string[0] != '/' && narrow_string[0] != '\\')
{
strcpy(absolute_path, _cwd);
}
strcat(absolute_path, narrow_string);
return absolute_path;
}
char* _posix_path_to_uefi(char* narrow_string)
{
char* absolute_path = _relative_path_to_absolute(narrow_string);
unsigned length = strlen(absolute_path);
unsigned i;
for(i = 0; i < length; i += 1)
{
if(absolute_path[i] == '/')
{
absolute_path[i] = '\\';
}
else
{
absolute_path[i] = absolute_path[i];
}
}
char* wide_string = _string2wide(absolute_path);
free(absolute_path);
return wide_string;
}
char* _string2wide(char* narrow_string)
{
unsigned length = strlen(narrow_string);
char* wide_string = calloc(length + 1, 2);
unsigned i;
for(i = 0; i < length; i += 1)
{
wide_string[2 * i] = narrow_string[i];
}
return wide_string;
}
int isspace(char _c);
void _process_load_options(char* load_options)
{
/* Determine argc */
_argc = 1; /* command name */
char *i = load_options;
unsigned was_space = 0;
do
{
if(isspace(i[0]))
{
if(!was_space)
{
_argc += 1;
was_space = 1;
}
}
else
{
was_space = 0;
}
i += 1;
} while(i[0] != 0);
/* Collect argv */
_argv = calloc(_argc + 1, sizeof(char*));
i = load_options;
unsigned j;
for(j = 0; j < _argc; j += 1)
{
_argv[j] = i;
do
{
i += 1;
} while(!isspace(i[0]) && i[0] != 0);
i[0] = 0;
do
{
i += 1;
} while(isspace(i[0]));
}
}
/* Function to find the length of a char**; an array of strings */
unsigned _array_length(char** array)
{
unsigned length = 0;
while(array[length] != NULL)
{
length += 1;
}
return length;
}
size_t wcstombs(char* dest, char* src, size_t n);
char* _get_environmental_variable(struct efi_guid* vendor_guid, char* name, unsigned size)
{
unsigned data_size;
char* data;
char* variable_data;
char* envp_line = NULL;
/* Call with data=NULL to obtain data size that we need to allocate */
_get_variable(name, vendor_guid, NULL, &data_size, NULL);
data = calloc(data_size + 1, 1);
_get_variable(name, vendor_guid, NULL, &data_size, data);
variable_data = calloc((data_size / 2) + 1, 1);
wcstombs(variable_data, data, (data_size / 2) + 1);
envp_line = calloc((size / 2) + (data_size / 2) + 1, 1);
wcstombs(envp_line, name, size / 2);
strcat(envp_line, "=");
strcat(envp_line, variable_data);
free(data);
free(variable_data);
return envp_line;
}
int memcmp(void const* lhs, void const* rhs, size_t count);
char** _get_environmental_variables(char** envp)
{
EFI_SHELL_VARIABLE_GUID.data1 = 0x158def5a;
EFI_SHELL_VARIABLE_GUID.data2 = 0xf656;
EFI_SHELL_VARIABLE_GUID.data3 = 0x419c;
EFI_SHELL_VARIABLE_GUID.data4[0] = 0xb0;
EFI_SHELL_VARIABLE_GUID.data4[1] = 0x27;
EFI_SHELL_VARIABLE_GUID.data4[2] = 0x7a;
EFI_SHELL_VARIABLE_GUID.data4[3] = 0x31;
EFI_SHELL_VARIABLE_GUID.data4[4] = 0x92;
EFI_SHELL_VARIABLE_GUID.data4[5] = 0xc0;
EFI_SHELL_VARIABLE_GUID.data4[6] = 0x79;
EFI_SHELL_VARIABLE_GUID.data4[7] = 0xd2;
unsigned size = __ENV_NAME_MAX;
unsigned rval;
unsigned envc = 0;
char* name = calloc(size, 1);
struct efi_guid vendor_guid;
/* First count the number of environmental variables */
do
{
size = __ENV_NAME_MAX;
rval = _get_next_variable_name(&size, name, &vendor_guid);
if(rval == EFI_SUCCESS)
{
if(memcmp(&vendor_guid, &EFI_SHELL_VARIABLE_GUID, sizeof(struct efi_guid)) == 0)
{
envc += 1;
}
}
} while(rval == EFI_SUCCESS);
/* Now redo the search but this time populate envp array */
envp = calloc(sizeof(char*), envc + 1);
name[0] = 0;
name[1] = 0;
unsigned j = 0;
do
{
size = __ENV_NAME_MAX;
rval = _get_next_variable_name(&size, name, &vendor_guid);
if(rval == EFI_SUCCESS)
{
if(memcmp(&vendor_guid, &EFI_SHELL_VARIABLE_GUID, sizeof(struct efi_guid)) == 0)
{
envp[j] = _get_environmental_variable(&vendor_guid, name, size);
j += 1;
}
}
} while(rval == EFI_SUCCESS);
envp[j] = 0;
free(name);
return envp;
}
void _wipe_environment()
{
char** envp = _get_environmental_variables(envp);
unsigned i = 0;
unsigned j;
char* name;
while(envp[i] != 0)
{
j = 0;
name = envp[i];
while(envp[i][j] != '=')
{
j += 1;
}
envp[i][j] = 0;
_set_variable(name, "");
i += 1;
}
free(envp);
}
int strcmp(char const* lhs, char const* rhs);
char* strchr(char const* str, int ch);
void _setup_current_working_directory(char** envp)
{
_cwd = calloc(__PATH_MAX, 1);
unsigned i = 0;
unsigned j;
unsigned k;
char* value;
char* match;
while(envp[i] != 0)
{
j = 0;
while(envp[i][j] != '=')
{
j += 1;
}
envp[i][j] = 0;
if(strcmp(envp[i], "cwd") == 0)
{
value = envp[i] + j + 1;
match = strchr(value, ':'); /* strip uefi device, e.g. fs0: */
if(match != NULL)
{
value = match + 1;
}
strcpy(_cwd, value);
k = 0;
while(_cwd[k] != '\0')
{
if(_cwd[k] == '\\')
{
_cwd[k] = '/';
}
k += 1;
}
}
envp[i][j] = '=';
i += 1;
}
if(strcmp(_cwd, "") == 0)
{
strcpy(_cwd, "/");
}
}
void* malloc(unsigned size);
void __init_io();
void _init()
{
/* Allocate user stack, UEFI stack is not big enough for compilers */
__user_stack = malloc(USER_STACK_SIZE) + USER_STACK_SIZE;
/* Process command line arguments */
EFI_LOADED_IMAGE_PROTOCOL_GUID.data1 = 0x5b1b31a1;
EFI_LOADED_IMAGE_PROTOCOL_GUID.data2 = 0x9562;
EFI_LOADED_IMAGE_PROTOCOL_GUID.data3 = 0x11d2;
EFI_LOADED_IMAGE_PROTOCOL_GUID.data4[0] = 0x8e;
EFI_LOADED_IMAGE_PROTOCOL_GUID.data4[1] = 0x3f;
EFI_LOADED_IMAGE_PROTOCOL_GUID.data4[2] = 0;
EFI_LOADED_IMAGE_PROTOCOL_GUID.data4[3] = 0xa0;
EFI_LOADED_IMAGE_PROTOCOL_GUID.data4[4] = 0xc9;
EFI_LOADED_IMAGE_PROTOCOL_GUID.data4[5] = 0x69;
EFI_LOADED_IMAGE_PROTOCOL_GUID.data4[6] = 0x72;
EFI_LOADED_IMAGE_PROTOCOL_GUID.data4[7] = 0x3b;
__init_io();
_open_protocol(_image_handle, &EFI_LOADED_IMAGE_PROTOCOL_GUID, &_image, _image_handle, 0, EFI_OPEN_PROTOCOL_BY_HANDLE_PROTOCOL);
char* load_options = calloc(_image->load_options_size, 1);
wcstombs(load_options, _image->load_options, _image->load_options_size);
_process_load_options(load_options);
EFI_SIMPLE_FILE_SYSTEM_PROTOCOL_GUID.data1 = 0x964E5B22;
EFI_SIMPLE_FILE_SYSTEM_PROTOCOL_GUID.data2 = 0x6459;
EFI_SIMPLE_FILE_SYSTEM_PROTOCOL_GUID.data3 = 0x11d2;
EFI_SIMPLE_FILE_SYSTEM_PROTOCOL_GUID.data4[0] = 0x8e;
EFI_SIMPLE_FILE_SYSTEM_PROTOCOL_GUID.data4[1] = 0x39;
EFI_SIMPLE_FILE_SYSTEM_PROTOCOL_GUID.data4[2] = 0;
EFI_SIMPLE_FILE_SYSTEM_PROTOCOL_GUID.data4[3] = 0xa0;
EFI_SIMPLE_FILE_SYSTEM_PROTOCOL_GUID.data4[4] = 0xc9;
EFI_SIMPLE_FILE_SYSTEM_PROTOCOL_GUID.data4[5] = 0x69;
EFI_SIMPLE_FILE_SYSTEM_PROTOCOL_GUID.data4[6] = 0x72;
EFI_SIMPLE_FILE_SYSTEM_PROTOCOL_GUID.data4[7] = 0x3b;
_root_device = _image->device;
struct efi_simple_file_system_protocol* rootfs;
_open_protocol(_root_device, &EFI_SIMPLE_FILE_SYSTEM_PROTOCOL_GUID, &rootfs, _image_handle, 0, EFI_OPEN_PROTOCOL_BY_HANDLE_PROTOCOL);
_open_volume(rootfs, &_rootdir);
EFI_FILE_INFO_GUID.data1 = 0x09576e92;
EFI_FILE_INFO_GUID.data2 = 0x6d3f;
EFI_FILE_INFO_GUID.data3 = 0x11d2;
EFI_FILE_INFO_GUID.data4[0] = 0x8e;
EFI_FILE_INFO_GUID.data4[1] = 0x39;
EFI_FILE_INFO_GUID.data4[2] = 0;
EFI_FILE_INFO_GUID.data4[3] = 0xa0;
EFI_FILE_INFO_GUID.data4[4] = 0xc9;
EFI_FILE_INFO_GUID.data4[5] = 0x69;
EFI_FILE_INFO_GUID.data4[6] = 0x72;
EFI_FILE_INFO_GUID.data4[7] = 0x3b;
_envp = _get_environmental_variables(_envp);
_setup_current_working_directory(_envp);
}
void __kill_io();
void* _malloc_release_all(FUNCTION _free);
void _cleanup()
{
__kill_io();
_close(_rootdir);
_close_protocol(_root_device, &EFI_SIMPLE_FILE_SYSTEM_PROTOCOL_GUID, _image_handle, 0);
_close_protocol(_image_handle, &EFI_LOADED_IMAGE_PROTOCOL_GUID, _image_handle, 0);
_malloc_release_all(_free_pool);
}
void* _malloc_uefi(unsigned size)
{
void* memory_block;
if(_allocate_pool(EFI_LOADER_DATA, size, &memory_block) != EFI_SUCCESS)
{
return 0;
}
return memory_block;
}
#endif
mescc-tools-1.5.2/M2libc/uefi/unistd.c 0000644 0000000 0000000 00000016366 14522760670 014374 0 ustar /* Copyright (C) 2022 Andrius Štikonas
* This file is part of M2-Planet.
*
* M2-Planet is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* M2-Planet is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with M2-Planet. If not, see
#include
#define NULL 0
#define EOF 0xFFFFFFFF
/* For lseek */
#define SEEK_SET 0
#define SEEK_CUR 1
#define SEEK_END 2
void* malloc(unsigned size);
size_t strlen(char const* str);
char* strncpy(char* dest, char const* src, size_t count);
char* strncat(char* dest, char const* src, size_t count);
void* memcpy(void* dest, void const* src, size_t count);
int access(char* pathname, int mode)
{
return 0;
}
int chdir(char* path)
{
char* absolute_path = _relative_path_to_absolute(path);
strncpy(_cwd, absolute_path, __PATH_MAX);
if(_cwd[strlen(_cwd) - 1] != '\\')
{
strncat(_cwd, "/", __PATH_MAX);
}
free(absolute_path);
return 0;
}
int fchdir(int fd)
{
/* TODO: not yet implemented. */
return -1;
}
int _get_file_size(struct efi_file_protocol* f)
{
/* Preallocate some extra space for file_name */
size_t file_info_size = sizeof(struct efi_file_info);
struct efi_file_info* file_info = calloc(1, file_info_size);
unsigned rval = __uefi_4(f, &EFI_FILE_INFO_GUID, &file_info_size, file_info, f->get_info);
if(rval != EFI_SUCCESS)
{
return -1;
}
int file_size = file_info->file_size;
free(file_info);
return file_size;
}
void _set_environment(char** envp)
{
unsigned i;
unsigned j;
unsigned length = _array_length(envp);
char* name;
char* value;
for(i = 0; i < length; i += 1)
{
j = 0;
name = envp[i];
while(envp[i][j] != '=')
{
j += 1;
}
envp[i][j] = 0;
value = envp[i] + j + 1;
_set_variable(name, value);
envp[i][j] = '=';
}
}
FILE* fopen(char const* filename, char const* mode);
size_t fread(void* buffer, size_t size, size_t count, FILE* stream);
int fclose(FILE* stream);
int spawn(char* file_name, char** argv, char** envp)
{
FILE* fcmd = fopen(file_name, "r");
if(fcmd == NULL) return -1;
long program_size = _get_file_size(fcmd->fd);
void* executable = malloc(program_size);
size_t count = fread(executable, 1, program_size, fcmd);
if(count < program_size)
{
free(executable);
fclose(fcmd);
return -1;
}
fclose(fcmd);
struct efi_device_path_protocol* device_path = calloc(2, sizeof(struct efi_device_path_protocol));
device_path->type = HARDWARE_DEVICE_PATH;
device_path->subtype = MEMORY_MAPPED;
device_path->length = sizeof(struct efi_device_path_protocol);
device_path->memory_type = EFI_LOADER_DATA;
device_path->start_address = executable;
device_path->end_address = executable + program_size;
device_path[1].type = END_HARDWARE_DEVICE_PATH;
device_path[1].subtype = END_ENTIRE_DEVICE_PATH;
device_path[1].length = 4;
void* child_ih;
unsigned rval = __uefi_6(0, _image_handle, device_path, executable, program_size, &child_ih, _system->boot_services->load_image);
free(device_path);
free(executable);
if(rval != EFI_SUCCESS) return -1;
struct efi_loaded_image_protocol* child_image;
rval = _open_protocol(child_ih, &EFI_LOADED_IMAGE_PROTOCOL_GUID, &child_image, child_ih, 0, EFI_OPEN_PROTOCOL_BY_HANDLE_PROTOCOL);
if(rval != EFI_SUCCESS) return -1;
/* Concatenate char** argv array */
unsigned arg_length = -1 ;
unsigned i = 0;
while(argv[i] != NULL)
{
arg_length += strlen(argv[i]) + 1;
i += 1;
}
char* load_options = calloc(arg_length + 1, 1);
strcpy(load_options, argv[0]);
i = 1;
while(argv[i] != NULL)
{
strcat(load_options, " ");
strcat(load_options, argv[i]);
i += 1;
}
char* uefi_path = _string2wide(load_options);
child_image->load_options = uefi_path;
child_image->load_options_size = 2 * arg_length;
free(load_options);
child_image->device = _image->device;
rval = _close_protocol(child_ih, &EFI_LOADED_IMAGE_PROTOCOL_GUID, child_ih, 0);
if(rval != EFI_SUCCESS) return -1;
/* Setup environment for child process */
_set_environment(envp);
_set_variable("cwd", _cwd);
/* Run command */
rval = __uefi_3(child_ih, 0, 0, _system->boot_services->start_image);
free(uefi_path);
/* Restore initial environment
* For simplicity we just delete all variables and restore them from _envp.
* This assumes that _envp is not modified by application, e.g. kaem.
*/
_wipe_environment();
_set_environment(_envp);
return rval;
}
int fork()
{
return -1;
}
int waitpid (int pid, int* status_ptr, int options)
{
return -1;
}
int execve(char* file_name, char** argv, char** envp)
{
return -1;
}
int read(int fd, char* buf, unsigned count)
{
struct efi_file_protocol* f = fd;
__uefi_3(fd, &count, buf, f->read);
return count;
}
int write(int fd, char* buf, unsigned count)
{
struct efi_file_protocol* f = fd;
unsigned i;
char c = 0;
/* In UEFI StdErr might not be printing stuff to console, so just use stdout */
if(f == STDOUT_FILENO || f == STDERR_FILENO)
{
for(i = 0; i < count; i += 1)
{
c = buf[i];
__uefi_2(_system->con_out, &c, _system->con_out->output_string);
if('\n' == c)
{
c = '\r';
__uefi_2(_system->con_out, &c, _system->con_out->output_string);
}
}
return i;
}
/* Otherwise write to file */
__uefi_3(f, &count, buf, f->write);
return count;
}
int lseek(int fd, int offset, int whence)
{
struct efi_file_protocol* f = fd;
if(whence == SEEK_SET)
{
}
else if(whence == SEEK_CUR)
{
unsigned position;
__uefi_2(f, &position, f->get_position);
offset += position;
}
else if(whence == SEEK_END)
{
offset += _get_file_size(fd);
}
else
{
return -1;
}
unsigned rval = __uefi_2(f, offset, f->set_position);
if(rval == EFI_SUCCESS)
{
return offset;
}
return -1;
}
int close(int fd)
{
struct efi_file_protocol* f = fd;
unsigned rval = __uefi_1(f, f->close);
if(rval != EFI_SUCCESS)
{
return -1;
}
return rval;
}
int unlink(char* filename)
{
FILE* f = fopen(filename, "r");
struct efi_file_protocol* fd = f->fd;
__uefi_1(fd, fd->delete);
}
char* getcwd(char* buf, unsigned size)
{
size_t length = strlen(_cwd);
if(length >= size) return NULL;
strcpy(buf, _cwd);
return buf;
}
char* getwd(char* buf)
{
return getcwd(buf, __PATH_MAX);
}
char* get_current_dir_name()
{
return getcwd(malloc(__PATH_MAX), __PATH_MAX);
}
int brk(void *addr)
{
return -1;
}
struct utsname
{
char sysname[65]; /* Operating system name (e.g., "Linux") */
char nodename[65]; /* Name within "some implementation-defined network" */
char release[65]; /* Operating system release (e.g., "2.6.28") */
char version[65]; /* Operating system version */
char machine[65]; /* Hardware identifier */
};
int uname(struct utsname* unameData)
{
memcpy(unameData->sysname, "UEFI", 5);
memcpy(unameData->release, "1.0", 4);
memcpy(unameData->version, "1.0", 4);
#ifdef __x86_64__
memcpy(unameData->machine, "x86_64", 7);
#else
#error unsupported arch
#endif
}
#endif
mescc-tools-1.5.2/M2libc/unistd.h 0000644 0000000 0000000 00000004224 14522760670 013437 0 ustar /* Copyright (C) 2020 Jeremiah Orians
* This file is part of M2-Planet.
*
* M2-Planet is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* M2-Planet is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with M2-Planet. If not, see
#elif __i386__
#include
#elif __x86_64__
#include
#elif __arm__
#include
#elif __aarch64__
#include
#elif __riscv && __riscv_xlen==32
#include
#elif __riscv && __riscv_xlen==64
#include
#else
#error arch not supported
#endif
#else
#define NULL 0
#define __PATH_MAX 4096
void* malloc(unsigned size);
int access(char* pathname, int mode);
int chdir(char* path);
int fchdir(int fd);
void _exit(int value);
int fork();
int waitpid (int pid, int* status_ptr, int options);
int execve(char* file_name, char** argv, char** envp);
int read(int fd, char* buf, unsigned count);
int write(int fd, char* buf, unsigned count);
int lseek(int fd, int offset, int whence);
int close(int fd);
int unlink (char *filename);
int _getcwd(char* buf, int size);
char* getcwd(char* buf, unsigned size);
char* getwd(char* buf);
char* get_current_dir_name();
int brk(void *addr);
struct utsname
{
char sysname[65]; /* Operating system name (e.g., "Linux") */
char nodename[65]; /* Name within "some implementation-defined network" */
char release[65]; /* Operating system release (e.g., "2.6.28") */
char version[65]; /* Operating system version */
char machine[65]; /* Hardware identifier */
};
int uname(struct utsname* unameData);
#endif
#endif
mescc-tools-1.5.2/M2libc/x86/ 0000755 0000000 0000000 00000000000 14522760670 012403 5 ustar mescc-tools-1.5.2/M2libc/x86/ELF-x86-debug.hex2 0000644 0000000 0000000 00000005642 14522760670 015317 0 ustar ### Copyright (C) 2016 Jeremiah Orians
### Copyright (C) 2017 Jan Nieuwenhuizen
### This file is part of M2-Planet.
###
### M2-Planet is free software: you can redistribute it and/or modify
### it under the terms of the GNU General Public License as published by
### the Free Software Foundation, either version 3 of the License, or
### (at your option) any later version.
###
### M2-Planet is distributed in the hope that it will be useful,
### but WITHOUT ANY WARRANTY; without even the implied warranty of
### MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
### GNU General Public License for more details.
###
### You should have received a copy of the GNU General Public License
### along with M2-Planet. If not, see 1 byte relative
### $ 2 byte address
### @ 2 byte relative
### & 4 byte address
### % 4 byte relative
### if you wish to use this header, you need to add :ELF_end to the end of your
### M1 or hex2 files.
## ELF Header
:ELF_base
7F 45 4C 46 # e_ident[EI_MAG0-3] ELF's magic number
01 # e_ident[EI_CLASS] Indicating 32 bit
01 # e_ident[EI_DATA] Indicating little endianness
01 # e_ident[EI_VERSION] Indicating original elf
03 # e_ident[EI_OSABI] Set at 3 because FreeBSD is strict
00 # e_ident[EI_ABIVERSION] See above
00 00 00 00 00 00 00 # e_ident[EI_PAD]
02 00 # e_type Indicating Executable
03 00 # e_machine Indicating 386
01 00 00 00 # e_version Indicating original elf
&_start # e_entry Address of the entry point
%ELF_program_headers>ELF_base # e_phoff Address of program header table
%ELF_section_headers>ELF_base # e_shoff Address of section header table
00 00 00 00 # e_flags
34 00 # e_ehsize Indicating our 52 Byte header
20 00 # e_phentsize size of a program header table
01 00 # e_phnum number of entries in program table
28 00 # e_shentsize size of a section header table
05 00 # e_shnum number of entries in section table
02 00 # e_shstrndx index of the section names
:ELF_program_headers
:ELF_program_header__text
01 00 00 00 # ph_type: PT-LOAD = 1
00 00 00 00 # ph_offset
&ELF_base # ph_vaddr
&ELF_base # ph_physaddr
%ELF_end>ELF_base # ph_filesz
%ELF_end>ELF_base # ph_memsz
07 00 00 00 # ph_flags: PF-X|PF-W|PF-R = 7
01 00 00 00 # ph_alignment
:ELF_text
mescc-tools-1.5.2/M2libc/x86/ELF-x86.hex2 0000644 0000000 0000000 00000005642 14522760670 014233 0 ustar ### Copyright (C) 2016 Jeremiah Orians
### Copyright (C) 2017 Jan Nieuwenhuizen
### This file is part of M2-Planet.
###
### M2-Planet is free software: you can redistribute it and/or modify
### it under the terms of the GNU General Public License as published by
### the Free Software Foundation, either version 3 of the License, or
### (at your option) any later version.
###
### M2-Planet is distributed in the hope that it will be useful,
### but WITHOUT ANY WARRANTY; without even the implied warranty of
### MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
### GNU General Public License for more details.
###
### You should have received a copy of the GNU General Public License
### along with M2-Planet. If not, see 1 byte relative
### $ 2 byte address
### @ 2 byte relative
### & 4 byte address
### % 4 byte relative
### if you wish to use this header, you need to add :ELF_end to the end of your
### M1 or hex2 files.
## ELF Header
:ELF_base
7F 45 4C 46 # e_ident[EI_MAG0-3] ELF's magic number
01 # e_ident[EI_CLASS] Indicating 32 bit
01 # e_ident[EI_DATA] Indicating little endianness
01 # e_ident[EI_VERSION] Indicating original elf
03 # e_ident[EI_OSABI] Set at 3 because FreeBSD is strict
00 # e_ident[EI_ABIVERSION] See above
00 00 00 00 00 00 00 # e_ident[EI_PAD]
02 00 # e_type Indicating Executable
03 00 # e_machine Indicating 386
01 00 00 00 # e_version Indicating original elf
&_start # e_entry Address of the entry point
%ELF_program_headers>ELF_base # e_phoff Address of program header table
00 00 00 00 # e_shoff Address of section header table
00 00 00 00 # e_flags
34 00 # e_ehsize Indicating our 52 Byte header
20 00 # e_phentsize size of a program header table
01 00 # e_phnum number of entries in program table
00 00 # e_shentsize size of a section header table
00 00 # e_shnum number of entries in section table
00 00 # e_shstrndx index of the section names
:ELF_program_headers
:ELF_program_header__text
01 00 00 00 # ph_type: PT-LOAD = 1
00 00 00 00 # ph_offset
&ELF_base # ph_vaddr
&ELF_base # ph_physaddr
%ELF_end>ELF_base # ph_filesz
%ELF_end>ELF_base # ph_memsz
07 00 00 00 # ph_flags: PF-X|PF-W|PF-R = 7
01 00 00 00 # ph_alignment
:ELF_text
mescc-tools-1.5.2/M2libc/x86/libc-core.M1 0000644 0000000 0000000 00000003171 14522760670 014443 0 ustar ## Copyright (C) 2016 Jeremiah Orians
## This file is part of M2-Planet.
##
## M2-Planet is free software: you can redistribute it and/or modify
## it under the terms of the GNU General Public License as published by
## the Free Software Foundation, either version 3 of the License, or
## (at your option) any later version.
##
## M2-Planet is distributed in the hope that it will be useful,
## but WITHOUT ANY WARRANTY; without even the implied warranty of
## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
## GNU General Public License for more details.
##
## You should have received a copy of the GNU General Public License
## along with M2-Planet. If not, see
#define S_IRWXU 00700
#define S_IXUSR 00100
#define S_IWUSR 00200
#define S_IRUSR 00400
#define S_ISUID 04000
#define S_ISGID 02000
#define S_IXGRP 00010
#define S_IXOTH 00001
#define S_IRGRP 00040
#define S_IROTH 00004
#define S_IWGRP 00020
#define S_IWOTH 00002
#define S_IRWXG 00070
#define S_IRWXO 00007
int chmod(char *pathname, int mode)
{
asm("lea_ebx,[esp+DWORD] %8"
"mov_ebx,[ebx]"
"lea_ecx,[esp+DWORD] %4"
"mov_ecx,[ecx]"
"mov_eax, %15"
"int !0x80");
}
int fchmod(int a, mode_t b)
{
asm("lea_ebx,[esp+DWORD] %8"
"mov_ebx,[ebx]"
"lea_ecx,[esp+DWORD] %4"
"mov_ecx,[ecx]"
"mov_eax, %94"
"int !0x80");
}
int mkdir(char const* a, mode_t b)
{
asm("lea_ebx,[esp+DWORD] %8"
"mov_ebx,[ebx]"
"lea_ecx,[esp+DWORD] %4"
"mov_ecx,[ecx]"
"mov_eax, %39"
"int !0x80");
}
int mknod(char const* a, mode_t b, dev_t c)
{
asm("lea_ebx,[esp+DWORD] %12"
"mov_ebx,[ebx]"
"lea_ecx,[esp+DWORD] %8"
"mov_ecx,[ecx]"
"lea_edx,[esp+DWORD] %4"
"mov_edx,[edx]"
"mov_eax, %14"
"int !0x80");
}
mode_t umask(mode_t m)
{
asm("lea_ebx,[esp+DWORD] %4"
"mov_ebx,[ebx]"
"mov_eax, %60"
"int !0x80");
}
#endif
mescc-tools-1.5.2/M2libc/x86/linux/unistd.c 0000644 0000000 0000000 00000007431 14522760670 015221 0 ustar /* Copyright (C) 2020 Jeremiah Orians
* This file is part of M2-Planet.
*
* M2-Planet is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* M2-Planet is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with M2-Planet. If not, see
* This file is part of mescc-tools
*
* mescc-tools is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* mescc-tools is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with mescc-tools. If not, see
#include
#include
#include
#include
#include "M2libc/bootstrappable.h"
// CONSTANT max_string 4096
#define max_string 4096
int BITSIZE;
int BigEndian;
// CONSTANT HEX 16
#define HEX 16
// CONSTANT OCTAL 8
#define OCTAL 8
// CONSTANT BINARY 2
#define BINARY 2
/* Strings needed for constants */
char* zero_8;
char* zero_16;
char* zero_32;
char* one_16;
char* one_32;
char* two_8;
char* two_32;
char* three_32;
char* six_32;
char* sixteen_32;
char* twentyfour_32;
/* Imported from stringify.c */
int stringify(char* s, int digits, int divisor, int value, int shift);
void LittleEndian(char* start, int ByteMode);
struct entry
{
struct entry* next;
char* name;
};
FILE* output;
struct entry* jump_table;
int count;
char* entry;
void consume_token(FILE* source_file, char* s)
{
int i = 0;
int c = fgetc(source_file);
require(EOF != c, "Can not have an EOF token\n");
do
{
s[i] = c;
i = i + 1;
require(max_string > i, "Token exceeds token length restriction\n");
c = fgetc(source_file);
if(EOF == c) break;
} while(!in_set(c, " \t\n>"));
}
void storeLabel(FILE* source_file)
{
struct entry* entry = calloc(1, sizeof(struct entry));
/* Prepend to list */
entry->next = jump_table;
jump_table = entry;
/* Store string */
entry->name = calloc((max_string + 1), sizeof(char));
consume_token(source_file, entry->name);
count = count + 1;
}
void line_Comment(FILE* source_file)
{
int c = fgetc(source_file);
while(!in_set(c, "\n\r"))
{
if(EOF == c) break;
c = fgetc(source_file);
}
}
void purge_string(FILE* source_file)
{
int c = fgetc(source_file);
while((EOF != c) && ('"' != c))
{
c = fgetc(source_file);
}
}
void first_pass(struct entry* input)
{
if(NULL == input) return;
first_pass(input->next);
FILE* source_file = fopen(input->name, "r");
if(NULL == source_file)
{
fputs("The file: ", stderr);
fputs(input->name, stderr);
fputs(" can not be opened!\n", stderr);
exit(EXIT_FAILURE);
}
int c;
for(c = fgetc(source_file); EOF != c; c = fgetc(source_file))
{
/* Check for and deal with label */
if(58 == c)
{
storeLabel(source_file);
}
/* Check for and deal with line comments */
else if (c == '#' || c == ';')
{
line_Comment(source_file);
}
else if ('"' == c)
{
purge_string(source_file);
}
}
fclose(source_file);
}
void output_string_table(struct entry* node)
{
fputs("\n# Generated string table\n:ELF_str\n", output);
fputs(zero_8, output);
fputs("\t# NULL string\n", output);
struct entry* i;
for(i = node; NULL != i; i = i->next)
{
fputs(":ELF_str_", output);
fputs(i->name, output);
fputs("\t\"", output);
fputs(i->name, output);
fputs("\"\n", output);
}
fputs("# END Generated string table\n\n", output);
}
void output_symbol_table(struct entry* node)
{
fputs("\n# Generated symbol table\n:ELF_sym\n# Required NULL symbol entry\n", output);
if(64 == BITSIZE)
{
fputs(zero_32, output);
fputs("\t# st_name\n", output);
fputs(zero_8, output);
fputs("\t# st_info\n", output);
fputs(zero_8, output);
fputs("\t# st_other\n", output);
fputs(one_16, output);
fputs("\t# st_shndx\n", output);
fputs(zero_32, output);
fputc(' ', output);
fputs(zero_32, output);
fputs("\t# st_value\n", output);
fputs(zero_32, output);
fputc(' ', output);
fputs(zero_32, output);
fputs("\t# st_size\n\n", output);
}
else
{
fputs(zero_32, output);
fputs("\t# st_name\n", output);
fputs(zero_32, output);
fputs("\t# st_value\n", output);
fputs(zero_32, output);
fputs("\t# st_size\n", output);
fputs(zero_8, output);
fputs("\t# st_info\n", output);
fputs(zero_8, output);
fputs("\t# st_other\n", output);
fputs(one_16, output);
fputs("\t# st_shndx\n\n", output);
}
struct entry* i;
for(i = node; NULL != i; i = i->next)
{
fputs("%ELF_str_", output);
fputs(i->name, output);
fputs(">ELF_str\t# st_name\n", output);
if(64 == BITSIZE)
{
fputs(two_8, output);
fputs("\t# st_info (FUNC)\n", output);
if(('_' == i->name[0]) && !match(entry, i->name))
{
fputs(two_8, output);
fputs("\t# st_other (hidden)\n", output);
}
else
{
fputs(zero_8, output);
fputs("\t# st_other (other)\n", output);
}
fputs(one_16, output);
fputs("\t# st_shndx\n", output);
fputs("&", output);
fputs(i->name, output);
fputc(' ', output);
fputs(zero_32, output);
fputs("\t# st_value\n", output);
fputs(zero_32, output);
fputc(' ', output);
fputs(zero_32, output);
fputs("\t# st_size (unknown size)\n\n", output);
}
else
{
fputs("&", output);
fputs(i->name, output);
fputs("\t#st_value\n", output);
fputs(zero_32, output);
fputs("\t# st_size (unknown size)\n", output);
fputs(two_8, output);
fputs("\t# st_info (FUNC)\n", output);
if(('_' == i->name[0]) && !match(entry, i->name))
{
fputs(two_8, output);
fputs("\t# st_other (hidden)\n", output);
}
else
{
fputs(zero_8, output);
fputs("\t# st_other (default)\n", output);
}
fputs(one_16, output);
fputs("\t# st_shndx\n\n", output);
}
}
fputs("# END Generated symbol table\n", output);
}
struct entry* reverse_list(struct entry* head)
{
struct entry* root = NULL;
struct entry* next;
while(NULL != head)
{
next = head->next;
head->next = root;
root = head;
head = next;
}
return root;
}
void write_int(char* field, char* label)
{
fputs(field, output);
fputs("\t#", output);
fputs(label, output);
fputc('\n', output);
}
void write_register(char* field, char* label)
{
/* $field section in the section headers are different size for 32 and 64bits */
/* The below is broken for BigEndian */
fputs(field, output);
if(64 == BITSIZE)
{
fputc(' ', output);
fputs(zero_32, output);
}
fputs("\t#", output);
fputs(label, output);
fputc('\n', output);
}
void write_section(char* label, char* name, char* type, char* flags, char* address, char* offset, char* size, char* link, char* info, char* entry)
{
/* Write label */
fputc('\n', output);
fputs(label, output);
fputc('\n', output);
write_int(name, "sh_name");
write_int(type, "sh_type");
write_register(flags, "sh_flags");
write_register(address, "sh_addr");
write_register(offset, "sh_offset");
write_register(size, "sh_size");
write_int(link, "sh_link");
/* Deal with the ugly case of stubs */
fputs(info, output);
fputs("\t#sh_info\n", output);
/* Alignment section in the section headers are different size for 32 and 64bits */
/* The below is broken for BigEndian */
if(64 == BITSIZE)
{
fputs(one_32, output);
fputc(' ', output);
fputs(zero_32, output);
fputs("\t#sh_addralign\n", output);
}
else
{
fputs(one_32, output);
fputs("\t#sh_addralign\n", output);
}
write_register(entry, "sh_entsize");
}
char* get_string(int value, int size, int ByteMode, int shift)
{
char* ch = calloc(42, sizeof(char));
require(NULL != ch, "Exhausted available memory\n");
ch[0] = '\'';
stringify(ch+1, size, ByteMode, value, shift);
if(!BigEndian) LittleEndian(ch+1, ByteMode);
int i = 0;
while(0 != ch[i])
{
i = i + 1;
}
ch[i] = '\'';
return ch;
}
char* setup_string(int value, int number_of_bytes, int ByteMode)
{
int shift;
int size;
if(HEX == ByteMode)
{
size = 2;
shift = 4;
}
else if(OCTAL == ByteMode)
{
size = 3;
shift = 3;
}
else if(BINARY == ByteMode)
{
size = 8;
shift = 1;
}
else
{
fputs("reached impossible mode\n", stderr);
exit(EXIT_FAILURE);
}
return get_string(value, number_of_bytes *size, ByteMode, shift);
}
void setup_strings(int ByteMode)
{
zero_8 = setup_string(0, 1, ByteMode);
zero_16 = setup_string(0, 2, ByteMode);
zero_32 = setup_string(0, 4, ByteMode);
one_16 = setup_string(1, 2, ByteMode);
one_32 = setup_string(1, 4, ByteMode);
two_8 = setup_string(2, 1, ByteMode);
two_32 = setup_string(2, 4, ByteMode);
three_32 = setup_string(3, 4, ByteMode);
six_32 = setup_string(6, 4, ByteMode);
sixteen_32 = setup_string(16, 4, ByteMode);
twentyfour_32 = setup_string(24, 4, ByteMode);
}
/* Standard C main program */
int main(int argc, char **argv)
{
jump_table = NULL;
struct entry* input = NULL;
output = stdout;
char* output_file = "";
entry = "";
BITSIZE = 32;
count = 1;
BigEndian = TRUE;
int ByteMode = HEX;
int set = FALSE;
struct entry* temp;
struct entry* head;
int option_index = 1;
while(option_index <= argc)
{
if(NULL == argv[option_index])
{
option_index = option_index + 1;
}
else if(match(argv[option_index], "-h") || match(argv[option_index], "--help"))
{
fputs("Usage: ", stderr);
fputs(argv[0], stderr);
fputs(" --file FILENAME1 {--file FILENAME2} --output FILENAME\n", stderr);
exit(EXIT_SUCCESS);
}
else if(match(argv[option_index], "--64"))
{
BITSIZE = 64;
option_index = option_index + 1;
}
else if(match(argv[option_index], "-f") || match(argv[option_index], "--file"))
{
temp = calloc(1, sizeof(struct entry));
temp->name = argv[option_index + 1];
temp->next = input;
input = temp;
option_index = option_index + 2;
}
else if(match(argv[option_index], "-o") || match(argv[option_index], "--output"))
{
output_file = argv[option_index + 1];
output = fopen(output_file, "w");
if(NULL == output)
{
fputs("The file: ", stderr);
fputs(input->name, stderr);
fputs(" can not be opened!\n", stderr);
exit(EXIT_FAILURE);
}
option_index = option_index + 2;
}
else if(match(argv[option_index], "-b") || match(argv[option_index], "--binary"))
{
ByteMode = BINARY;
option_index = option_index + 1;
}
else if(match(argv[option_index], "-O") || match(argv[option_index], "--octal"))
{
ByteMode = OCTAL;
option_index = option_index + 1;
}
else if(match(argv[option_index], "-X") || match(argv[option_index], "--hex"))
{
ByteMode = HEX;
option_index = option_index + 1;
}
else if(match(argv[option_index], "--big-endian"))
{
BigEndian = TRUE;
set = TRUE;
option_index = option_index + 1;
}
else if(match(argv[option_index], "--little-endian"))
{
BigEndian = FALSE;
set = TRUE;
option_index = option_index + 1;
}
else if(match(argv[option_index], "-V") || match(argv[option_index], "--version"))
{
fputs("blood-elf 2.0.1\n(Basically Launches Odd Object Dump ExecutabLe Files\n", stdout);
exit(EXIT_SUCCESS);
}
else if(match(argv[option_index], "--entry"))
{
head = calloc(1, sizeof(struct entry));
/* Include _start or any other entry from your .hex2 */
head->next = jump_table;
jump_table = head;
jump_table->name = argv[option_index + 1];
/* However only the last one will be exempt from the _name hidden rule */
entry = argv[option_index + 1];
option_index = option_index + 2;
count = count + 1;
}
else
{
fputs("Unknown option\n", stderr);
exit(EXIT_FAILURE);
}
}
/* Make sure we have a program tape to run */
if (NULL == input)
{
return EXIT_FAILURE;
}
/* Force setting of endianness */
if(!set)
{
fputs("either --little-endian or --big-endian MUST be set\n", stderr);
return EXIT_FAILURE;
}
/* Setup the ugly formating because RISC-V sucks */
setup_strings(ByteMode);
/* Get all of the labels */
first_pass(input);
/* Reverse their order */
jump_table = reverse_list(jump_table);
/* Create sections */
/* Create string names for sections */
fputs("# Generated sections\n:ELF_shstr\n", output);
fputs(zero_8, output);
fputs("\t# NULL\n", output);
fputs(":ELF_shstr__text\n\".text\"\n", output);
fputs(":ELF_shstr__shstr\n\".shstrtab\"\n", output);
fputs(":ELF_shstr__sym\n\".symtab\"\n", output);
fputs(":ELF_shstr__str\n\".strtab\"\n", output);
/* Create NULL section header as is required by the Spec. So dumb and waste of bytes*/
write_section(":ELF_section_headers", zero_32, zero_32, zero_32, zero_32, zero_32, zero_32, zero_32, zero_32, zero_32);
write_section(":ELF_section_header_text", "%ELF_shstr__text>ELF_shstr", one_32, six_32, "&ELF_text", "%ELF_text>ELF_base", "%ELF_data>ELF_text", zero_32, zero_32, zero_32);
write_section(":ELF_section_header_shstr", "%ELF_shstr__shstr>ELF_shstr", three_32, zero_32, "&ELF_shstr", "%ELF_shstr>ELF_base", "%ELF_section_headers>ELF_shstr", zero_32, zero_32, zero_32);
write_section(":ELF_section_header_str", "%ELF_shstr__str>ELF_shstr", three_32, zero_32, "&ELF_str", "%ELF_str>ELF_base", "%ELF_sym>ELF_str", zero_32, zero_32, zero_32);
if(64 == BITSIZE) write_section(":ELF_section_header_sym", "%ELF_shstr__sym>ELF_shstr", two_32, zero_32, "&ELF_sym", "%ELF_sym>ELF_base", "%ELF_end>ELF_sym", three_32, setup_string(count, 4, ByteMode), twentyfour_32);
else write_section(":ELF_section_header_sym", "%ELF_shstr__sym>ELF_shstr", two_32, zero_32, "&ELF_sym", "%ELF_sym>ELF_base", "%ELF_end>ELF_sym", three_32, setup_string(count, 4, ByteMode), sixteen_32);
/* Create dwarf stubs needed for objdump -d to get function names */
output_string_table(jump_table);
output_symbol_table(jump_table);
fputs("\n:ELF_end\n", output);
/* Close output file */
fclose(output);
return EXIT_SUCCESS;
}
mescc-tools-1.5.2/catm.c 0000644 0000000 0000000 00000003211 14522760670 011733 0 ustar /* Copyright (C) 2019 Jeremiah Orians
* This file is part of mescc-tools
*
* mescc-tools is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* mescc-tools is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with mescc-tools. If not, see
#include
#include
#include
// CONSTANT BUFFER_SIZE 4096
#define BUFFER_SIZE 4096
int main(int argc, char** argv)
{
if(2 > argc)
{
fputs("catm requires 2 or more arguments\n", stderr);
exit(EXIT_FAILURE);
}
int output = open(argv[1], 577 , 384);
if(-1 == output)
{
fputs("The file: ", stderr);
fputs(argv[1], stderr);
fputs(" is not a valid output file name\n", stderr);
exit(EXIT_FAILURE);
}
int i;
int bytes;
char* buffer = calloc(BUFFER_SIZE + 1, sizeof(char));
int input;
for(i = 2; i < argc ; i = i + 1)
{
input = open(argv[i], 0, 0);
if(-1 == input)
{
fputs("The file: ", stderr);
fputs(argv[i], stderr);
fputs(" is not a valid input file name\n", stderr);
exit(EXIT_FAILURE);
}
keep:
bytes = read(input, buffer, BUFFER_SIZE);
write(output, buffer, bytes);
if(BUFFER_SIZE == bytes) goto keep;
}
free(buffer);
return EXIT_SUCCESS;
}
mescc-tools-1.5.2/check.sh 0000755 0000000 0000000 00000002551 14522760670 012265 0 ustar #! /usr/bin/env bash
# Copyright © 2017 Jan Nieuwenhuizen
# Copyright © 2017 Jeremiah Orians
# Copyright (C) 2019 ng0
#
# This file is part of mescc-tools
#
# mescc-tools is free software; you can redistribute it and/or modify it
# under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3 of the License, or (at
# your option) any later version.
#
# mescc-tools is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with mescc-tools. If not, see
.br
Jan (janneke) Nieuwenhuizen
.SH COPYRIGHT
Copyright 2016-2019 Jeremiah Orians
.br
Copyright 2017 Jan Nieuwenhuizen
.br
License GPLv3+.
.SH "SEE ALSO"
hex2(1), blood-elf(1), kaem(1), syscalls(2)
mescc-tools-1.5.2/docs/blood-elf.1 0000644 0000000 0000000 00000002546 14522760670 013532 0 ustar .\"Made with Love
.TH blood-elf 1 "JULY 2019" Linux "User Manuals"
.SH NAME
blood-elf - Get mescc with dwarfs
.SH SYNOPSIS
.na
blood-elf --file FILE [--output FILE --64]
.SH DESCRIPTION
blood-elf exists to generate ELF debug tables in M1-macro
format from M1-macro assembly files.
.br
At its core is read until you find :LABEL and then add it
to the list of things to output. It will ignore labels that
have '_' prefixing their name. eg :_foo will not get an entry.
If no output is specified, the result will be sent to Standard
Out.
.br
Fortunately the only architecture difference that you need
to concern yourself with is if your binary is going to be
64bits or 32bits (which is the default) and to pass the flag:
--64 should you need that alternate format
.SH EXAMPLES
Typically, blood-elf will be called in scripts used in bootstrapping
.br
# blood-elf -f cc.M1 -o cc-footer.M1
.br
# blood-elf --file cc.M1 --64 --output cc-footer.M1
.br
.SH COMPATIBILITY
blood-elf is compatible with all Turing complete machines;
even the ones that try to be Turing complete -1.
.SH AUTHORS
Jeremiah Orians
.br
Jan (janneke) Nieuwenhuizen
.SH COPYRIGHT
Copyright 2016-2019 Jeremiah Orians
.br
Copyright 2017 Jan Nieuwenhuizen
.br
License GPLv3+.
.SH "SEE ALSO"
M1(1), hex2(1), kaem(1), syscalls(2)
mescc-tools-1.5.2/docs/get_machine.1 0000644 0000000 0000000 00000003371 14522760670 014127 0 ustar .\"Made with Love
.TH get_machine 1 "JULY 2019" Linux "User Manuals"
.SH NAME
get_machine - identify running hardware architecture
.SH SYNOPSIS
.na
get_machine [ --exact --override OVERRIDE --os ]
.SH DESCRIPTION
get_machine exists to make simple shell scripts that need
to know that hardware architecture it is assuming or what
host operating system is being used.
.br
At its core is figure out the general hardware architecture
and return it as quickly as possible. Although it is sometimes
useful to return something different; which is why --override
exists and thus what ever is supplied by with it is returned.
Scripts that wish to expose that can leverage the environment
variable GET_MACHINE_FLAGS to allow efficient overriding in
their scripts. Or if they wish to only override what Operating
system is running the environment variable GET_MACHINE_OS_FLAGS
should be used.
.br
If one wishes for something more exact than x86 or amd64, the
option --exact will return more specific values like i686-pae.
.br
Should one desire to know the host operating system: --os
.br
A word of warning; --override always will take top precedence
and can return anything you desire.
.SH EXAMPLES
Typically, get_machine will be in scripts used in bootstrapping
.br
# get_machine
.br
# get_machine --override "I am the very model of a modern major general"
.br
# get_machine ${GET_MACHINE_FLAGS}
.br
# get_machine ${GET_MACHINE_OS_FLAGS} --os
.br
.SH COMPATIBILITY
get_machine is compatible with all Turing complete machines;
even the ones that try to be Turing complete -1
.SH AUTHORS
Jeremiah Orians
.SH COPYRIGHT
Copyright 2016-2021 Jeremiah Orians
.br
License GPLv3+.
.SH "SEE ALSO"
M1(1), hex2(1), blood-elf(1), kaem(1), syscalls(2)
mescc-tools-1.5.2/docs/hex2.1 0000644 0000000 0000000 00000004731 14522760670 012533 0 ustar .\"Made with Love
.TH hex2 1 "JULY 2019" Linux "User Manuals"
.SH NAME
hex2 - The trivially bootstrappable linker that is designed to be introspectable by humans
.SH SYNOPSIS
.na
hex2 --architecture ARCHITECTURE --base-address ADDRESS --file FILE [--output FILE [--non-executable]]
.SH DESCRIPTION
hex2 is designed to allow humans to write elf and other binary
files by hand in a format that allows comments and ease of understanding.
.br
At its core is read 2 hex characters add them together
and output a single byte. You can override this and use
binary or octal input if you so desire, using the --octal
or --binary option.
.br
If no output file is specified the output will be send to standard out.
By default the file will be executable unless the option:
--non-executable is also passed.
.br
The supported ARCHITECTURES are as follows: knight-native,
knight-posix, x86, amd64, armv7l and aarch64.
If you fail to specify an architecture, the default of knight-native
will be used.
.br
The base address for which the binary is to be loaded into memory
and thus the relative and absolute pointers should be based,
is passed via --base-address if it is not provided the default
value of ZERO will be assumed.
.br
hex2 also support labels in the :LABEL format and relative
and absolute pointers to those labels in 8, 16, 24 or 32bit sizes.
!LABEL, @LABEL, ~LABEL and %LABEL for 8, 16, 24 and 32bit relative addresses
respectively and $LABEL and &LABEL for 16 and 32bit absolute
addresses respectively.
Should you wish to specify the bit and byte encoding of the
addresses to match your target --big-endian and --little-endian
On architectures that require word alignment the < and ^
characters have a special meaning; particularly pad to word
and use word base address calculation rather than standard
byte based address calculation; generally seen in the form:
^~LABEL EB for calls in ARM
.SH EXAMPLES
Typically, hex2 will be called in scripts used in bootstrapping
.br
# hex2 -f ELF-armv7l.hex2 -f cc.hex2 --little-endian --architecture armv7l --base-address 0x10000 -o cc
.br
.SH COMPATIBILITY
hex2 is compatible with all Turing complete machines;
even the ones that try to be Turing complete -1
.SH AUTHORS
Jeremiah Orians
.br
Jan (janneke) Nieuwenhuizen
.SH COPYRIGHT
Copyright 2016-2019 Jeremiah Orians
.br
Copyright 2017 Jan Nieuwenhuizen
.br
License GPLv3+.
.SH "SEE ALSO"
M1(1), blood-elf(1), kaem(1), syscalls(2)
mescc-tools-1.5.2/docs/kaem.1 0000644 0000000 0000000 00000003201 14522760670 012571 0 ustar .\"Made with Love
.TH kaem 1 "JULY 2019" Linux "User Manuals"
.SH NAME
kaem - Like running with scissors but shell scripts without a shell
.SH SYNOPSIS
.na
kaem [--file FILE --strict --verbose --nightmare-mode]
.SH DESCRIPTION
kaem exists to be the most minimal shell needed in the bootstrap
processes; that has the ability to function as an init
thus allowing the bootstrap to occur with only itself and a
hex0 assembler as the only binaries running on the system.
.br
At its core is read a line (except when the line is terminated
with a '\\', when it is read the next line too) and then collect
the arguments into an array, lookup the program in the path
provided by the name or if not found in the ENVIRONMENT and
then execute the program with the specified options.
.br
If no filename is passed, it then attempts to execute a file
called kaem.run; which is the standard name for kaem scripts.
If you wish for kaem to stop when one of the lines throws or
returns an error code, simply add --strict. If you wish to
see what is being executed, simply add --verbose. If you
hate dealing with an environment and want to eliminate it
entirely --nightmare-mode.
.SH EXAMPLES
Typically, kaem will be in running scripts used in bootstrapping
.br
# kaem --verbose --strict
.br
# kaem -f bootstrap.sh --nightmare-mode
.br
.SH COMPATIBILITY
kaem is compatible with all Turing complete machines;
even the ones that try to be Turing complete -1
.SH AUTHORS
Jeremiah Orians
.SH COPYRIGHT
Copyright 2016-2019 Jeremiah Orians
.br
License GPLv3+.
.SH "SEE ALSO"
M1(1), hex2(1), blood-elf(1), get_machine(1), syscalls(2)
mescc-tools-1.5.2/elf_headers/elf32-ARM-debug.hex2 0000644 0000000 0000000 00000005713 14522760670 016321 0 ustar ### Copyright (C) 2016 Jeremiah Orians
### Copyright (C) 2017 Jan Nieuwenhuizen
### This file is part of stage0.
###
### stage0 is free software: you can redistribute it and/or modify
### it under the terms of the GNU General Public License as published by
### the Free Software Foundation, either version 3 of the License, or
### (at your option) any later version.
###
### stage0 is distributed in the hope that it will be useful,
### but WITHOUT ANY WARRANTY; without even the implied warranty of
### MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
### GNU General Public License for more details.
###
### You should have received a copy of the GNU General Public License
### along with stage0. If not, see 1 byte relative
### $ 2 byte address
### @ 2 byte relative
### & 4 byte address
### % 4 byte relative
### elf32.hex2: 32 bit elf header in hex2
### if you wish to use this header, you need to add :ELF_end to the end of your
### M1 or hex2 files.
## ELF Header
:ELF_base
7F 45 4C 46 # e_ident[EI_MAG0-3] ELF's magic number
01 # e_ident[EI_CLASS] Indicating 32 bit
01 # e_ident[EI_DATA] Indicating little endianness
01 # e_ident[EI_VERSION] Indicating original elf
03 # e_ident[EI_OSABI] Set at 3 because FreeBSD is strict
00 # e_ident[EI_ABIVERSION] See above
00 00 00 00 00 00 00 # e_ident[EI_PAD]
02 00 # e_type Indicating Executable
28 00 # e_machine Indicating 32bit ARM
01 00 00 00 # e_version Indicating original elf
&_start # e_entry Address of the entry point
%ELF_program_headers>ELF_base # e_phoff Address of program header table
%ELF_section_headers>ELF_base # e_shoff Address of section header table
00 02 00 05 # e_flags
34 00 # e_ehsize Indicating our 52 Byte header
20 00 # e_phentsize size of a program header table
01 00 # e_phnum number of entries in program table
28 00 # e_shentsize size of a section header table
05 00 # e_shnum number of entries in section table
02 00 # e_shstrndx index of the section names
# @40
:ELF_program_headers
:ELF_program_header__text
01 00 00 00 # ph_type: PT-LOAD = 1
00 00 00 00 # ph_offset
&ELF_base # ph_vaddr
&ELF_base # ph_physaddr
%ELF_end>ELF_base # ph_filesz
%ELF_end>ELF_base # ph_memsz
07 00 00 00 # ph_flags: PF-X|PF-W|PF-R = 7
00 00 01 00 # alignment
:ELF_text
mescc-tools-1.5.2/elf_headers/elf32-ARM.hex2 0000644 0000000 0000000 00000005726 14522760670 015241 0 ustar ### Copyright (C) 2016 Jeremiah Orians
### Copyright (C) 2017 Jan Nieuwenhuizen
### This file is part of stage0.
###
### stage0 is free software: you can redistribute it and/or modify
### it under the terms of the GNU General Public License as published by
### the Free Software Foundation, either version 3 of the License, or
### (at your option) any later version.
###
### stage0 is distributed in the hope that it will be useful,
### but WITHOUT ANY WARRANTY; without even the implied warranty of
### MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
### GNU General Public License for more details.
###
### You should have received a copy of the GNU General Public License
### along with stage0. If not, see 1 byte relative
### $ 2 byte address
### @ 2 byte relative
### & 4 byte address
### % 4 byte relative
### elf32.hex2: 32 bit elf header in hex2
### if you wish to use this header, you need to add :ELF_end to the end of your
### M1 or hex2 files.
## ELF Header
:ELF_base
7F 45 4C 46 # e_ident[EI_MAG0-3] ELF's magic number
01 # e_ident[EI_CLASS] Indicating 32 bit
01 # e_ident[EI_DATA] Indicating little endianness
01 # e_ident[EI_VERSION] Indicating original elf
03 # e_ident[EI_OSABI] Set at 3 because FreeBSD is strict
00 # e_ident[EI_ABIVERSION] See above
00 00 00 00 00 00 00 # e_ident[EI_PAD]
02 00 # e_type Indicating Executable
28 00 # e_machine Indicating 32bit ARM
01 00 00 00 # e_version Indicating original elf
&_start # e_entry Address of the entry point
%ELF_program_headers>ELF_base # e_phoff Address of program header table
00 00 00 00 # e_shoff Address of section header table
00 02 00 05 # e_flags
34 00 # e_ehsize Indicating our 52 Byte header
20 00 # e_phentsize size of a program header table
01 00 # e_phnum number of entries in program table
00 00 # e_shentsize size of a section header table
00 00 # e_shnum number of entries in section table
00 00 # e_shstrndx index of the section names
## Program Header
:ELF_program_headers
:ELF_program_header__text
01 00 00 00 # ph_type: PT-LOAD = 1
00 00 00 00 # ph_offset
&ELF_base # ph_vaddr
&ELF_base # ph_physaddr
%ELF_end>ELF_base # ph_filesz
%ELF_end>ELF_base # ph_memsz
07 00 00 00 # ph_flags: PF-X|PF-W|PF-R = 7
00 00 01 00 # alignment
:ELF_text
mescc-tools-1.5.2/elf_headers/elf32-debug.hex2 0000644 0000000 0000000 00000005677 14522760670 015715 0 ustar ### Copyright (C) 2016 Jeremiah Orians
### Copyright (C) 2017 Jan Nieuwenhuizen
### This file is part of stage0.
###
### stage0 is free software: you can redistribute it and/or modify
### it under the terms of the GNU General Public License as published by
### the Free Software Foundation, either version 3 of the License, or
### (at your option) any later version.
###
### stage0 is distributed in the hope that it will be useful,
### but WITHOUT ANY WARRANTY; without even the implied warranty of
### MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
### GNU General Public License for more details.
###
### You should have received a copy of the GNU General Public License
### along with stage0. If not, see 1 byte relative
### $ 2 byte address
### @ 2 byte relative
### & 4 byte address
### % 4 byte relative
### local_ function-local
### string_ string #
### elf32-header-exit-42.hex2: 32 bit elf header in hex2 for `exit 42'
:ELF_base
7F 45 4C 46 # e_ident[EI_MAG0-3] ELF's magic number
01 # e_ident[EI_CLASS] Indicating 32 bit
01 # e_ident[EI_DATA] Indicating little endianness
01 # e_ident[EI_VERSION] Indicating original elf
03 # e_ident[EI_OSABI] Set at 3 because FreeBSD is strict
00 # e_ident[EI_ABIVERSION] See above
00 00 00 00 00 00 00 # e_ident[EI_PAD]
02 00 # e_type Indicating Executable
03 00 # e_machine Indicating AMD64
01 00 00 00 # e_version Indicating original elf
&_start # e_entry Address of the entry point
%ELF_program_headers>ELF_base # e_phoff Address of program header table
%ELF_section_headers>ELF_base # e_shoff Address of section header table
00 00 00 00 # e_flags
34 00 # e_ehsize Indicating our 52 Byte header
20 00 # e_phentsize size of a program header table
01 00 # e_phnum number of entries in program table
28 00 # e_shentsize size of a section header table
05 00 # e_shnum number of entries in section table
02 00 # e_shstrndx index of the section names
:ELF_program_headers
:ELF_program_header__text
01 00 00 00 # ph_type: PT-LOAD = 1
00 00 00 00 # ph_offset
&ELF_base # ph_vaddr
&ELF_base # ph_physaddr
%ELF_end>ELF_base # ph_filesz
%ELF_end>ELF_base # ph_memsz
07 00 00 00 # ph_flags: PF-X|PF-W|PF-R = 7
01 00 00 00 # ph_align
:ELF_text
mescc-tools-1.5.2/elf_headers/elf32.hex2 0000644 0000000 0000000 00000005717 14522760670 014624 0 ustar ### Copyright (C) 2016 Jeremiah Orians
### Copyright (C) 2017 Jan Nieuwenhuizen
### This file is part of stage0.
###
### stage0 is free software: you can redistribute it and/or modify
### it under the terms of the GNU General Public License as published by
### the Free Software Foundation, either version 3 of the License, or
### (at your option) any later version.
###
### stage0 is distributed in the hope that it will be useful,
### but WITHOUT ANY WARRANTY; without even the implied warranty of
### MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
### GNU General Public License for more details.
###
### You should have received a copy of the GNU General Public License
### along with stage0. If not, see 1 byte relative
### $ 2 byte address
### @ 2 byte relative
### & 4 byte address
### % 4 byte relative
### elf32.hex2: 32 bit elf header in hex2
### if you wish to use this header, you need to add :ELF_end to the end of your
### M1 or hex2 files.
## ELF Header
:ELF_base
7F 45 4C 46 # e_ident[EI_MAG0-3] ELF's magic number
01 # e_ident[EI_CLASS] Indicating 32 bit
01 # e_ident[EI_DATA] Indicating little endianness
01 # e_ident[EI_VERSION] Indicating original elf
03 # e_ident[EI_OSABI] Set at 3 because FreeBSD is strict
00 # e_ident[EI_ABIVERSION] See above
00 00 00 00 00 00 00 # e_ident[EI_PAD]
02 00 # e_type Indicating Executable
03 00 # e_machine Indicating x86
01 00 00 00 # e_version Indicating original elf
&_start # e_entry Address of the entry point
%ELF_program_headers>ELF_base # e_phoff Address of program header table
00 00 00 00 # e_shoff Address of section header table
00 00 00 00 # e_flags
34 00 # e_ehsize Indicating our 52 Byte header
20 00 # e_phentsize size of a program header table
01 00 # e_phnum number of entries in program table
00 00 # e_shentsize size of a section header table
00 00 # e_shnum number of entries in section table
00 00 # e_shstrndx index of the section names
## Program Header
:ELF_program_headers
:ELF_program_header__text
01 00 00 00 # ph_type: PT-LOAD = 1
00 00 00 00 # ph_offset
&ELF_base # ph_vaddr
&ELF_base # ph_physaddr
%ELF_end>ELF_base # ph_filesz
%ELF_end>ELF_base # ph_memsz
07 00 00 00 # ph_flags: PF-X|PF-W|PF-R = 7
01 00 00 00 # ph_align
:ELF_text
mescc-tools-1.5.2/elf_headers/elf64-ARM.hex2 0000644 0000000 0000000 00000006316 14522760670 015242 0 ustar ### Copyright (C) 2016 Jeremiah Orians
### Copyright (C) 2017 Jan Nieuwenhuizen
### This file is part of stage0.
###
### stage0 is free software: you can redistribute it and/or modify
### it under the terms of the GNU General Public License as published by
### the Free Software Foundation, either version 3 of the License, or
### (at your option) any later version.
###
### stage0 is distributed in the hope that it will be useful,
### but WITHOUT ANY WARRANTY; without even the implied warranty of
### MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
### GNU General Public License for more details.
###
### You should have received a copy of the GNU General Public License
### along with stage0. If not, see
### This file is part of stage0.
###
### stage0 is free software: you can redistribute it and/or modify
### it under the terms of the GNU General Public License as published by
### the Free Software Foundation, either version 3 of the License, or
### (at your option) any later version.
###
### stage0 is distributed in the hope that it will be useful,
### but WITHOUT ANY WARRANTY; without even the implied warranty of
### MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
### GNU General Public License for more details.
###
### You should have received a copy of the GNU General Public License
### along with stage0. If not, see
### This file is part of stage0.
###
### stage0 is free software: you can redistribute it and/or modify
### it under the terms of the GNU General Public License as published by
### the Free Software Foundation, either version 3 of the License, or
### (at your option) any later version.
###
### stage0 is distributed in the hope that it will be useful,
### but WITHOUT ANY WARRANTY; without even the implied warranty of
### MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
### GNU General Public License for more details.
###
### You should have received a copy of the GNU General Public License
### along with stage0. If not, see
### This file is part of stage0.
###
### stage0 is free software: you can redistribute it and/or modify
### it under the terms of the GNU General Public License as published by
### the Free Software Foundation, either version 3 of the License, or
### (at your option) any later version.
###
### stage0 is distributed in the hope that it will be useful,
### but WITHOUT ANY WARRANTY; without even the implied warranty of
### MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
### GNU General Public License for more details.
###
### You should have received a copy of the GNU General Public License
### along with stage0. If not, see
#include
#include
int match(char* a, char* b);
#define TRUE 1
//CONSTANT TRUE 1
#define FALSE 0
//CONSTANT FALSE 0
/* Standard C main program */
int main(int argc, char **argv)
{
int exact = FALSE;
int override = FALSE;
char* override_string;
int option_index = 1;
struct utsname* unameData = calloc(1, sizeof(struct utsname));
uname(unameData);
while(option_index <= argc)
{
if(NULL == argv[option_index])
{
option_index = option_index + 1;
}
else if(match(argv[option_index], "--exact"))
{
exact = TRUE;
option_index = option_index + 1;
}
else if(match(argv[option_index], "--override"))
{
override = TRUE;
if((option_index + 1) < argc)
{
override_string = argv[option_index + 1];
option_index = option_index + 2;
}
else
{
fputs("--override requires an actual override string\n", stderr);
exit(EXIT_FAILURE);
}
}
else if(match(argv[option_index], "--os") || match(argv[option_index], "--OS"))
{
if(override) fputs(override_string, stdout);
else fputs(unameData->sysname, stdout);
fputc('\n', stdout);
exit(EXIT_SUCCESS);
}
else if(match(argv[option_index], "--blood"))
{
if(override) fputs(override_string, stdout);
else if(match("aarch64", unameData->machine)
|| match("amd64", unameData->machine)
|| match("ppc64le", unameData->machine)
|| match("riscv64", unameData->machine)
|| match("x86_64", unameData->machine)) fputs("--64", stdout);
fputc('\n', stdout);
exit(EXIT_SUCCESS);
}
else if(match(argv[option_index], "--endian"))
{
if(override) fputs(override_string, stdout);
else if(match("aarch64", unameData->machine)
|| match("amd64", unameData->machine)
|| match("ppc64le", unameData->machine)
|| match("riscv64", unameData->machine)
|| match("x86_64", unameData->machine)
|| match("i386", unameData->machine)
|| match("i486", unameData->machine)
|| match("i586", unameData->machine)
|| match("i686", unameData->machine)
|| match("i686-pae", unameData->machine))fputs("--little-endian", stdout);
else fputs("--big-endian", stdout);
fputc('\n', stdout);
exit(EXIT_SUCCESS);
}
else if(match(argv[option_index], "--hex2"))
{
if(override) fputs(override_string, stdout);
else if(match("aarch64", unameData->machine)) fputs("0x400000", stdout);
else if(match("armv7l", unameData->machine)) fputs("0x10000", stdout);
else if(match("amd64", unameData->machine)
|| match("x86_64", unameData->machine)) fputs("0x600000", stdout);
else if(match("ppc64le", unameData->machine)) fputs("0x10000", stdout);
else if(match("riscv64", unameData->machine)) fputs("0x600000", stdout);
else if(match("i386", unameData->machine)
|| match("i486", unameData->machine)
|| match("i586", unameData->machine)
|| match("i686", unameData->machine)
|| match("i686-pae", unameData->machine)) fputs("0x08048000", stdout);
else fputs("0x0", stdout);
fputc('\n', stdout);
exit(EXIT_SUCCESS);
}
else if(match(argv[option_index], "-V") || match(argv[option_index], "--version"))
{
fputs("get_machine 1.5.0\n", stdout);
exit(EXIT_SUCCESS);
}
else if(match(argv[option_index], "-h") || match(argv[option_index], "--help"))
{
fputs("If you want exact architecture use --exact\n", stderr);
fputs("If you want to know the Operating system use --os\n", stderr);
fputs("If you wish to override the output to anything you want use --override\n", stderr);
exit(EXIT_SUCCESS);
}
else
{
fputs("Unknown option\n", stderr);
exit(EXIT_FAILURE);
}
}
if(override) fputs(override_string, stdout);
else if(!exact)
{
if(match("i386", unameData->machine) ||
match("i486", unameData->machine) ||
match("i586", unameData->machine) ||
match("i686", unameData->machine) ||
match("i686-pae", unameData->machine)) fputs("x86", stdout);
else if(match("x86_64", unameData->machine)) fputs("amd64", stdout);
else fputs(unameData->machine, stdout);
}
else fputs(unameData->machine, stdout);
fputs("\n", stdout);
return EXIT_SUCCESS;
}
mescc-tools-1.5.2/guix.scm 0000644 0000000 0000000 00000006461 14522760670 012335 0 ustar ;;; guix.scm -- Guix package definition
;;; mescc-tools
;;; Copyright © 2017 Jan Nieuwenhuizen
;;; Copyright 2016 Jeremiah Orians
;;; Also borrowing code from:
;;; guile-sdl2 --- FFI bindings for SDL2
;;; Copyright © 2015 David Thompson
;;;
;;; guix.scm: This file is part of mescc-tools.
;;;
;;; mescc-tools is free software; you can redistribute it and/or modify it
;;; under the terms of the GNU General Public License as published by
;;; the Free Software Foundation; either version 3 of the License, or (at
;;; your option) any later version.
;;;
;;; mescc-tools is distributed in the hope that it will be useful, but
;;; WITHOUT ANY WARRANTY; without even the implied warranty of
;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;; GNU General Public License for more details.
;;;
;;; You should have received a copy of the GNU General Public License
;;; along with mescc-tools. If not, see
* This file is part of mescc-tools
*
* mescc-tools is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* mescc-tools is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with mescc-tools. If not, see
* This file is part of mescc-tools
*
* mescc-tools is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* mescc-tools is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with mescc-tools. If not, see
#include
#include
#include
#include
#include "M2libc/bootstrappable.h"
#define max_string 4096
#define TRUE 1
#define FALSE 0
#define KNIGHT 0
#define X86 0x03
#define AMD64 0x3E
#define ARMV7L 0x28
#define AARM64 0xB7
#define PPC64LE 0x15
#define RISCV32 0xF3
#define RISCV64 0x100F3 /* Because RISC-V unlike all other architectures does get a seperate e_machine when changing from 32 to 64bit */
#define HEX 16
#define OCTAL 8
#define BINARY 2
struct input_files
{
struct input_files* next;
char* filename;
};
struct entry
{
struct entry* next;
unsigned target;
char* name;
};
mescc-tools-1.5.2/hex2_globals.h 0000644 0000000 0000000 00000003224 14522760670 013371 0 ustar /* -*- c-file-style: "linux";indent-tabs-mode:t -*- */
/* Copyright (C) 2017 Jeremiah Orians
* Copyright (C) 2017 Jan Nieuwenhuizen
* This file is part of mescc-tools
*
* mescc-tools is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* mescc-tools is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with mescc-tools. If not, see
* This file is part of mescc-tools
*
* mescc-tools is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* mescc-tools is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with mescc-tools. If not, see
* This file is part of mescc-tools
*
* mescc-tools is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* mescc-tools is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with mescc-tools. If not, see
;;; Copyright 2016 Jeremiah Orians
;;; guix.scm: This file is part of mescc-tools.
;;;
;;; mescc-tools is free software; you can redistribute it and/or modify it
;;; under the terms of the GNU General Public License as published by
;;; the Free Software Foundation; either version 3 of the License, or (at
;;; your option) any later version.
;;;
;;; mescc-tools is distributed in the hope that it will be useful, but
;;; WITHOUT ANY WARRANTY; without even the implied warranty of
;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;; GNU General Public License for more details.
;;;
;;; You should have received a copy of the GNU General Public License
;;; along with mescc-tools. If not, see
# Copyright (C) 2019 Jeremiah Orians
#
# This file is part of mescc-tools
#
# mescc-tools is free software; you can redistribute it and/or modify it
# under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3 of the License, or (at
# your option) any later version.
#
# mescc-tools is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with mescc-tools. If not, see
* This file is part of mescc-tools.
*
* mescc-tools is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* mescc-tools is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with mescc-tools. If not, see
// CONSTANT HEX 16
#define HEX 16
// CONSTANT OCTAL 8
#define OCTAL 8
// CONSTANT BINARY 2
#define BINARY 2
/***********************************************************
* Needed for current implementation of little endian *
* Can be used to support little bit endian instruction *
* sets if we ever find one that might be useful *
* But I seriously doubt it *
***********************************************************/
void reverseBitOrder(char* c, int ByteMode)
{
if(NULL == c) return;
if(0 == c[1]) return;
int hold = c[0];
if(HEX == ByteMode)
{
c[0] = c[1];
c[1] = hold;
reverseBitOrder(c+2, ByteMode);
}
else if(OCTAL == ByteMode)
{
c[0] = c[2];
c[2] = hold;
reverseBitOrder(c+3, ByteMode);
}
else if(BINARY == ByteMode)
{
c[0] = c[7];
c[7] = hold;
hold = c[1];
c[1] = c[6];
c[6] = hold;
hold = c[2];
c[2] = c[5];
c[5] = hold;
hold = c[3];
c[3] = c[4];
c[4] = hold;
reverseBitOrder(c+8, ByteMode);
}
}
void LittleEndian(char* start, int ByteMode)
{
char* end = start;
char* c = start;
while(0 != end[0]) end = end + 1;
int hold;
for(end = end - 1; start < end; start = start + 1)
{
hold = start[0];
start[0] = end[0];
end[0] = hold;
end = end - 1;
}
/* The above makes a reversed bit order */
reverseBitOrder(c, ByteMode);
}
int hex2char(int c)
{
if((c >= 0) && (c <= 9)) return (c + 48);
else if((c >= 10) && (c <= 15)) return (c + 55);
else return -1;
}
int stringify(char* s, int digits, int divisor, int value, int shift)
{
int i = value;
if(digits > 1)
{
i = stringify(s+1, (digits - 1), divisor, value, shift);
}
s[0] = hex2char(i & (divisor - 1));
return (i >> shift);
}
mescc-tools-1.5.2/test.sh 0000755 0000000 0000000 00000001524 14522760670 012166 0 ustar #! /bin/sh
## Copyright (C) 2017 Jeremiah Orians
## This file is part of stage0.
##
## stage0 is free software: you can redistribute it and/or modify
## it under the terms of the GNU General Public License as published by
## the Free Software Foundation, either version 3 of the License, or
## (at your option) any later version.
##
## stage0 is distributed in the hope that it will be useful,
## but WITHOUT ANY WARRANTY; without even the implied warranty of
## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
## GNU General Public License for more details.
##
## You should have received a copy of the GNU General Public License
## along with stage0. If not, see 1 byte relative
## $ 2 byte address
## @