mirror of
https://github.com/reactos/reactos.git
synced 2024-11-18 21:13:52 +00:00
316 lines
9 KiB
C++
316 lines
9 KiB
C++
#include <stdio.h>
|
|
#include <iostream>
|
|
#include <fstream>
|
|
#include <sstream>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
class ofw_wrappers {
|
|
public:
|
|
int base, ctindex, method_ctindex;
|
|
std::string functions;
|
|
std::string names;
|
|
std::string calltable;
|
|
std::string le_stubs;
|
|
std::string of_call;
|
|
};
|
|
|
|
class vartype {
|
|
public:
|
|
vartype( const std::string &typestr ) {
|
|
size_t amp = typestr.find('&');
|
|
size_t col = typestr.find(':');
|
|
if( amp != std::string::npos ) {
|
|
if( col > amp && col != std::string::npos )
|
|
lit_value = typestr.substr(amp+1,col-amp+1);
|
|
else lit_value = typestr.substr(amp+1);
|
|
}
|
|
if( col != std::string::npos ) {
|
|
if( amp > col && amp != std::string::npos )
|
|
len = typestr.substr(col+1,amp-col+1);
|
|
else len = typestr.substr(col+1);
|
|
}
|
|
|
|
if( amp != std::string::npos && amp < col ) col = amp;
|
|
if( col == std::string::npos ) col = typestr.size();
|
|
c_type = typestr.substr(0,col);
|
|
}
|
|
|
|
vartype( const vartype &other )
|
|
: c_type(other.c_type),
|
|
len(other.len),
|
|
lit_value(other.lit_value) {
|
|
}
|
|
|
|
vartype &operator = ( const vartype &other ) {
|
|
c_type = other.c_type;
|
|
len = other.len;
|
|
lit_value = other.lit_value;
|
|
return *this;
|
|
}
|
|
|
|
std::string c_type;
|
|
std::string len;
|
|
std::string lit_value;
|
|
};
|
|
|
|
std::string uppercase( const std::string &toucase ) {
|
|
std::vector<char> ucase_work(toucase.size());
|
|
for( size_t i = 0; i < toucase.size(); i++ ) {
|
|
ucase_work[i] = toupper(toucase[i]);
|
|
}
|
|
return std::string(&ucase_work[0], toucase.size());
|
|
}
|
|
|
|
std::string clip_eol( std::string in, const std::string &eol_marks ) {
|
|
size_t found;
|
|
for( size_t i = 0; i < eol_marks.size(); i++ ) {
|
|
found = in.find( eol_marks[i] );
|
|
if( found != std::string::npos )
|
|
in = in.substr( 0, found );
|
|
}
|
|
return in;
|
|
}
|
|
|
|
int round_up( int x, int factor ) {
|
|
return (x + (factor - 1)) & ~(factor - 1);
|
|
}
|
|
|
|
void populate_definition( ofw_wrappers &wrapper, const std::string &line ) {
|
|
std::istringstream iss(line);
|
|
bool make_function = true, method_call = false, make_stub = true, comma;
|
|
std::string name, nametext, argtype, rettype;
|
|
std::vector<vartype> argtypes;
|
|
int args, rets, i, local_offset, total_stack, userarg_start = 0;
|
|
size_t f;
|
|
std::ostringstream function, ct_csource, le_stub, of_call;
|
|
|
|
iss >> name >> args >> rets;
|
|
|
|
if( !name.size() ) return;
|
|
|
|
if( (f = name.find('!')) != std::string::npos ) {
|
|
nametext = name.substr(f+1);
|
|
name = name.substr(0,f);
|
|
}
|
|
if( name[0] == '-' ) {
|
|
name = name.substr(1);
|
|
make_function = false;
|
|
}
|
|
if( name[0] == '+' ) {
|
|
name = name.substr(1);
|
|
make_stub = false;
|
|
}
|
|
if( name[0] == '@' ) {
|
|
name = name.substr(1);
|
|
method_call = true;
|
|
make_function = false;
|
|
}
|
|
|
|
if( !nametext.size() ) nametext = name;
|
|
|
|
for( i = 1; i < (int)name.size(); i++ )
|
|
if( name[i] == '-' ) name[i] = '_';
|
|
|
|
if( nametext == "call-method" )
|
|
wrapper.method_ctindex = wrapper.ctindex;
|
|
|
|
for( i = 0; i < args; i++ ) {
|
|
iss >> argtype;
|
|
argtypes.push_back(vartype(argtype));
|
|
}
|
|
|
|
if( method_call ) {
|
|
userarg_start = 1;
|
|
args += 2;
|
|
}
|
|
|
|
iss >> rettype;
|
|
if( !rettype.size() ) rettype = "void";
|
|
|
|
local_offset = (3 + rets + args) * 4;
|
|
total_stack = round_up(12 + local_offset, 16);
|
|
|
|
function << "asm_ofw_" << name << ":\n"
|
|
<< "\t/* Reserve stack space */\n"
|
|
<< "\tsubi %r1,%r1," << total_stack << "\n"
|
|
<< "\t/* Store r8, r9, lr */\n"
|
|
<< "\tstw %r8," << (local_offset + 0) << "(%r1)\n"
|
|
<< "\tstw %r9," << (local_offset + 4) << "(%r1)\n"
|
|
<< "\tmflr %r8\n"
|
|
<< "\tstw %r8," << (local_offset + 8) << "(%r1)\n"
|
|
<< "\t/* Get read name */\n"
|
|
<< "\tlis %r8," << name << "_ofw_name@ha\n"
|
|
<< "\taddi %r9,%r8," << name << "_ofw_name@l\n"
|
|
<< "\tstw %r9,0(%r1)\n"
|
|
<< "\t/* " << args << " arguments and " << rets << " return */\n"
|
|
<< "\tli %r9," << args << "\n"
|
|
<< "\tstw %r9,4(%r1)\n"
|
|
<< "\tli %r9," << rets << "\n"
|
|
<< "\tstw %r9,8(%r1)\n";
|
|
|
|
for( int i = 0; i < args; i++ )
|
|
function << "\tstw %r" << (i+3) << "," << (4 * (i + 3)) << "(%r1)\n";
|
|
|
|
function << "\t/* Load up the call address */\n"
|
|
<< "\tlis %r10,ofw_call_addr@ha\n"
|
|
<< "\tlwz %r9,ofw_call_addr@l(%r10)\n"
|
|
<< "\tmtlr %r9\n"
|
|
<< "\t/* Set argument */\n"
|
|
<< "\tmr %r3,%r1\n"
|
|
<< "\t/* Fire */\n"
|
|
<< "\tblrl\n"
|
|
<< "\tlwz %r3," << (local_offset - 4) << "(%r1)\n"
|
|
<< "\t/* Restore registers */\n"
|
|
<< "\tlwz %r8," << (local_offset + 8) << "(%r1)\n"
|
|
<< "\tmtlr %r8\n"
|
|
<< "\tlwz %r9," << (local_offset + 4) << "(%r1)\n"
|
|
<< "\tlwz %r8," << (local_offset + 0) << "(%r1)\n"
|
|
<< "\t/* Return */\n"
|
|
<< "\taddi %r1,%r1," << total_stack << "\n"
|
|
<< "\tblr\n";
|
|
|
|
if( method_call ) {
|
|
argtypes.insert(argtypes.begin(),vartype("int"));
|
|
argtypes.insert(argtypes.begin(),vartype("char*"));
|
|
}
|
|
|
|
le_stub << rettype << " ofw_" << name << "(";
|
|
|
|
comma = false;
|
|
for( i = userarg_start; i < args; i++ ) {
|
|
if( !argtypes[i].lit_value.size() ) {
|
|
if( !comma ) comma = true; else le_stub << ",";
|
|
le_stub << argtypes[i].c_type << " arg" << i;
|
|
}
|
|
}
|
|
le_stub << ")";
|
|
of_call << le_stub.str() << ";\n";
|
|
|
|
le_stub << " {\n";
|
|
if( rettype != "void" )
|
|
le_stub << "\t" << rettype << " ret;\n";
|
|
|
|
if( method_call ) {
|
|
le_stub << "\tchar arg0["
|
|
<< round_up(nametext.size()+1,8)
|
|
<< "] = \"" << nametext << "\";\n";
|
|
}
|
|
|
|
for( i = 0; i < args; i++ ) {
|
|
if( argtypes[i].lit_value.size() ) {
|
|
le_stub << "\t" << argtypes[i].c_type << " arg" << i << " = "
|
|
<< argtypes[i].lit_value << ";\n";
|
|
}
|
|
}
|
|
|
|
le_stub << "\t";
|
|
if( rettype != "void" ) le_stub << "ret = (" << rettype << ")";
|
|
|
|
le_stub << "ofproxy(" <<
|
|
(method_call ? (wrapper.method_ctindex * 4) : (wrapper.ctindex * 4));
|
|
|
|
for( i = 0; i < 6; i++ ) {
|
|
if( i < args ) le_stub << ",(void *)arg" << i;
|
|
else le_stub << ",NULL";
|
|
}
|
|
|
|
le_stub << ");\n";
|
|
|
|
if( rettype != "void" )
|
|
le_stub << "\treturn ret;\n";
|
|
|
|
le_stub << "}\n";
|
|
|
|
if( make_function ) wrapper.functions += function.str();
|
|
if( make_stub ) {
|
|
wrapper.le_stubs += le_stub.str();
|
|
wrapper.of_call += of_call.str();
|
|
}
|
|
if( !method_call ) {
|
|
wrapper.names += name + "_ofw_name:\n\t.asciz \"" + nametext + "\"\n";
|
|
wrapper.calltable += std::string("\t.long asm_ofw_") + name + "\n";
|
|
wrapper.ctindex++;
|
|
}
|
|
}
|
|
|
|
int main( int argc, char **argv ) {
|
|
int status = 0;
|
|
std::ifstream in;
|
|
std::ofstream out, outcsource, outcheader;
|
|
std::string line;
|
|
const char *eol_marks = "#\r\n";
|
|
ofw_wrappers wrappers;
|
|
|
|
wrappers.base = 0xe00000;
|
|
wrappers.ctindex = 0;
|
|
|
|
if( argc < 5 ) {
|
|
fprintf( stderr, "%s [interface.ofw] [ofw.s] [le_stub.c] [le_stub.h]\n", argv[0] );
|
|
return 1;
|
|
}
|
|
|
|
in.open( argv[1] );
|
|
if( !in ) {
|
|
fprintf( stderr, "can't open %s\n", argv[1] );
|
|
status = 1;
|
|
goto error;
|
|
}
|
|
|
|
out.open( argv[2] );
|
|
if( !out ) {
|
|
fprintf( stderr, "can't open %s\n", argv[2] );
|
|
status = 1;
|
|
goto error;
|
|
}
|
|
|
|
outcsource.open( argv[3] );
|
|
if( !outcsource ) {
|
|
fprintf( stderr, "can't open %s\n", argv[3] );
|
|
status = 1;
|
|
goto error;
|
|
}
|
|
|
|
outcheader.open( argv[4] );
|
|
if( !outcheader ) {
|
|
fprintf( stderr, "can't open %s\n", argv[4] );
|
|
status = 1;
|
|
goto error;
|
|
}
|
|
|
|
while( std::getline( in, line ) ) {
|
|
line = clip_eol( line, eol_marks );
|
|
if( line.size() ) populate_definition( wrappers, line );
|
|
}
|
|
|
|
out << "/* AUTOMATICALLY GENERATED BY ofw_interface */\n"
|
|
<< "\t.section .text\n"
|
|
<< "\t.align 4\n"
|
|
<< "\t.globl _start\n"
|
|
<< "\t.globl ofw_functions\n"
|
|
<< "\t.globl ofw_call_addr\n"
|
|
<< "ofw_call_addr:\n"
|
|
<< "\t.long 0\n"
|
|
<< "\n/* Function Wrappers */\n\n"
|
|
<< wrappers.functions
|
|
<< "\n/* Function Names */\n\n"
|
|
<< wrappers.names
|
|
<< "\n/* Function Call Table for Freeldr */\n\n"
|
|
<< "\t.align 4\n"
|
|
<< "ofw_functions:\n"
|
|
<< wrappers.calltable
|
|
<< "\n/* End */\n";
|
|
|
|
outcsource << "/* AUTOMATICALLY GENERATED BY ofw_interface */\n"
|
|
<< "#include \"of.h\"\n"
|
|
<< wrappers.le_stubs;
|
|
|
|
outcheader << "/* AUTOMATICALLY GENERATE BY ofw_interface */\n"
|
|
<< "#ifndef _OFW_CALLS_H\n"
|
|
<< "#define _OFW_CALLS_H\n"
|
|
<< wrappers.of_call
|
|
<< "#endif/*_OFW_CALLS_H*/\n";
|
|
|
|
error:
|
|
return status;
|
|
}
|