amos 9d633e9e67 Batch 15 (20261023-C-hwe-scale-15): 320 HWE-derived repair tasks
One user-space repair task per eligible HWE debug-diag / compile-deploy base
ID: 320 admitted (C 218, C++ 97, build scripts 5), 1 skipped by the content
filter. Each ships a public spec with a check-to-basis table, at least two
defects with single-fix fixtures, a symptom-masking fixture and an alternative
correct implementation. Claude re-checked all 320: structure, the HWE quality
items and trace6 Docker calibration receipts against current digests
(320/320 USABLE). Difficulty is unmeasured. Known follow-up: 212 tasks use 120
ad-hoc family names; the next batch maps them to the canonical list.
The batch's 1,256-line progress log stays in its factory report and the
36-local branch batch15-hwe.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-27 01:55:56 +08:00

220 lines
6.3 KiB
C

#include "mode_formula.h"
#include <stdint.h>
#include <string.h>
typedef struct {
const char *start;
size_t length;
} word;
static int horizontal(unsigned char c)
{
return c==' ' || c=='\t' || c=='\r';
}
static int tokenize(const char *text,size_t length,word *words,size_t *count)
{
size_t cursor=0;
*count=0;
while (cursor<length) {
size_t begin;
while (cursor<length && horizontal((unsigned char)text[cursor])) cursor++;
if (cursor==length) break;
if (*count==MF_WORDS) return 0;
begin=cursor;
while (cursor<length && !horizontal((unsigned char)text[cursor])) cursor++;
words[*count].start=text+begin;
words[*count].length=cursor-begin;
*count+=1;
}
return 1;
}
static int same(word value,const char *literal)
{
size_t length=strlen(literal);
return value.length==length && memcmp(value.start,literal,length)==0;
}
static int number(word value,int64_t *out)
{
size_t position=0;
uint64_t magnitude=0;
uint64_t limit=INT64_MAX;
int negative=0;
if (value.length==0) return 0;
if (value.start[0]=='-' || value.start[0]=='+') {
negative=value.start[0]=='-';
position++;
}
if (position==value.length) return 0;
if (negative) limit+=1;
for (;position<value.length;position++) {
unsigned char c=(unsigned char)value.start[position];
uint64_t digit;
if (c<'0' || c>'9') return 0;
digit=(uint64_t)(c-'0');
if (magnitude>(limit-digit)/10) return 0;
magnitude=magnitude*10+digit;
}
if (negative && magnitude==(uint64_t)INT64_MAX+1) *out=INT64_MIN;
else *out=negative ? -(int64_t)magnitude : (int64_t)magnitude;
return 1;
}
static int arguments(word *words,size_t count,int64_t *values)
{
size_t i;
for (i=1;i<count;i++) {
if (!number(words[i],&values[i-1])) return 0;
}
return 1;
}
static void row_begin(mf_row *row,int64_t operation,int64_t code)
{
row->length=2;
row->values[0]=operation;
row->values[1]=code;
}
static void append(mf_row *row,int64_t value)
{
row->values[row->length]=value;
row->length+=1;
}
static void config_command(mf_bank *bank,int64_t *v,mf_row *row)
{
mf_profile profile;
int code;
profile.gate=v[1];
profile.base=v[2];
profile.gain=v[3];
profile.mode=v[4];
profile.shift=v[5];
profile.scale=v[6];
profile.pivot=v[7];
code=mf_configure(bank,v[0],&profile);
row_begin(row,1,code);
if (code==MF_OK) {
append(row,v[0]);
append(row,bank->channels[v[0]].generation);
}
}
static void apply_command(mf_bank *bank,int64_t *v,mf_row *row)
{
mf_event event;
int code=mf_apply(bank,v[0],v[1],&event);
row_begin(row,2,code);
if (code==MF_OK) {
append(row,event.ticket);
append(row,event.raw);
append(row,event.value);
}
}
static void batch_command(mf_bank *bank,int64_t *v,size_t count,mf_row *row)
{
mf_batch_result result;
int code;
if (v[1]<0 || v[1]>MF_BATCH) {
row_begin(row,3,MF_RANGE);
return;
}
if ((size_t)v[1]+3!=count) {
row_begin(row,7,MF_SYNTAX);
return;
}
code=mf_batch(bank,v[0],v+2,(size_t)v[1],&result);
row_begin(row,3,code);
if (code==MF_OK) {
append(row,result.count);
append(row,result.first_ticket);
append(row,result.sum);
append(row,result.minimum);
append(row,result.maximum);
}
}
static void stats_command(mf_bank *bank,int64_t *v,mf_row *row)
{
mf_channel channel;
int code=mf_stats(bank,v[0],&channel);
row_begin(row,4,code);
if (code==MF_OK) {
append(row,channel.configured);
append(row,channel.generation);
append(row,channel.count);
append(row,channel.sum);
append(row,channel.minimum);
append(row,channel.maximum);
append(row,channel.last_ticket);
}
}
static void history_command(mf_bank *bank,int64_t *v,mf_row *row)
{
mf_event event;
int code=mf_history(bank,v[0],v[1],&event);
row_begin(row,5,code);
if (code==MF_OK) {
append(row,event.ticket);
append(row,event.generation);
append(row,event.input);
append(row,event.raw);
append(row,event.value);
}
}
static void clear_command(mf_bank *bank,int64_t *v,mf_row *row)
{
int code=mf_clear(bank,v[0]);
row_begin(row,6,code);
if (code==MF_OK) {
append(row,v[0]);
append(row,bank->channels[v[0]].generation);
}
}
static void profile_command(mf_bank *bank,int64_t *v,mf_row *row)
{
mf_profile profile;
int64_t generation;
int code;
code=mf_get_profile(bank,v[0],&profile,&generation);
row_begin(row,8,code);
if (code==MF_OK) {
append(row,generation);
append(row,profile.gate);
append(row,profile.base);
append(row,profile.gain);
append(row,profile.mode);
append(row,profile.shift);
append(row,profile.scale);
append(row,profile.pivot);
}
}
int mf_dispatch(mf_bank *bank,const char *text,size_t length,mf_row *row)
{
word words[MF_WORDS];
int64_t values[MF_WORDS];
size_t count;
row_begin(row,7,MF_SYNTAX);
size_t first=0;
while (first<length && horizontal((unsigned char)text[first])) first++;
if (first<length && text[first]=='#') return 0;
if (!tokenize(text,length,words,&count)) return 1;
if (count==0) return 0;
if (words[0].length>0 && words[0].start[0]=='#') return 0;
if (!arguments(words,count,values)) return 1;
if (same(words[0],"RESET") && count==1) {
mf_reset(bank);
row_begin(row,0,MF_OK);
append(row,bank->next_ticket);
} else if (same(words[0],"CONFIG") && count==9) {
config_command(bank,values,row);
} else if (same(words[0],"APPLY") && count==3) {
apply_command(bank,values,row);
} else if (same(words[0],"BATCH") && count>=3) {
batch_command(bank,values,count,row);
} else if (same(words[0],"STATS") && count==2) {
stats_command(bank,values,row);
} else if (same(words[0],"HISTORY") && count==3) {
history_command(bank,values,row);
} else if (same(words[0],"PROFILE") && count==2) {
profile_command(bank,values,row);
} else if (same(words[0],"CLEAR") && count==2) {
clear_command(bank,values,row);
}
return 1;
}