int main()
{
char st[100];
printf("\nEnter the input statement:");
//gets(st);
strcpy(st,"id = id DIV int - int * int ;");
oparse(st);
return EXIT_SUCCESS;
}
/* {{{ proto int ora_parse(int cursor, string sql_statement [, int defer])
Parse an Oracle SQL statement */
void php3_Ora_Parse(INTERNAL_FUNCTION_PARAMETERS)
{
/* cursor_ind, sql_statement [, defer] */
int argc;
pval *argv[3];
oraCursor *cursor;
sword defer = 0;
text *query;
argc = ARG_COUNT(ht);
if ((argc != 2 && argc != 3) || getParametersArray(ht, argc, argv) == FAILURE) {
WRONG_PARAM_COUNT;
}
convert_to_long(argv[0]);
convert_to_string(argv[1]);
if (argc == 3) {
convert_to_long(argv[2]);
if (argv[2]->value.lval != 0) {
defer = DEFER_PARSE;
}
}
query = (text *) estrndup(argv[1]->value.str.val,argv[1]->value.str.len);
if (query == NULL) {
php3_error(E_WARNING, "Invalid query");
RETURN_FALSE;
}
if (!(cursor = ora_get_cursor(list, argv[0]->value.lval))){
efree(query);
RETURN_FALSE;
}
if (cursor->query) {
efree(cursor->query);
}
cursor->query = query;
cursor->fetched = 0;
if(cursor->params && cursor->nparams > 0){
_php3_hash_destroy(cursor->params);
efree(cursor->params);
cursor->params = NULL;
cursor->nparams = 0;
}
if (oparse(&cursor->cda, query, (sb4) - 1, defer, VERSION_7)) {
php3_error(E_WARNING, "Ora_Parse failed (%s)",
ora_error(&cursor->cda));
RETURN_FALSE;
}
RETURN_TRUE;
}
static int _ora_ping(oraConnection *conn)
{
Cda_Def cda;
if (oopen(&cda, &conn->lda, (text *) 0, -1, -1, (text *) 0, -1)) {
return 0;
}
if (oparse(&cda, "select sysdate from dual", (sb4) - 1, 0, VERSION_7)) {
oclose(&cda);
return 0;
}
oclose(&cda);
return 1;
}
int main(int argc, char* argv[])
{
puts("args: path/to/obj path/to/bmp");
FILE* const fobj =
oload(argc == 3 ? argv[1] : "model/salesman.obj");
SDL_Surface* const fdif =
sload(argc == 3 ? argv[2] : "model/salesman.bmp");
const Obj obj = oparse(fobj);
const Triangles tv = tvgen(obj); // Triangle Vertices.
const Triangles tt = ttgen(obj); // Triangle Textures.
const Triangles tn = tngen(obj); // Triangle Normals.
const Sdl sdl = ssetup(800, 600);
float* const zbuff = (float*) malloc(sizeof(float) * sdl.xres * sdl.yres);
for(Input input = iinit(); !input.done; input = ipump(input))
{
uint32_t* const pixel = slock(sdl);
reset(zbuff, pixel, sdl.xres * sdl.yres);
const Vertex center = { 0.0f, 0.0f, 0.0f };
const Vertex upward = { 0.0f, 1.0f, 0.0f };
const Vertex eye = { sinf(input.xt), sinf(input.yt), cosf(input.xt) };
const Vertex z = vunit(vsub(eye, center));
const Vertex x = vunit(vcross(upward, z));
const Vertex y = vcross(z, x);
for(int i = 0; i < tv.count; i++)
{
const Triangle nrm = tviewnrm(tn.triangle[i], x, y, z);
const Triangle tex = tt.triangle[i];
const Triangle tri = tviewtri(tv.triangle[i], x, y, z, eye);
const Triangle per = tperspective(tri);
const Triangle vew = tviewport(per, sdl);
const Target target = { vew, nrm, tex, fdif };
tdraw(sdl.yres, pixel, zbuff, target);
}
sunlock(sdl);
schurn(sdl);
spresent(sdl);
}
// Let the OS free hoisted memory for a quick exit.
return 0;
}
Cda_Def *DBConnection_ORACLE::ExecuteQuery(char *p_query, DBString *p_arguments, int p_argument_count)
{
int t_affected_rows;
t_affected_rows = 0;
unsigned int t_query_length;
t_query_length = strlen(p_query);
Cda_Def *t_cursor;
t_cursor = new Cda_Def;
bool t_success;
t_success = true;
sword t_error;
if (t_success)
{
t_error = oopen(t_cursor, getLDA(), (text *)0, -1, -1, NULL, -1);
if (t_error != 0)
t_success = false;
}
char *t_parsed_query;
t_parsed_query = p_query;
PlaceholderMap t_placeholder_map;
if (p_argument_count != 0)
{
t_placeholder_map . length = 0;
t_placeholder_map . elements = new int[p_argument_count + 1];
DBBuffer t_query_buffer(t_query_length + 1);
t_success = processQuery(p_query, t_query_buffer, queryCallback, &t_placeholder_map);
t_query_length = t_query_buffer . getSize();
t_parsed_query = t_query_buffer . grab();
}
if (t_success)
{
if (oparse(t_cursor, (text *)t_parsed_query, t_query_length, DEFER_PARSE, PARSE_V7_LNG) != 0)
t_success = false;
}
if (t_success)
{
if (!BindVariables(t_cursor, p_arguments, p_argument_count, &t_placeholder_map))
t_success = false;
}
if (t_success)
{
t_error = oexec(t_cursor);
if (t_error != 0)
t_success = false;
}
if (!t_success)
{
delete t_cursor;
t_cursor = NULL;
}
return t_cursor;
}
static int
perform_oracle_search(uschar *query, uschar *server, uschar **resultptr,
uschar **errmsg, BOOL *defer_break)
{
Cda_Def *cda = NULL;
struct cda_def *oracle_handle = NULL;
Ora_Describe *desc = NULL;
Ora_Define *def = NULL;
void *hda = NULL;
int i;
int ssize = 0;
int offset = 0;
int yield = DEFER;
unsigned int num_fields = 0;
uschar *result = NULL;
oracle_connection *cn = NULL;
uschar *server_copy = NULL;
uschar *sdata[4];
uschar tmp[1024];
/* Disaggregate the parameters from the server argument. The order is host,
database, user, password. We can write to the string, since it is in a
nextinlist temporary buffer. The copy of the string that is used for caching
has the password removed. This copy is also used for debugging output. */
for (i = 3; i > 0; i--)
{
uschar *pp = Ustrrchr(server, '/');
if (pp == NULL)
{
*errmsg = string_sprintf("incomplete ORACLE server data: %s", server);
*defer_break = TRUE;
return DEFER;
}
*pp++ = 0;
sdata[i] = pp;
if (i == 3) server_copy = string_copy(server); /* sans password */
}
sdata[0] = server; /* What's left at the start */
/* If the database is the empty string, set it NULL - the query must then
define it. */
if (sdata[1][0] == 0) sdata[1] = NULL;
/* See if we have a cached connection to the server */
for (cn = oracle_connections; cn != NULL; cn = cn->next)
{
if (strcmp(cn->server, server_copy) == 0)
{
oracle_handle = cn->handle;
hda = cn->hda_mem;
break;
}
}
/* If no cached connection, we must set one up */
if (cn == NULL)
{
DEBUG(D_lookup) debug_printf("ORACLE new connection: host=%s database=%s "
"user=%s\n", sdata[0], sdata[1], sdata[2]);
/* Get store for a new connection, initialize it, and connect to the server */
oracle_handle = store_get(sizeof(struct cda_def));
hda = store_get(HDA_SIZE);
memset(hda,'\0',HDA_SIZE);
/*
* Perform a default (blocking) login
*
* sdata[0] = tnsname (service name - typically host name)
* sdata[1] = dbname - not used at present
* sdata[2] = username
* sdata[3] = passwd
*/
if(olog(oracle_handle, hda, sdata[2], -1, sdata[3], -1, sdata[0], -1,
(ub4)OCI_LM_DEF) != 0)
{
*errmsg = oracle_error(oracle_handle, oracle_handle->rc,
US"connection failed");
*defer_break = FALSE;
goto ORACLE_EXIT_NO_VALS;
}
/* Add the connection to the cache */
cn = store_get(sizeof(oracle_connection));
cn->server = server_copy;
cn->handle = oracle_handle;
cn->next = oracle_connections;
cn->hda_mem = hda;
oracle_connections = cn;
}
/* Else use a previously cached connection - we can write to the server string
to obliterate the password because it is in a nextinlist temporary buffer. */
else
{
DEBUG(D_lookup)
debug_printf("ORACLE using cached connection for %s\n", server_copy);
}
/* We have a connection. Open a cursor and run the query */
cda = store_get(sizeof(Cda_Def));
if (oopen(cda, oracle_handle, (text *)0, -1, -1, (text *)0, -1) != 0)
{
*errmsg = oracle_error(oracle_handle, cda->rc, "failed to open cursor");
*defer_break = FALSE;
goto ORACLE_EXIT_NO_VALS;
}
if (oparse(cda, (text *)query, (sb4) -1,
(sword)PARSE_NO_DEFER, (ub4)PARSE_V7_LNG) != 0)
{
*errmsg = oracle_error(oracle_handle, cda->rc, "query failed");
*defer_break = FALSE;
oclose(cda);
goto ORACLE_EXIT_NO_VALS;
}
/* Find the number of fields returned and sort out their types. If the number
is one, we don't add field names to the data. Otherwise we do. */
def = store_get(sizeof(Ora_Define)*MAX_SELECT_LIST_SIZE);
desc = store_get(sizeof(Ora_Describe)*MAX_SELECT_LIST_SIZE);
if ((num_fields = describe_define(cda,def,desc)) == -1)
{
*errmsg = oracle_error(oracle_handle, cda->rc, "describe_define failed");
*defer_break = FALSE;
goto ORACLE_EXIT;
}
if (oexec(cda)!=0)
{
*errmsg = oracle_error(oracle_handle, cda->rc, "oexec failed");
*defer_break = FALSE;
goto ORACLE_EXIT;
}
/* Get the fields and construct the result string. If there is more than one
row, we insert '\n' between them. */
while (cda->rc != NO_DATA_FOUND) /* Loop for each row */
{
ofetch(cda);
if(cda->rc == NO_DATA_FOUND) break;
if (result != NULL) result = string_cat(result, &ssize, &offset, "\n", 1);
/* Single field - just add on the data */
if (num_fields == 1)
result = string_cat(result, &ssize, &offset, def[0].buf, def[0].col_retlen);
/* Multiple fields - precede by file name, removing {lead,trail}ing WS */
else for (i = 0; i < num_fields; i++)
{
int slen;
uschar *s = US desc[i].buf;
while (*s != 0 && isspace(*s)) s++;
slen = Ustrlen(s);
while (slen > 0 && isspace(s[slen-1])) slen--;
result = string_cat(result, &ssize, &offset, s, slen);
result = string_cat(result, &ssize, &offset, US"=", 1);
/* int and float type wont ever need escaping. Otherwise, quote the value
if it contains spaces or is empty. */
if (desc[i].dbtype != INT_TYPE && desc[i].dbtype != FLOAT_TYPE &&
(def[i].buf[0] == 0 || strchr(def[i].buf, ' ') != NULL))
{
int j;
result = string_cat(result, &ssize, &offset, "\"", 1);
for (j = 0; j < def[i].col_retlen; j++)
{
if (def[i].buf[j] == '\"' || def[i].buf[j] == '\\')
result = string_cat(result, &ssize, &offset, "\\", 1);
result = string_cat(result, &ssize, &offset, def[i].buf+j, 1);
}
result = string_cat(result, &ssize, &offset, "\"", 1);
}
else switch(desc[i].dbtype)
{
case INT_TYPE:
sprintf(CS tmp, "%d", def[i].int_buf);
result = string_cat(result, &ssize, &offset, tmp, Ustrlen(tmp));
break;
case FLOAT_TYPE:
sprintf(CS tmp, "%f", def[i].flt_buf);
result = string_cat(result, &ssize, &offset, tmp, Ustrlen(tmp));
break;
case STRING_TYPE:
result = string_cat(result, &ssize, &offset, def[i].buf,
def[i].col_retlen);
break;
default:
*errmsg = string_sprintf("ORACLE: unknown field type %d", desc[i].dbtype);
*defer_break = FALSE;
result = NULL;
goto ORACLE_EXIT;
}
result = string_cat(result, &ssize, &offset, " ", 1);
}
}
/* If result is NULL then no data has been found and so we return FAIL.
Otherwise, we must terminate the string which has been built; string_cat()
always leaves enough room for a terminating zero. */
if (result == NULL)
{
yield = FAIL;
*errmsg = "ORACLE: no data found";
}
else
{
result[offset] = 0;
store_reset(result + offset + 1);
}
/* Get here by goto from various error checks. */
ORACLE_EXIT:
/* Close the cursor; don't close the connection, as it is cached. */
oclose(cda);
ORACLE_EXIT_NO_VALS:
/* Non-NULL result indicates a sucessful result */
if (result != NULL)
{
*resultptr = result;
return OK;
}
else
{
DEBUG(D_lookup) debug_printf("%s\n", *errmsg);
return yield; /* FAIL or DEFER */
}
}
/*
* Function: setup
*
* Description: This routine does the necessary setup to execute the SQL
* statement. Specifically, it does the open, parse, bind and
* define phases as needed.
*
*/
void setup()
{
colp *colsptr; /* temporary pointer */
sword colindex;
if (oopen(&cda, &lda, (text *) 0, -1, -1, (text *) 0, -1)) /* open */
{
err_report(&cda);
do_exit(OCI_EXIT_FAILURE);
}
if (oparse(&cda, sqlstmt, (sb4) -1, DEFER_PARSE, /* parse */
(ub4) VERSION_7))
{
err_report(&cda);
do_exit(OCI_EXIT_FAILURE);
}
/* bind the scalar */
if (obndra(&cda, (text *)":numins", -1,
(ub1 *)&numinsert, (sword)sizeof(numinsert),
SQLT_INT, -1, (sb2 *) 0, (ub2 *)0, (ub2 *)0,
(ub4)0, (ub4 *)0, (text *)0, -1, -1)) /* bind */
{
err_report(&cda);
do_exit(OCI_EXIT_FAILURE);
}
if (obndra(&cda, (text *)":retval", -1,
(ub1 *)&retval, (sword)sizeof(retval),
SQLT_INT, -1, (sb2 *) 0, (ub2 *)0, (ub2 *)0,
(ub4)0, (ub4 *)0, (text *)0, -1, -1)) /* bind */
{
err_report(&cda);
do_exit(OCI_EXIT_FAILURE);
}
cols = malloc_col(NUMCOLS);
colsptr = cols;
for (colindex = 0; colindex < NUMCOLS; colindex++, colsptr++)
{
colsptr->c_size = coltable[colindex].size;
colsptr->c_type = coltable[colindex].type;
colsptr->c_indp = (sb2*)malloc((size_t)(MAX_ROWS_PER_INSERT*sizeof(sb2)));
memset((dvoid *)colsptr->c_indp, 0, MAX_ROWS_PER_INSERT * sizeof(sb2));
colsptr->c_rlen = (ub2*)malloc((size_t)(MAX_ROWS_PER_INSERT*sizeof(ub2)));
memset((dvoid *)colsptr->c_rlen, 0, MAX_ROWS_PER_INSERT * sizeof(ub2));
colsptr->c_rcode = (ub2*)malloc((size_t)(MAX_ROWS_PER_INSERT*sizeof(ub2)));
memset((dvoid *)colsptr->c_rcode, 0, MAX_ROWS_PER_INSERT * sizeof(ub2));
colsptr->c_buf =
(ub1 *)malloc((size_t)(MAX_ROWS_PER_INSERT*colsptr->c_size));
memset((dvoid *)colsptr->c_buf, 0, MAX_ROWS_PER_INSERT * colsptr->c_size);
colsptr->c_curlen = 0;
switch (colindex) {
case(0) :
/* GOTCHA!!! - need to pass in zeroes for mal and cal parameters when
running a regular insert. Set it to non-zero when using plsql */
if (obndra(&cda, (text *)":col1", -1,
colsptr->c_buf, colsptr->c_size,
(sword)colsptr->c_type, (sword) -1,
(sb2 *)colsptr->c_indp, colsptr->c_rlen, colsptr->c_rcode,
(ub4)MAX_ROWS_PER_INSERT, (ub4 *)&(colsptr->c_curlen),
(text *)0, -1, -1))
{
err_report(&cda);
do_exit(OCI_EXIT_FAILURE);
}
break;
}
}
}
void
main(int argc, char **argv)
{
int i;
int64_t off1, off2;
bin = &binbuf;
bout = &boutbuf;
Binit(bin, 0, OREAD);
Binit(bout, 1, OWRITE);
argv0 = argv[0];
while (argc > 1 && argv[1][0] == '-') {
if (argv[1][1] == '\0')
break;
switch (argv[1][1]) {
case '-':
argc--;
argv++;
goto proceed;
case 'a':
switch(*getoptarg(&argc, &argv)) {
case '1':
a1++;
break;
case '2':
a2++;
break;
default:
sysfatal("incomplete option -a");
}
break;
case 'e':
strtorune(null, getoptarg(&argc, &argv));
break;
case 't':
sepstr=getoptarg(&argc, &argv);
chartorune(&sep1, sepstr);
sep2 = sep1;
break;
case 'o':
if(argv[1][2]!=0 ||
(argc>2 && strchr(argv[2],',')!=0))
oparse(getoptarg(&argc, &argv));
else for (no = 0; no<2*NFLD && argc>2; no++){
if (argv[2][0] == '1' && argv[2][1] == '.') {
olistf[no] = F1;
olist[no] = atoi(&argv[2][2]);
} else if (argv[2][0] == '2' && argv[2][1] == '.') {
olist[no] = atoi(&argv[2][2]);
olistf[no] = F2;
} else if (argv[2][0] == '0')
olistf[no] = F0;
else
break;
argc--;
argv++;
}
break;
case 'j':
if(argc <= 2)
break;
if (argv[1][2] == '1')
j1 = atoi(argv[2]);
else if (argv[1][2] == '2')
j2 = atoi(argv[2]);
else
j1 = j2 = atoi(argv[2]);
argc--;
argv++;
break;
case '1':
j1 = atoi(getoptarg(&argc, &argv));
break;
case '2':
j2 = atoi(getoptarg(&argc, &argv));
break;
}
argc--;
argv++;
}
proceed:
for (i = 0; i < no; i++)
if (olist[i]-- > NFLD) /* 0 origin */
sysfatal("field number too big in -o");
if (argc != 3) {
fprint(2, "usage: join [-1 x -2 y] [-o list] file1 file2\n");
exits("usage");
}
if (j1 < 1 || j2 < 1)
sysfatal("invalid field indices");
j1--;
j2--; /* everyone else believes in 0 origin */
if (strcmp(argv[1], "-") == 0)
f[F1] = bin;
else if ((f[F1] = Bopen(argv[1], OREAD)) == 0)
sysfatal("can't open %s: %r", argv[1]);
if(strcmp(argv[2], "-") == 0)
f[F2] = bin;
else if ((f[F2] = Bopen(argv[2], OREAD)) == 0)
sysfatal("can't open %s: %r", argv[2]);
off1 = Boffset(f[F1]);
off2 = Boffset(f[F2]);
if(Bseek(f[F2], 0, 2) >= 0){
Bseek(f[F2], off2, 0);
join(F2);
}else if(Bseek(f[F1], 0, 2) >= 0){
Bseek(f[F1], off1, 0);
Bseek(f[F2], off2, 0);
join(F1);
}else
sysfatal("neither file is randomly accessible");
if (discard)
sysfatal("some input line was truncated");
exits("");
}
/* {{{ proto int ora_do(int connection, int cursor)
Parse and execute a statement and fetch first result row */
void php3_Ora_Do(INTERNAL_FUNCTION_PARAMETERS)
{
pval *argv[2];
oraConnection *conn = NULL;
oraCursor *cursor = NULL;
text *query;
if (ARG_COUNT(ht) != 2 || getParametersArray(ht, 2, argv) == FAILURE) {
WRONG_PARAM_COUNT;
}
convert_to_long(argv[0]);
convert_to_string(argv[1]);
conn = ora_get_conn(list,plist, argv[0]->value.lval);
if (conn == NULL) {
RETURN_FALSE;
}
if ((cursor = (oraCursor *)emalloc(sizeof(oraCursor))) == NULL){
php3_error(E_WARNING, "Out of memory");
RETURN_FALSE;
}
memset(cursor, 0, sizeof(oraCursor));
query = (text *) estrndup(argv[1]->value.str.val,argv[1]->value.str.len);
if (query == NULL) {
php3_error(E_WARNING, "Invalid query in Ora_Do");
RETURN_FALSE;
}
cursor->query = query;
if (oopen(&cursor->cda, &conn->lda, (text *) 0, -1, -1, (text *) 0, -1)) {
php3_error(E_WARNING, "Unable to open new cursor (%s)",
ora_error(&cursor->cda));
efree(cursor);
RETURN_FALSE;
}
cursor->open = 1;
cursor->conn_ptr = conn;
cursor->conn_id = argv[0]->value.lval;
/* Prepare stmt */
if (oparse(&cursor->cda, query, (sb4) - 1, 1, VERSION_7)){
php3_error(E_WARNING, "Ora_Do failed (%s)",
ora_error(&cursor->cda));
_close_oracur(cursor);
RETURN_FALSE;
}
/* Execute stmt (and fetch 1st row for selects) */
if (cursor->cda.ft == FT_SELECT) {
if (ora_describe_define(cursor) < 0){
/* error message is given by ora_describe_define() */
_close_oracur(cursor);
RETURN_FALSE;
}
if (oexfet(&cursor->cda, 1, 0, 0)) {
php3_error(E_WARNING, "Ora_Do failed (%s)",
ora_error(&cursor->cda));
_close_oracur(cursor);
RETURN_FALSE;
}
cursor->fetched = 1;
} else {
if (oexec(&cursor->cda)) {
php3_error(E_WARNING, "Ora_Do failed (%s)",
ora_error(&cursor->cda));
_close_oracur(cursor);
RETURN_FALSE;
}
}
RETURN_RESOURCE(ora_add_cursor(list, cursor));
}