Нашли или выдавили из себя код, который нельзя назвать нормальным, на который без улыбки не взглянешь? Не торопитесь его удалять или рефакторить, — запостите его на говнокод.ру, посмеёмся вместе!
−2
if (true
&& (false
|| LYS_LEAF != ref_node->schema->nodetype
|| LY_TYPE_LEAFREF != reinterpret_cast<lys_node_leaf*>(ref_node->schema)->type.base
)
&& (false
|| LYS_LEAFLIST != ref_node->schema->nodetype
|| LY_TYPE_LEAFREF != reinterpret_cast<lys_node_leaflist*>(ref_node->schema)->type.base
)
)
return nullptr;
Посоны, помогити!11
Я блять чего то не ПОНИМАЮ, ШО ТАК ЗАЧЕМ ДЕЛАТЬ?
dicklover,
07 Ноября 2022
+2
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#define NUMARGS(type,...) (sizeof((type[]){__VA_ARGS__})/sizeof(type))
#define xDEF(type) typedef struct {size_t size; type* arr; } xARR(type)
#define xARR(type) jArr_ ## type
#define A(type, ...) (xARR(type)) {NUMARGS(type,__VA_ARGS__), (type[]){__VA_ARGS__}}
#define _FOR(type, item, Arr) type item=Arr.arr[0]; for(size_t I = 0; I < Arr.size; item=Arr.arr[++I] )
// MSVC
#define xFOR(type, item, array) do{ _FOR(type, item, array) {
// GCC, Clang
#define FOR(item, array) do{ __auto_type Arr=array; _FOR(__auto_type, item, Arr) {
#define NEXT }} while(0);
#define OfArray(type,arr) (xARR(type)){sizeof(arr)/sizeof(type), arr }
typedef struct {
char *name;
int id;
} Entry;
typedef struct {const char *name;} Str;
typedef struct {int x[2]; } Pair;
xDEF(Entry);
xDEF(Str);
xDEF(Pair);
xDEF(int);
void printEntry(xARR(Entry) entries)
{
xFOR(Entry, e, entries)
printf("%s %d \n", e.name, e.id);
NEXT
}
void printSquares(xARR(int) ints)
{
FOR(v, ints)
printf("%d²=%d\n", v,(int) pow(v,2.));
NEXT
}
int main(void)
{
xARR(Entry) e = A(Entry, {"one",1}, {"two",2}, {"three",3});
printEntry(e);
puts("_______________________________________");
// можно передавать в метод непосредственно аргуметом
printSquares( A(int, 3, 7, 5, 4) );
puts("_______________________________________");
int nums[]={4,3,2,1};
// можно использовать ранее объявленный массив
printSquares(OfArray(int,nums));
// можно итерироватьcя по ранее объявленному массиву
FOR(i, OfArray(int, nums))
printf("%d-",i);
NEXT
puts("\n_______________________________________");
//вложенные циклы:
for (int k=1;k<3;k++)
FOR(i, A(Str, "kakoi", "bagor"))
FOR(j, A(int, 1111,2222,3333))
printf("%d %s %d\n", k, i.name, j);
NEXT
NEXT
puts("_______________________________________");
FOR(v, A(Pair, {1,2}, {11,12}, {20,21}))
printf("%d,%d\n", v.x[0], v.x[1]);
NEXT
puts("_______________________________________");
//проблема пустого варарга
FOR(j, A(int))
printf("%d\n", j);
NEXT
return(0);
}
https://godbolt.org/z/o9Tv9EvGx
Довёл for~each до ума.
3.14159265,
23 Июля 2022
0
#define _CRT_SECURE_NO_WARNINGS
#pragma comment(lib, "ntdll.lib")
#include <Windows.h>
#include <string>
#define FLG_HEAP_ENABLE_TAIL_CHECK 0x10
#define FLG_HEAP_ENABLE_FREE_CHECK 0x20
#define FLG_HEAP_VALIDATE_PARAMETERS 0x40
#define NT_GLOBAL_FLAG_DEBUGGED (FLG_HEAP_ENABLE_TAIL_CHECK | FLG_HEAP_ENABLE_FREE_CHECK | FLG_HEAP_VALIDATE_PARAMETERS)
typedef NTSTATUS(NTAPI* pfnNtSetInformationThread)(
_In_ HANDLE ThreadHandle,
_In_ ULONG ThreadInformationClass,
_In_ PVOID ThreadInformation,
_In_ ULONG ThreadInformationLenght);
const ULONG ThreadHideFromDebugger = 0x11;
typedef NTSTATUS(NTAPI* pfnNtQueryInformationProcess)(
_In_ HANDLE ProcessHandle,
_In_ ULONG ProcessInformationClass,
_In_ PVOID ProcessInformation,
_In_ ULONG ProcessInformationLenght,
_Out_opt_ PULONG ReturnLenght);
const UINT ProcessDebugPort = 7;
void HideFromDebugger()
{
HMODULE hNtDll = LoadLibrary("ntdll.dll");
if (!hNtDll)
throw std::exception("can't load kernel");
pfnNtSetInformationThread NtSetInformatioThread = (pfnNtSetInformationThread)
GetProcAddress(hNtDll, "NtSetInformationThread");
NTSTATUS status = NtSetInformatioThread(GetCurrentThread(), ThreadHideFromDebugger, NULL, NULL);
}
PVOID GetPEB()
{
return (PVOID)__readfsword(0x0C * sizeof(PVOID));
}
int main()
{
pfnNtQueryInformationProcess NtQueryInformationProcess = nullptr;
NTSTATUS status;
DWORD IsDebuggerPresent = 0;
HMODULE hNtDll = LoadLibrary("ntdll.dll");
if (!hNtDll)
throw std::exception("can't load kernel");
NtQueryInformationProcess = (pfnNtQueryInformationProcess)GetProcAddress(hNtDll, "NtQueryInformationProcess");
void HideFromDebugger();
while (true)
{
PVOID pPEB = GetPEB();
DWORD offsetNtGlobalFlag = 0x68;
DWORD NtGlobalFlag = (DWORD)((PBYTE)pPEB + offsetNtGlobalFlag);
NTSTATUS stat = NtQueryInformationProcess(GetCurrentProcess(), ProcessDebugPort,
&IsDebuggerPresent, sizeof(DWORD), NULL);
if ((NtGlobalFlag & NT_GLOBAL_FLAG_DEBUGGED) || (stat == 0x00000000 && IsDebuggerPresent != 0))
{
MessageBox(NULL, "Close your fucking debuger!", "FUCK YOU", MB_OK);
return -1;
}
}
return 0;
}
PVOID,
23 Мая 2022
0
-- Теперь мы можем легко получить отчёт по продажам на прошлую дату:
DELIMITER ;
BEGIN;
CALL set_prot_snapshot_date('2018-10-09 17:23:47', NULL, -1);
SELECT NOW() report_time, d.date, SUM(p.amount * p.price) sum
FROM docs d
INNER JOIN doc_pos p ON d.id = p.doc_id
GROUP BY d.date;
ROLLBACK;
https://habr.com/ru/post/425769/
Как научить MySQL заглядывать в прошлое
ISO,
09 Мая 2022
0
#include <iostream>
#include <vector>
#include <thread>
int f()
{
static int i = 0;
synchronized { // begin synchronized block
std::cout << i << " -> ";
++i; // each call to f() obtains a unique value of i
std::cout << i << '\n';
return i; // end synchronized block
}
}
int main()
{
std::vector<std::thread> v(10);
for(auto& t: v)
t = std::thread([]{ for(int n = 0; n < 10; ++n) f(); });
for(auto& t: v)
t.join();
}
0 -> 1
1 -> 2
2 -> 3
...
99 -> 100https://en.cppreference.com/w/cpp/language/transactional_memory
kcalbCube,
27 Апреля 2022
0
'use strict'
const {TheCtrl} = require('the-controller-base')
const {withAuthorized} = require('the-controller-mixins')
async function tryExample () {
class MyCtrl extends withAuthorized(TheCtrl) {
/* ... */
}
}
tryExample().catch((err) => console.error(err))
Mixins for the-controller
Installation
$ npm install the-controller-mixins --save
Очень полезный и нужный пакет. Пользуйтесь.
https://www.npmjs.com/package/the-controller-mixins/v/2.1.0
3_dar,
31 Декабря 2021
0
export type Maybe<T> = null | undefined | T;
export interface Path {
readonly prev: Path | undefined;
readonly key: string | number;
readonly typename: string | undefined;
}
/**
* Given a Path and a key, return a new Path containing the new key.
*/
export function addPath(
prev: Readonly<Path> | undefined,
key: string | number,
typename: string | undefined,
): Path {
return { prev, key, typename };
}
/**
* Given a Path, return an Array of the path keys.
*/
export function pathToArray(
path: Maybe<Readonly<Path>>,
): Array<string | number> {
let curr = path;
let flattened = [];
while (curr) {
flattened.push(curr.key);
curr = curr.prev;
}
//flattened.reverse();
return flattened;
}
function main() {
let pathArray = pathToArray({
key: "path",
prev: undefined,
typename: undefined,
});
for (let x of pathArray) {
print(x);
}
}
последний коммит позволяет скомпилить и выполнить данный код. это невиданный прогресс в компиляторе :)
и уже традиционный вопрос ... а ты там можешь наговнокодить на С/C++?
ASD_77,
31 Декабря 2021
+1
Можно ли считать говнокодом (говноAPI) правильно работающую, но незадокументированную особенность API?
Например у вьюхи есть свойство isOpen, которое может быть задано (true/false) а может быть не задано (undefined).
Первое нужно для управления видимостью в реактивном стиле, второе предполагает что разработчик будет
управлять видимостью через хендлы вьюхи. И оно так и работает - если isOpen=undefined, то этот проп просто игнорируется
при обновлении вьюхи (чтобы не допустить конфликта source truth). Но этого нет в документации, отчего неосторожное
использование булеана и значения которое может быть undefined в качестве значения isOpen, приводит к забавному
косяку - вьюха должна исчезнуть, но она не исчезает! И тут по-началу грешишь на забагованное API. Но в нем нет бага!
JaneBurt,
06 Декабря 2021
+1
(** Set of all possible interleaving of two traces is a trace
ensemble. As we later prove in [interleaving_to_permutation], this
definition is dual to [Permutation]. *)
Inductive Interleaving : list TE -> list TE -> TraceEnsemble :=
| ilv_cons_l : forall te t1 t2 t,
Interleaving t1 t2 t ->
Interleaving (te :: t1) t2 (te :: t)
| ilv_cons_r : forall te t1 t2 t,
Interleaving t1 t2 t ->
Interleaving t1 (te :: t2) (te :: t)
| ilv_nil : Interleaving [] [] [].
Попытка оптимизации:
(* Left-biased version of [Interleaving] that doesn't make
distinction between schedulings of commuting elements: *)
Inductive UniqueInterleaving : list TE -> list TE -> TraceEnsemble :=
| uilv_cons_l : forall l t1 t2 t,
UniqueInterleaving t1 t2 t ->
UniqueInterleaving (l :: t1) t2 (l :: t)
| uilv_cons_r1 : forall l r t1 t2 t,
~trace_elems_commute l r ->
UniqueInterleaving (l :: t1) t2 (l :: t) ->
UniqueInterleaving (l :: t1) (r :: t2) (r :: l :: t)
| uilv_cons_r2 : forall r1 r2 t1 t2 t,
UniqueInterleaving t1 (r1 :: t2) (r1 :: t) ->
UniqueInterleaving t1 (r2 :: r1 :: t2) (r2 :: r1 :: t)
| uilv_nil : forall t, UniqueInterleaving [] t t.Сложный говнокод. Почему вторая "оптимизированная" версия работает хуже первой?
CHayT,
01 Ноября 2021
0
#define REGISTERS_LIST A, B, C, D, E, SI, BP, SP, IP
#define LREGISTERS_LIST AH, AL, BH, BL, CH, CL, DH, DL, EH, EL, SIH, SIL, BPH, BPL, SPH, SPL, IPH, IPL
enum RegisterID
{
REGISTERS_LIST,
LREGISTERS_LIST
};
const static std::string registerId2registerName[] = {
#define _MAP(x) #x
MAP_LIST(_MAP, REGISTERS_LIST),
MAP_LIST(_MAP, LREGISTERS_LIST)
};
#undef _MAP
const static std::map<std::string, RegisterID> registerName2registerId = {
#define _MAP(x) {#x, x}
MAP_LIST(_MAP, REGISTERS_LIST),
MAP_LIST(_MAP, LREGISTERS_LIST)
};
#undef _MAPпокруче гомоиконности
digitalEugene,
30 Октября 2021
Follow us!