static bool _pblaze_parseOptions(int *pargc, char **argv, int *i)
{
char *dialecttype;
if (ISOPT(DIALECT_OPT)) {
dialecttype = getStringArg(DIALECT_OPT, argv, i, *pargc);
if (!STRCASECMP(dialecttype, "pblazeide"))
pblaze_options.dialect = 0;
else if (!STRCASECMP(dialecttype, "kcpsm3"))
pblaze_options.dialect = 1;
else {
fprintf(stderr, "Unknown dialect type: %s\nAvaiable options: pblazeide or kcpsm3\n", dialecttype);
exit(EXIT_FAILURE);
}
return TRUE;
}
if (ISOPT(PORTKW_OPT)) {
pblaze_options.portKw = Safe_strdup(getStringArg(PORTKW_OPT, argv, i, *pargc));
return TRUE;
}
if (ISOPT(ACKNOWLEDGEMENT_OPT)) {
fprintf(stderr, "The development of this pblaze-port was supported by the Czech Ministry of Education, Youth and Sports grant 2C06008 Virtual Laboratory of Microprocessor Technology Application (visit the website http://www.vlam.cz).");
exit(EXIT_FAILURE);
return TRUE;
}
return FALSE;
}
String FileFunction::getEncodingArg( ExternalFunction::Arguments_t const &args,
unsigned pos ) const {
String encoding( getStringArg( args, pos ) );
if ( encoding.empty() )
encoding = "UTF-8"; // the default file encoding
return encoding;
}
int ICACHE_FLASH_ATTR cgiNFCSet(HttpdConnData *connData) {
if (connData->conn==NULL) return HTTPD_CGI_DONE;
// handle NFC server settings
int8_t nfc_server = 0; // accumulator for changes/errors
nfc_server |= getStringArg(connData, "nfc-url",
flashConfig.nfc_url, sizeof(flashConfig.nfc_url));
if (nfc_server < 0) return HTTPD_CGI_DONE;
nfc_server |= getStringArg(connData, "nfc-device-id",
flashConfig.nfc_device_id, sizeof(flashConfig.nfc_device_id));
if (nfc_server < 0) return HTTPD_CGI_DONE;
nfc_server |= getStringArg(connData, "nfc-device-secret",
flashConfig.nfc_device_secret, sizeof(flashConfig.nfc_device_secret));
if (nfc_server < 0) return HTTPD_CGI_DONE;
char buff[16];
// handle nfc counter
if (httpdFindArg(connData->getArgs, "nfc-counter", buff, sizeof(buff)) > 0) {
uint32_t counter = atoi(buff);
if (counter > 0 && counter < 4294967295) {
flashConfig.nfc_counter = counter;
nfc_server |= 1;
} else {
errorResponse(connData, 400, "Invalid NFC counter!");
return HTTPD_CGI_DONE;
}
}
DBG("Saving config\n");
if (configSave()) {
httpdStartResponse(connData, 200);
httpdEndHeaders(connData);
} else {
httpdStartResponse(connData, 500);
httpdEndHeaders(connData);
httpdSend(connData, "Failed to save config", -1);
}
return HTTPD_CGI_DONE;
}
ItemSequence_t WriteTextFunctionImpl::evaluate(
ExternalFunction::Arguments_t const &args,
StaticContext const*,
DynamicContext const* ) const
{
String const path( getPathArg( args, 0 ) );
String const encoding( getStringArg( args, 2 ) );
fs::type const fs_type = fs::get_type( path );
if ( fs_type && fs_type != fs::file )
raiseFileError( "FOFL0004", "not a plain file", path );
if ( !transcode::is_supported( encoding.c_str() ) )
raiseFileError( "FOFL9999", "encoding not supported", encoding );
ios_base::openmode const mode = ios_base::out
| (append_ ? ios_base::app : ios_base::trunc);
ofstream ofs( path.c_str(), mode );
if ( !ofs ) {
ostringstream oss;
oss << '"' << path << "\": can not open file for writing";
raiseFileError( "FOFL9999", oss.str().c_str(), path );
}
transcode::auto_attach<ofstream> transcoder;
if ( transcode::is_necessary( encoding.c_str() ) )
transcoder.attach( ofs, encoding.c_str() );
Iterator_t it( args[1]->getIterator() );
it->open();
Item item;
while ( it->next( item ) ) {
if ( item.isStreamable() ) {
ofs << item.getStream().rdbuf();
} else {
zorba::String const s( item.getStringValue() );
ofs.write( s.data(), s.size() );
}
if ( newlines_ )
ofs << fs::newline;
}
it->close();
return ItemSequence_t( new EmptySequence() );
}
int execute(int argc, char* argv[])
{
if (argc <= 1) {
showHelp();
return RESULT_EC_SUCCESS;
}
std::string fileInput = argv[1];
int errorlevel = 0;
int limit = -1;
bool info = false;
bool help = false;
for (int i = 1; i < argc; i++)
{
getStringArg(fileInput, argv[i], "file");
getIntArg(errorlevel, argv[i], "errorlevel");
getIntArg(limit, argv[i], "limit");
getBoolArg(info, argv[i], "info");
getBoolArg(help, argv[i], "help");
}
if (help) {
showHelp();
return RESULT_EC_SUCCESS;
}
if (errorlevel < 0 || errorlevel > 3)
{
std::cerr << "Invalid value for errorlevel: " << errorlevel << std::endl;
return RESULT_EC_INVALIDERRORLEVEL;
}
int width = 0;
int height = 0;
std::vector<std::string> lines;
try
{
std::ifstream file(fileInput);
if (!file.is_open())
{
std::cerr << "Cannot open file: " << fileInput << std::endl;
return RESULT_EC_FILEREADEXCEPTION;
}
std::string str;
bool first = true;
while (std::getline(file, str))
{
// UTF-8 BOM
if (first && str.length() >= 3 && (uint8_t)str.at(0) == 0xEF && (uint8_t)str.at(1) == 0xBB && (uint8_t)str.at(2) == 0xBF)
{
str = str.substr(3);
}
lines.push_back(str);
width = std::max(width, (int)str.length());
height++;
first = false;
}
}
catch (const std::exception& ex)
{
std::cerr << "Cannot open/read file " << fileInput << std::endl;
std::cerr << ex.what() << std::endl;
return RESULT_EC_FILEREADEXCEPTION;
}
catch (...)
{
std::cerr << "Unknown internal exception in file " << __FILE__ << " at line " << __LINE__ << std::endl;
return RESULT_EC_UNKNOWNEXCEPTION;
}
if (width <= 0 || height <= 0)
{
std::cerr << "The program has an size of zero" << std::endl;
return RESULT_EC_INVALIDSIZE;
}
IBefungeRunner *runner;
if (info)
{
runner = new BefungeRunnerInfo(width, height);
}
else if (errorlevel == 0)
{
runner = new BefungeRunner0(width, height);
}
else if (errorlevel == 1)
{
runner = new BefungeRunner1(width, height);
}
else if (errorlevel == 2)
{
runner = new BefungeRunner2(width, height);
}
else if (errorlevel == 3)
{
runner = new BefungeRunner3(width, height);
}
else
{
std::cerr << "Cannot create a befunge runner for the supplied parameters" << std::endl;
return RESULT_EC_INVALIDRUNNER;
}
runner->Init(lines);
runner->SetLimit(limit);
try
{
runner->Run();
}
catch (const BFRunException& ex)
{
std::cerr << ex.what() << std::endl;
return ex.exitCode;
}
catch (const std::exception& ex)
{
std::cerr << "Internal exception while running program:" << std::endl;
std::cerr << ex.what() << std::endl;
return RESULT_EC_UNKNOWNEXCEPTION;
}
catch (...)
{
std::cerr << "Unknown internal exception in file " << __FILE__ << " at line " << __LINE__ << std::endl;
return RESULT_EC_UNKNOWNEXCEPTION;
}
delete runner;
return RESULT_EC_SUCCESS;
}
static bool
_parseOptions (int *pargc, char **argv, int *i)
{
if (argv[*i][0] == '-')
{
if (IS_GB)
{
if (!strncmp (argv[*i], OPTION_BO, sizeof (OPTION_BO) - 1))
{
/* ROM bank */
int bank = getIntArg (OPTION_BO, argv, i, *pargc);
struct dbuf_s buffer;
dbuf_init (&buffer, 16);
dbuf_printf (&buffer, "CODE_%u", bank);
dbuf_c_str (&buffer);
/* ugly, see comment in src/port.h (borutr) */
gbz80_port.mem.code_name = dbuf_detach (&buffer);
options.code_seg = (char *)gbz80_port.mem.code_name;
return TRUE;
}
else if (!strncmp (argv[*i], OPTION_BA, sizeof (OPTION_BA) - 1))
{
/* RAM bank */
int bank = getIntArg (OPTION_BA, argv, i, *pargc);
struct dbuf_s buffer;
dbuf_init (&buffer, 16);
dbuf_printf (&buffer, "DATA_%u", bank);
dbuf_c_str (&buffer);
/* ugly, see comment in src/port.h (borutr) */
gbz80_port.mem.data_name = dbuf_detach (&buffer);
return TRUE;
}
}
else if (!strncmp (argv[*i], OPTION_ASM, sizeof (OPTION_ASM) - 1))
{
char *asmblr = getStringArg (OPTION_ASM, argv, i, *pargc);
if (!strcmp (asmblr, "rgbds"))
{
asm_addTree (&_rgbds_gb);
gbz80_port.assembler.cmd = _gbz80_rgbasmCmd;
gbz80_port.linker.cmd = _gbz80_rgblinkCmd;
gbz80_port.linker.do_link = _gbz80_rgblink;
_G.asmType = ASM_TYPE_RGBDS;
return TRUE;
}
else if (!strcmp (asmblr, "asxxxx"))
{
_G.asmType = ASM_TYPE_ASXXXX;
return TRUE;
}
else if (!strcmp (asmblr, "isas"))
{
asm_addTree (&_isas_gb);
/* Munge the function prefix */
gbz80_port.fun_prefix = "";
_G.asmType = ASM_TYPE_ISAS;
return TRUE;
}
else if (!strcmp (asmblr, "z80asm"))
{
port->assembler.externGlobal = TRUE;
asm_addTree (&_z80asm_z80);
_G.asmType = ASM_TYPE_ISAS;
return TRUE;
}
}
else if (!strncmp (argv[*i], OPTION_PORTMODE, sizeof (OPTION_PORTMODE) - 1))
{
char *portmode = getStringArg (OPTION_ASM, argv, i, *pargc);
if (!strcmp (portmode, "z80"))
{
z80_opts.port_mode = 80;
return TRUE;
}
else if (!strcmp (portmode, "z180"))
{
z80_opts.port_mode = 180;
return TRUE;
}
}
}
return FALSE;
}
static bool
_json_parseOptions (int *pargc, char **argv, int *i)
{
/* TODO: allow port-specific command line options to specify
* segment names here.
*/
int j=0;
//char *stkmodel;
/* check for arguments that have associated an integer variable */
while(json_optionsTable[j].pparameter) {
if(ISOPT( json_optionsTable[j].longOpt )) {
(*(int *)json_optionsTable[j].pparameter)++;
return TRUE;
}
j++;
}
/*
if(ISOPT(STACK_MODEL)) {
stkmodel = getStringArg(STACK_MODEL, argv, i, *pargc);
if(!STRCASECMP(stkmodel, "small"))picoBlaze_options.stack_model = 0;
else if(!STRCASECMP(stkmodel, "large"))picoBlaze_options.stack_model = 1;
else {
fprintf(stderr, "Unknown stack model: %s", stkmodel);
exit(EXIT_FAILURE);
}
return TRUE;
}
if(ISOPT(IVT_LOC)) {
picoBlaze_options.ivt_loc = getIntArg(IVT_LOC, argv, i, *pargc);
fprintf(stderr, "%s:%d setting interrupt vector addresses 0x%x\n", __FILE__, __LINE__, picoBlaze_options.ivt_loc);
return TRUE;
}
if(ISOPT(USE_CRT)) {
picoBlaze_options.no_crt = 0;
picoBlaze_options.crt_name = Safe_strdup( getStringArg(USE_CRT, argv, i, *pargc) );
return TRUE;
}
if (ISOPT(NO_OPTIMIZE_GOTO)) {
picoBlaze_options.opt_flags |= OF_NO_OPTIMIZE_GOTO;
return TRUE;
}
if(ISOPT(OPTIMIZE_CMP)) {
picoBlaze_options.opt_flags |= OF_OPTIMIZE_CMP;
return TRUE;
}
if (ISOPT(OPTIMIZE_DF)) {
picoBlaze_options.opt_flags |= OF_OPTIMIZE_DF;
return TRUE;
}
*/
if (ISOPT(GEN_JSON)) {
json_options.json_flag = TRUE;
if (ISOPT(GEN_JSONFILE)) { // inside block because JSON and JSON-FILE have common starting substring checked in arguments
json_options.json_dumpfile = Safe_strdup( getStringArg(GEN_JSONFILE, argv, i, *pargc) );
}
return TRUE;
}
return FALSE;
}
