void declerations(int level) {
if(token == TK_DECLARE) {
debug(level,"DECLERATIONS");
debug_lex();
varlist(level+1);
if(token == TK_ENDDECLARE) {
debug_lex();
} else {
/* syntax error enddeclare */
syntax_error("'enddeclare' expected");
}
}
}
int main (int argc, char *argv[])
{
#ifdef WIN32
char *callname = argv[0];
#endif
char linecopy[MAXLINE];
DATASET *dset = NULL;
MODEL *model = NULL;
ExecState state;
char *line = NULL;
int quiet = 0;
int makepkg = 0;
int load_datafile = 1;
char filearg[MAXLEN];
char runfile[MAXLEN];
double scriptval = NADBL;
CMD cmd;
PRN *prn = NULL;
PRN *cmdprn = NULL;
int err = 0;
#ifdef G_OS_WIN32
win32_set_gretldir(callname);
#endif
nls_init();
#ifdef HAVE_READLINE
rl_bind_key(0x18, ctrl_x);
#endif
dset = datainfo_new();
if (dset == NULL) {
noalloc();
}
if (argc < 2) {
load_datafile = 0;
} else {
gretlopt opt = 0;
err = parse_options(&argc, &argv, &opt, &scriptval, filearg);
if (!err && (opt & (OPT_DBOPEN | OPT_WEBDB))) {
/* catch GUI-only options */
err = E_BADOPT;
}
if (err) {
/* bad option */
usage(1);
} else if (opt & (OPT_HELP | OPT_VERSION)) {
/* we'll exit in these cases */
if (opt & OPT_HELP) {
usage(0);
} else {
logo(0);
exit(EXIT_SUCCESS);
}
}
if (opt & (OPT_BATCH | OPT_RUNIT | OPT_MAKEPKG)) {
if (*filearg == '\0') {
/* we're missing a filename argument */
usage(1);
} else {
/* record argument (not a datafile) */
strcpy(runfile, filearg);
load_datafile = 0;
if (opt & OPT_BATCH) {
batch = 1;
} else if (opt & OPT_MAKEPKG) {
batch = 1;
makepkg = 1;
} else {
runit = 1;
}
}
} else if (*filearg == '\0') {
load_datafile = 0;
}
if (opt & OPT_QUIET) {
quiet = 1;
}
if (opt & OPT_ENGLISH) {
force_language(LANG_C);
}
}
libgretl_init();
logo(quiet);
if (!quiet) {
session_time(NULL);
}
prn = gretl_print_new(GRETL_PRINT_STDOUT, &err);
if (err) {
noalloc();
}
line = malloc(MAXLINE);
if (line == NULL) {
noalloc();
}
#ifdef WIN32
win32_cli_read_rc(callname);
#else
cli_read_rc();
#endif /* WIN32 */
if (!batch) {
strcpy(cmdfile, gretl_workdir());
strcat(cmdfile, "session.inp");
cmdprn = gretl_print_new_with_filename(cmdfile, &err);
if (err) {
errmsg(err, prn);
return EXIT_FAILURE;
}
}
if (load_datafile) {
handle_datafile(filearg, runfile, dset, prn, cmdprn);
}
/* allocate memory for model */
model = allocate_working_model();
if (model == NULL) {
noalloc();
}
gretl_cmd_init(&cmd);
gretl_exec_state_init(&state, 0, line, &cmd, model, prn);
set_debug_read_func(get_interactive_line);
/* print list of variables */
if (data_status) {
varlist(dset, prn);
}
if (!na(scriptval)) {
/* define "scriptopt" */
gretl_scalar_add("scriptopt", scriptval);
}
/* misc. interactive-mode setup */
if (!batch) {
check_help_file();
fb = stdin;
push_input_file(fb);
if (!runit && !data_status) {
fputs(_("Type \"open filename\" to open a data set\n"), stdout);
}
}
#ifdef HAVE_READLINE
initialize_readline();
#endif
if (batch || runit) {
/* re-initialize: will be incremented by "run" cmd */
runit = 0;
if (makepkg) {
set_gretl_echo(0);
}
if (strchr(runfile, ' ')) {
sprintf(line, "run \"%s\"", runfile);
} else {
sprintf(line, "run %s", runfile);
}
err = cli_exec_line(&state, dset, cmdprn);
if (err && fb == NULL) {
exit(EXIT_FAILURE);
}
}
*linecopy = '\0';
/* main command loop */
while (cmd.ci != QUIT && fb != NULL && !xout) {
if (err && gretl_error_is_fatal()) {
gretl_abort(linecopy);
}
if (gretl_execute_loop()) {
if (gretl_loop_exec(&state, dset, NULL)) {
return 1;
}
} else {
err = cli_get_input_line(&state);
if (err) {
errmsg(err, prn);
break;
}
}
if (!state.in_comment) {
if (cmd.context == FOREIGN || cmd.context == MPI ||
gretl_compiling_python(line)) {
tailstrip(line);
} else {
err = maybe_get_input_line_continuation(line);
if (err) {
errmsg(err, prn);
break;
}
}
}
strcpy(linecopy, line);
tailstrip(linecopy);
err = cli_exec_line(&state, dset, cmdprn);
} /* end of get commands loop */
if (!err) {
err = gretl_if_state_check(0);
if (err) {
errmsg(err, prn);
}
}
if (makepkg && !err) {
switch_ext(filearg, runfile, "gfn");
sprintf(line, "makepkg %s\n", filearg);
cli_exec_line(&state, dset, cmdprn);
}
/* leak check -- try explicitly freeing all memory allocated */
destroy_working_model(model);
destroy_dataset(dset);
if (fb != stdin && fb != NULL) {
fclose(fb);
}
free(line);
gretl_print_destroy(prn);
gretl_cmd_free(&cmd);
libgretl_cleanup();
return 0;
}
static int cli_open_append (CMD *cmd, DATASET *dset,
MODEL *model, PRN *prn)
{
gretlopt opt = cmd->opt;
PRN *vprn = prn;
char newfile[MAXLEN] = {0};
char response[3];
int http = 0, dbdata = 0;
int ftype;
int err = 0;
if (opt & OPT_K) {
/* --frompkg=whatever */
err = get_package_data_path(cmd->param, newfile);
if (err) {
errmsg(err, prn);
return err;
}
} else {
err = cli_try_http(cmd->param, newfile, &http);
if (err) {
errmsg(err, prn);
return err;
}
if (!http && !(opt & OPT_O)) {
/* not using http or ODBC */
err = get_full_filename(cmd->param, newfile, (opt & OPT_W)?
OPT_W : OPT_NONE);
if (err) {
errmsg(err, prn);
return err;
}
}
}
if (opt & OPT_W) {
ftype = GRETL_NATIVE_DB_WWW;
} else if (opt & OPT_O) {
ftype = GRETL_ODBC;
} else {
ftype = detect_filetype(newfile, OPT_P);
}
dbdata = (ftype == GRETL_NATIVE_DB || ftype == GRETL_NATIVE_DB_WWW ||
ftype == GRETL_RATS_DB || ftype == GRETL_PCGIVE_DB ||
ftype == GRETL_ODBC);
if (data_status && !batch && !dbdata && cmd->ci != APPEND &&
strcmp(newfile, datafile)) {
fprintf(stderr, _("Opening a new data file closes the "
"present one. Proceed? (y/n) "));
if (fgets(response, sizeof response, stdin) != NULL &&
*response != 'y' && *response != 'Y') {
pprintf(prn, _("OK, staying with current data set\n"));
return 0;
}
}
if (!dbdata && cmd->ci != APPEND) {
cli_clear_data(cmd, dset, model);
}
if (opt & OPT_Q) {
/* --quiet, but in case we hit any problems below... */
vprn = gretl_print_new(GRETL_PRINT_BUFFER, NULL);
}
if (ftype == GRETL_XML_DATA || ftype == GRETL_BINARY_DATA) {
err = gretl_read_gdt(newfile, dset, opt, vprn);
} else if (ftype == GRETL_CSV) {
err = import_csv(newfile, dset, opt, vprn);
} else if (SPREADSHEET_IMPORT(ftype)) {
err = import_spreadsheet(newfile, ftype, cmd->list, cmd->parm2,
dset, opt, vprn);
} else if (OTHER_IMPORT(ftype)) {
err = import_other(newfile, ftype, dset, opt, vprn);
} else if (ftype == GRETL_ODBC) {
err = set_odbc_dsn(cmd->param, vprn);
} else if (dbdata) {
err = set_db_name(newfile, ftype, vprn);
} else {
err = gretl_get_data(newfile, dset, opt, vprn);
}
if (vprn != prn) {
if (err) {
/* The user asked for --quiet operation, but something
went wrong so let's print any info we got on
vprn.
*/
const char *buf = gretl_print_get_buffer(vprn);
if (buf != NULL && *buf != '\0') {
pputs(prn, buf);
}
} else {
/* print minimal success message */
pprintf(prn, _("Read datafile %s\n"), newfile);
}
gretl_print_destroy(vprn);
}
if (err) {
errmsg(err, prn);
return err;
}
if (!dbdata && !http && cmd->ci != APPEND) {
strncpy(datafile, newfile, MAXLEN - 1);
}
data_status = 1;
if (dset->v > 0 && !dbdata && !(opt & OPT_Q)) {
varlist(dset, prn);
}
if (http) {
remove(newfile);
}
return err;
}
void
OGLShaderObject::_initActiveUniformBlock() noexcept
{
GLint numUniformBlock = 0;
GLint maxUniformBlockLength = 0;
GLint maxUniformLength = 0;
glGetProgramiv(_program, GL_ACTIVE_UNIFORM_BLOCKS, &numUniformBlock);
glGetProgramiv(_program, GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH, &maxUniformBlockLength);
glGetProgramiv(_program, GL_ACTIVE_UNIFORM_MAX_LENGTH, &maxUniformLength);
if (numUniformBlock)
{
auto nameUniformBlock = make_scope<GLchar[]>(maxUniformBlockLength + 1);
nameUniformBlock[maxUniformBlockLength] = 0;
for (GLint i = 0; i < numUniformBlock; ++i)
{
GLsizei lengthUniformBlock;
glGetActiveUniformBlockName(_program, (GLuint)i, maxUniformBlockLength, &lengthUniformBlock, nameUniformBlock.get());
GLuint location = glGetUniformBlockIndex(_program, nameUniformBlock.get());
if (location == GL_INVALID_INDEX)
continue;
glUniformBlockBinding(_program, location, location);
GLint size;
GLint count;
glGetActiveUniformBlockiv(_program, location, GL_UNIFORM_BLOCK_DATA_SIZE, &size);
glGetActiveUniformBlockiv(_program, location, GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS, &count);
if (count)
{
std::vector<GLint> indices(count);
glGetActiveUniformBlockiv(_program, location, GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES, indices.data());
std::vector<GLint> offset((std::size_t)count);
std::vector<GLint> type((std::size_t)count);
std::vector<GLint> datasize((std::size_t)count);
std::vector<std::string> varlist((std::size_t)count);
std::vector<GLchar> name(maxUniformLength);
glGetActiveUniformsiv(_program, count, (GLuint*)&indices[0], GL_UNIFORM_OFFSET, &offset[0]);
glGetActiveUniformsiv(_program, count, (GLuint*)&indices[0], GL_UNIFORM_TYPE, &type[0]);
glGetActiveUniformsiv(_program, count, (GLuint*)&indices[0], GL_UNIFORM_SIZE, &datasize[0]);
for (GLint j = 0; j < count; ++j)
{
GLsizei length = 0;
#if !defined(EGLAPI)
glGetActiveUniformName(_program, indices[j], maxUniformLength, &length, name.data());
#else
glGetActiveUniform(_program, indices[j], maxUniformLength, &length, &datasize[j], (GLenum*)&type[j], name.data());
#endif
varlist[j].append(name.data(), length);
}
auto uniformblock = std::make_shared<ShaderUniform>();
uniformblock->setName(nameUniformBlock.get());
uniformblock->setType(ShaderVariantType::SPT_BUFFER);
uniformblock->setLocation(location);
_activeUniforms.push_back(uniformblock);
}
}
}
}
