def func(interp, s_frame, argument_count): # argument_count does NOT include the receiver. # This means that for argument_count == 3 the stack looks like: # 3 2 1 Top # Rcvr | Arg 0 | Arg1 | Arg 2 # # Validate that we have a block on the stack and that it received # the proper number of arguments: w_block_ctx = s_frame.peek(argument_count) # XXX need to check this since VALUE is called on all sorts of objects. if not w_block_ctx.getclass(interp.space).is_same_object( interp.space.w_BlockContext): raise PrimitiveFailedError() w_block_ctx = assert_pointers(w_block_ctx) s_block_ctx = w_block_ctx.as_context_get_shadow(interp.space) exp_arg_cnt = s_block_ctx.expected_argument_count() if argument_count != exp_arg_cnt: # exp_arg_cnt doesn't count self raise PrimitiveFailedError() # Initialize the block stack with the arguments that were # pushed. Also pop the receiver. block_args = s_frame.pop_and_return_n(exp_arg_cnt) # Reset stack of blockcontext to [] s_block_ctx.reset_stack() s_block_ctx.push_all(block_args) s_frame.pop() s_block_ctx.reset_pc() return s_block_ctx
def primitiveSQLNextObject(interp, s_frame, w_rcvr, cursor_handle): if CConfig is None: raise PrimitiveFailedError('sqpyte not found') space = interp.space cursor = dbm.cursor(cursor_handle) row = cursor.raw_next(space) if not row: return space.w_nil w_id = None num_cols = len(row) cache = [None] * num_cols for i in range(num_cols): name = cursor.column_names[i] if name == 'id': w_id = row[i] else: n0 = int(name[9:]) # strip 'inst_var_' class_name = w_rcvr.classname(interp.space).split(' ')[0] if W_DBObject.state.get_column_type(class_name, n0) is BLOB: db_id = space.unwrap_int(row[i]) cache[n0] = W_DBObject.state.db_objects[db_id] else: cache[n0] = row[i] if w_id is None: raise PrimitiveFailedError('Could not find w_id') return W_DBObject(space, w_rcvr, num_cols, w_id=w_id, cache=cache)
def func(interp, s_frame, w_rcvr, args_w, w_cm): if not isinstance(w_cm, W_CompiledMethod): raise PrimitiveFailedError() code = w_cm.primitive() if code: raise PrimitiveFailedError("withArgs:executeMethod: not support with primitive method") return w_cm.create_frame(interp.space, w_rcvr, args_w)
def execute(self, space, sql, args=None): if self.column_count > 0: raise PrimitiveFailedError( 'execute() cannot be called twice on same cursor') # otherwise we can't assume that column_{count,names} are immutable jit.promote(self.connection) jit.promote(self.statement) cache = self.connection.statement_cache self.statement = cache.get_or_make(sql) query = self.statement.query if args is not None: if len(args) != query.bind_parameter_count(): raise PrimitiveFailedError('wrong # of arguments for query') for i, w_value in enumerate(args): self.bind_query_argument(space, w_value, query, i + 1) self._step() self.column_count = query.data_count() self.column_names = [rffi.charp2strn(query.column_name(i), 255) for i in range(self.column_count)] return self
def func(interp, s_frame, w_cls, size): w_cls = assert_pointers(w_cls) s_class = w_cls.as_class_get_shadow(interp.space) if not s_class.isvariable() and size != 0: raise PrimitiveFailedError() if size < 0: raise PrimitiveFailedError() try: return s_class.new(size) except MemoryError: raise PrimitiveFailedError
def func(interp, s_frame, w_class): # This primitive returns some instance of the class on the stack. # If no class is given, it returns some object. if w_class.is_same_object(interp.space.w_SmallInteger): raise PrimitiveFailedError() match_w = get_instances_array(interp, s_frame, w_class=w_class, some_instance=True) try: return match_w[0] except IndexError: raise PrimitiveFailedError()
def func(interp, s_frame, w_rcvr, w_arg): w_arg_class = w_arg.getclass(interp.space) w_rcvr_class = w_rcvr.getclass(interp.space) # We should fail if: # 1. Rcvr or arg are SmallIntegers if (w_arg_class.is_same_object(interp.space.w_SmallInteger) or w_rcvr_class.is_same_object(interp.space.w_SmallInteger)): raise PrimitiveFailedError() # 2. Rcvr is an instance of a compact class and argument isn't # or vice versa XXX we don't have to fail here, but for squeak it's a problem # 3. Format of rcvr is different from format of argument if ((isinstance(w_arg, W_PointersObject) and isinstance(w_rcvr, W_PointersObject)) or (isinstance(w_arg, W_BytesObject) and isinstance(w_rcvr, W_BytesObject)) or (isinstance(w_arg, W_WordsObject) and isinstance(w_rcvr, W_WordsObject))): w_rcvr.change_class(interp.space, w_arg_class) return w_rcvr elif isinstance(w_rcvr, W_WordsObject) and isinstance(w_arg, W_BytesObject): wordsize = constants.BYTES_PER_WORD w_rcvr.convert_to_bytes_layout(wordsize) w_rcvr.change_class(interp.space, w_arg_class) return w_rcvr else: # TODO: this should also work to change bytes to words and such raise PrimitiveNotYetWrittenError
def _fetch_one_row(self, space): query = jit.promote(self.statement).query num_cols = query.data_count() jit.promote(num_cols) cols = [None] * num_cols for i in range(num_cols): tid = query.column_type(i) if tid == CConfig.SQLITE_TEXT or tid == CConfig.SQLITE_BLOB: textlen = query.column_bytes(i) result = rffi.charpsize2str(rffi.cast(rffi.CCHARP, query.column_text(i)), textlen) w_result = space.wrap_string(result) # no encoding elif tid == CConfig.SQLITE_INTEGER: result = query.column_int64(i) w_result = space.wrap_int(result) elif tid == CConfig.SQLITE_FLOAT: result = query.column_double(i) w_result = space.wrap_float(result) elif tid == CConfig.SQLITE_NULL: w_result = space.w_nil else: raise PrimitiveFailedError('read_row [tid: %s' % tid) cols[i] = w_result return cols
def primitiveSQLColumnName(interp, s_frame, w_rcvr, cursor_handle, index): if index < 1: raise PrimitiveFailedError('Index must be >= 1') # Smalltalk counts from 1, rest of world from 0 return interp.space.wrap_string( dbm.cursor(cursor_handle).column_names[index - 1])
def func(interp, s_frame, w_rcvr): if not isinstance(w_rcvr, W_CompiledMethod): raise PrimitiveFailedError() w_class = w_rcvr.compiled_in() if w_class: w_class = assert_pointers(w_class) w_class.as_class_get_shadow(interp.space).flush_method_caches() return w_rcvr
def primitiveSQLConnect(interp, s_frame, w_rcvr, filename, sqpyte): if interpreter is None: raise PrimitiveFailedError('sqpyte not found') if sqpyte: db_handle = dbm.connect(interpreter.SQPyteDB, filename) else: db_handle = dbm.connect(interpreter.SQLite3DB, filename) return interp.space.wrap_int(db_handle)
def func(interp, s_frame, w_obj, n0, w_val): val = interp.space.unwrap_char_as_byte(w_val) n0 = assert_valid_index(interp.space, n0, w_obj) if not (isinstance(w_obj, W_CompiledMethod) or isinstance( w_obj, W_BytesObject) or isinstance(w_obj, W_WordsObject)): raise PrimitiveFailedError() w_obj.setchar(n0, val) return w_val
def __init__(self, w_connection, sql): assert isinstance(w_connection, SQLConnection) self.w_connection = w_connection self.sql = sql try: self.query = w_connection.db.execute(sql) except Exception as e: raise PrimitiveFailedError(str(e))
def _step(self): rc = self.statement.query.mainloop() if rc == CConfig.SQLITE_ROW: pass elif rc == CConfig.SQLITE_DONE: self._reset() else: raise PrimitiveFailedError('strange result: %s' % rc)
def func(interp, s_frame, argcount): if interp.space.headless.is_set(): w_message = None if s_frame.w_method().lookup_selector == 'doesNotUnderstand:': w_arguments = s_frame.w_arguments() if len(w_arguments) >= 1: w_message = w_arguments[0] s_frame.exitFromHeadlessExecution(w_message=w_message) raise PrimitiveFailedError()
def primitiveSQLModeSwitch(interp, s_frame, w_rcvr, mode): if interpreter is None: raise PrimitiveFailedError('sqpyte not found') if mode == 1: dbm.driver = interpreter.SQLite3DB elif mode == 2: dbm.driver = interpreter.SQPyteDB else: dbm.driver = None return interp.space.w_nil
def connection(self): if self.db_connection is not None: return self.db_connection if self.driver is None: raise PrimitiveFailedError('connection [driver is None]') print "DBMode: %s" % self.driver connection = SQLConnection(self.driver, self.db_file_name) assert connection is not None self.db_connection = connection return connection
def func(interp, s_frame, receiver, argument): guard_nonnull(argument) if isinstance(receiver, rbigint): if receiver.mod(argument) != NULLRBIGINT: raise PrimitiveFailedError return interp.space.wrap_rbigint(receiver.div(argument)) else: if int_ovfcheck_mod(receiver, argument) != 0: raise PrimitiveFailedError() return interp.space.wrap_int(int_ovfcheck_div(receiver, argument))
def activateClosure(interp, w_block, args_w): space = interp.space if not isinstance(w_block, W_BlockClosure): raise PrimitiveFailedError blockNumArgs = w_block.numArgs() if not blockNumArgs == len(args_w): raise PrimitiveFailedError() # additionally to the smalltalk implementation, this also pushes # args and copiedValues s_new_frame = w_block.create_frame(space, arguments=args_w) return s_new_frame
def _become(space, w_rcvr, w_new): w_lefts = [] w_rights = [] for i in range(w_rcvr.size()): w_left = w_rcvr.at0(space, i) w_right = w_new.at0(space, i) if w_left.become(w_right): w_lefts.append(w_left) w_rights.append(w_right) else: for i in range(len(w_lefts)): w_lefts[i].become(w_rights[i]) raise PrimitiveFailedError()
def bind_query_argument(self, space, w_value, query, i): cls = w_value.getclass(space) if (cls.is_same_object(space.w_String)): query.bind_str(i, space.unwrap_string(w_value)) elif cls.is_same_object(space.w_SmallInteger): query.bind_int64(i, space.unwrap_int(w_value)) elif cls.is_same_object(space.w_Float): query.bind_double(i, space.unwrap_float(w_value)) elif cls.is_same_object(space.w_nil): query.bind_null(i) else: raise PrimitiveFailedError( 'unable to unwrap %s' % w_value.getclass(space))
def next_instance(space, list_of_objects, w_obj): retval = None try: idx = list_of_objects.index(w_obj) except ValueError: idx = -1 try: retval = list_of_objects[idx + 1] except IndexError: raise PrimitiveFailedError() # just in case, that one of the objects in the list changes its class if retval.getclass(space).is_same_object(w_obj.getclass(space)): return retval else: list_of_objects.pop(idx + 1) return next_instance(space, list_of_objects, w_obj)
def func(interp, s_frame, w_block_ctx, args_w): w_block_ctx = assert_pointers(w_block_ctx) s_block_ctx = w_block_ctx.as_context_get_shadow(interp.space) exp_arg_cnt = s_block_ctx.expected_argument_count() if len(args_w) != exp_arg_cnt: raise PrimitiveFailedError() # Push all the items from the array for i in range(exp_arg_cnt): s_block_ctx.push(args_w[i]) # XXX Check original logic. Image does not test this anyway # because falls back to value + internal implementation s_block_ctx.reset_pc() return s_block_ctx
def primitiveSQLExecute(interp, s_frame, argcount): if not 2 <= argcount <= 3: raise PrimitiveFailedError( 'wrong number of arguments: %s' % argcount) space = interp.space args = None if argcount == 3: args = interp.space.unwrap_array(s_frame.pop()) arg3_w = s_frame.pop() sql = space.unwrap_string(arg3_w) arg2_w = s_frame.pop() db_handle = space.unwrap_int64(arg2_w) connection = dbm.get_connection(db_handle) cursor_handle = dbm.execute(interp.space, connection, sql, args) return space.wrap_int(cursor_handle)
def primitiveFileOpen(interp, s_frame, w_rcvr, file_path, w_writeable_flag): space = interp.space file_missing = not os.path.exists(file_path) if w_writeable_flag is space.w_true: if file_missing: mode = os.O_RDWR | os.O_CREAT else: mode = os.O_RDWR else: mode = os.O_RDONLY if file_missing: return space.w_nil mode |= os.O_BINARY try: file_descriptor = os.open(file_path, mode, 0666) except OSError: raise PrimitiveFailedError() return space.wrap_int(file_descriptor)
def close(self, db_pointer): db = self._dbs.get(db_pointer, None) if db is None: raise PrimitiveFailedError('close [db is None]') return db.close()
def cursor(self, cursor_handle): cursor = self._cursors.get(cursor_handle, None) if cursor is None: raise PrimitiveFailedError('cursor not found') return cursor
def get_connection(self, db_handle): db = self._dbs.get(db_handle, None) if db is None: raise PrimitiveFailedError('execute [db is None]') return db
def primitiveFileClose(interp, s_frame, w_rcvr, fd): try: os.close(fd) except OSError: raise PrimitiveFailedError() return w_rcvr
def func(interp, s_frame, w_class): match_w = get_instances_array(interp, s_frame, some_instance=True) try: return match_w[0] except IndexError: raise PrimitiveFailedError()