stable をチェック。sort 見出しを検索してそれっぽいのが引っかかった。
gawk.git - gawk
gawk.git - gawk
+/* sort_match --- compare leading part of a string against a sort option */
+
+static size_t
+sort_match(const char *str, size_t slen, const char *target)
+{
+ const char *endofword;
+
+ /*
+ * STR comes from the user and is SLEN characters long;
+ * if it has spaces then we care about the subset up until
+ * its first space rather than the full length.
+ * We check whether STR is the same as--or proper prefix
+ * of--TARGET.
+ * Accept "by-foo" or "as-foo" as a synonym match for "foo".
+ */
+ endofword = strchr(str, ' ');
+ if (endofword != NULL)
+ slen = (size_t) (endofword - str);
+ /* try for exact match */
+ if (slen > 0 && strncasecmp(str, target, slen) == 0)
+ return slen;
+ /* ingore "by-" or "as-" prefix and try again */
+ if (slen > 3
+ && (strncasecmp(str, "by-", 3) == 0
+ || strncasecmp(str, "as-", 3) == 0)
+ && strncasecmp(str + 3, target, slen - 3) == 0)
+ return slen;
+ /* no match */
+ return 0;
+}
+
+/*
+ * sort_selection --- parse user-specified sort ordering
+ * ("ascending index" or "value number" and so forth);
+ * returns a qsort comparison function
+ */
+
+static qsort_compfunc
+sort_selection(NODE *r, const char *warn_arg, int default_by_value)
+{
+ enum sort_bits {
+ unrecognized = 0,
+ Unsorted = 0x01,
+ Ascending = 0x02,
+ Descending = 0x04,
+ by_Index = 0x08,
+ by_Value = 0x10,
+ as_String = 0x20,
+ as_Number = 0x40,
+ as_Inserted = 0x80,
+ allbitsused = 0xff
+ };
+ /*
+ * The documented values are singular, but it's trivial to accept
+ * "index numbers" and "descending values" since we're using a
+ * prefix match. Latin plural of index is the only complication.
+ */
+ static const struct sort_keys {
+ const char *const keyword;
+ enum sort_bits keybit;
+ } sorts[] = {
+ { "unsorted", Unsorted }, /* not part of a three-part key */
+ { "ascending", Ascending }, /* ascending vs descending */
+ { "descending", Descending },
+ { "indexes", by_Index }, /* by_Index vs by_Number */
+ { "indices", by_Index }, /* synonym for plural match */
+ { "values", by_Value },
+ { "strings", as_String }, /* as_String vs as_Number */
+ { "numbers", as_Number },
+ { "numeric", as_Number }, /* synonym; singular only */
+ { "inserted", as_Inserted }, /* not part of a three-part key */
+ { "insertion", as_Inserted }, /* another synonym */
+ };
+
+ static short warned_unrecognized = FALSE;
+ static enum sort_bits prev_invalid = unrecognized;
+
+ char *s;
+ size_t l, matchlen;
+ unsigned i;
+ const char *errfmt;
+ enum sort_bits allparts;
+ qsort_compfunc sort_func, default_sort_func;
+
+ /* deduce our caller from the args provided */
+ if (warn_arg != NULL) /* for-in statement */
+ default_sort_func = (qsort_compfunc) 0; /* unsorted */
+ else if (default_by_value) /* asort() */
+ default_sort_func = sort_up_value;
+ else /* asorti() */
+ default_sort_func = ! IGNORECASE ? sort_up_index_string
+ : sort_up_index_ignrcase;
+
+ r = force_string(r);
+ s = r->stptr;
+ l = r->stlen;
+
+ /* treat empty sort-order string as request for default */
+ if (l == 0)
+ return default_sort_func;
+
+ /* no ordering specification yet */
+ allparts = unrecognized;
+ /*
+ * Scan through S until length L is exhausted, checking its
+ * starting word against each possible ordering choice and
+ * then skipping past that to get to the next word. If no
+ * choice matches, an error has been detected. Duplicate
+ * words are accepted; contradictory ones get noticed and
+ * rejected after the string parsing has completed.
+ */
+ while (l > 0) {
+ matchlen = 0; /* lint suppression */
+ for (i = 0; i < (sizeof sorts / sizeof *sorts); ++i) {
+ matchlen = sort_match(s, l, sorts[i].keyword);
+ if (matchlen > 0) {
+ allparts |= sorts[i].keybit;
+ break;
+ }
+ }
+ if (matchlen == 0) {
+ /* failed to match any possible component */
+ allparts = unrecognized;
+ break;
+ }
+ /* move past the part just handled */
+ s += matchlen, l -= matchlen;
+ /* (l > 0) here would accept a trailing space; (l > 1) won't */
+ if (l > 1 && *s == ' ')
+ ++s, --l;
+ } /* while (l > 0) */
+
+ /*
+ * If we have one or two parts of a three part key, fill in
+ * whichever parts are missing with default values. For key
+ * type the default is specified by our caller, for direction
+ * it is Ascending, and for comparison mode it is as_String
+ * but only when sorting by_Index. When sorting by_Value,
+ * comparison mode is out of the user's control and we don't
+ * need or want to fill in either as_String or as_Number.
+ */
+ if ((allparts & (Ascending|Descending|as_String|as_Number)) != 0
+ && (allparts & (Unsorted|by_Index|by_Value|as_Inserted)) == 0)
+ allparts |= default_by_value ? by_Value : by_Index;
+ if ((allparts & (by_Index|by_Value|as_String|as_Number)) != 0
+ && (allparts & (Unsorted|Ascending|Descending|as_Inserted)) == 0)
+ allparts |= Ascending;
+ /* by_Value is handled differently from by_Index */
+ if ((allparts & (Ascending|Descending|by_Index)) != 0
+ && (allparts & (Unsorted|by_Value|as_String|as_Number|as_Inserted)) == 0)
+ allparts |= as_String;
+
略
+ return sort_func;
+}
が、↑では各項目はフルスペルだし、区切りは空白だったりと
CodeZin の斉藤さんの記事とは違っている部分が。
それじゃあと、修正ファイルは分かったので先っちょをみてみると
gawk.git - gawk
gawk.git - gawk
/* assoc_list -- construct, and optionally sort, a list of array elements */
NODE **
assoc_list(NODE *symbol, const char *sort_str, sort_context_t sort_ctxt)
{
typedef int (*qsort_compfunc)(const void *, const void *);
static const struct qsort_funcs {
const char *name;
qsort_compfunc comp_func;
assoc_kind_t kind;
} sort_funcs[] = {
{ "@ind_str_asc", sort_up_index_string, AINDEX|AISTR|AASC },
{ "@ind_num_asc", sort_up_index_number, AINDEX|AINUM|AASC },
{ "@val_str_asc", sort_up_value_string, AVALUE|AVSTR|AASC },
{ "@val_num_asc", sort_up_value_number, AVALUE|AVNUM|AASC },
{ "@ind_str_desc", sort_down_index_string, AINDEX|AISTR|ADESC },
{ "@ind_num_desc", sort_down_index_number, AINDEX|AINUM|ADESC },
{ "@val_str_desc", sort_down_value_string, AVALUE|AVSTR|ADESC },
{ "@val_num_desc", sort_down_value_number, AVALUE|AVNUM|ADESC },
{ "@val_type_asc", sort_up_value_type, AVALUE|AASC },
{ "@val_type_desc", sort_down_value_type, AVALUE|ADESC },
{ "@unsorted", 0, AINDEX },
};
/*
* N.B.: AASC and ADESC are hints to the specific array types.
* See cint_list() in cint_array.c.
*/
NODE **list;
NODE akind;
unsigned long num_elems, j;
int elem_size, qi;
qsort_compfunc cmp_func = 0;
INSTRUCTION *code = NULL;
extern int currule;
int save_rule = 0;
assoc_kind_t assoc_kind = ANONE;
elem_size = 1;
for (qi = 0, j = sizeof(sort_funcs)/sizeof(sort_funcs[0]); qi < j; qi++) {
if (strcmp(sort_funcs[qi].name, sort_str) == 0)
break;
}
if (qi < j) {
cmp_func = sort_funcs[qi].comp_func;
assoc_kind = sort_funcs[qi].kind;
if (symbol->array_funcs != cint_array_func)
assoc_kind &= ~(AASC|ADESC);
if (sort_ctxt != SORTED_IN || (assoc_kind & AVALUE) != 0) {
/* need index and value pair in the list */
assoc_kind |= (AINDEX|AVALUE);
elem_size = 2;
}
} else { /* unrecognized */
NODE *f;
const char *sp;
for (sp = sort_str; *sp != '\0' && ! isspace((unsigned char) *sp); sp++)
continue;
/* empty string or string with space(s) not valid as function name */
if (sp == sort_str || *sp != '\0')
fatal(_("`%s' is invalid as a function name"), sort_str);
f = lookup(sort_str);
if (f == NULL || f->type != Node_func)
fatal(_("sort comparison function `%s' is not defined"), sort_str);
cmp_func = sort_user_func;
/* need index and value pair in the list */
assoc_kind |= (AVALUE|AINDEX);
elem_size = 2;
/* make function call instructions */
code = bcalloc(Op_func_call, 2, 0);
code->func_body = f;
code->func_name = NULL; /* not needed, func_body already assigned */
(code + 1)->expr_count = 4; /* function takes 4 arguments */
code->nexti = bcalloc(Op_stop, 1, 0);
/*
* make non-redirected getline, exit, `next' and `nextfile' fatal in
* callback function by setting currule in interpret()
* to undefined (0).
*/
save_rule = currule; /* save current rule */
currule = 0;
PUSH_CODE(code);
}
akind.flags = (unsigned int) assoc_kind; /* kludge */
list = symbol->alist(symbol, & akind);
assoc_kind = (assoc_kind_t) akind.flags; /* symbol->alist can modify it */
if (list == NULL || ! cmp_func || (assoc_kind & (AASC|ADESC)) != 0)
return list; /* empty list or unsorted, or list already sorted */
num_elems = assoc_length(symbol);
qsort(list, num_elems, elem_size * sizeof(NODE *), cmp_func); /* shazzam! */
if (cmp_func == sort_user_func) {
code = POP_CODE();
currule = save_rule; /* restore current rule */
bcfree(code->nexti); /* Op_stop */
bcfree(code); /* Op_func_call */
}
if (sort_ctxt == SORTED_IN && (assoc_kind & (AINDEX|AVALUE)) == (AINDEX|AVALUE)) {
/* relocate all index nodes to the first half of the list. */
for (j = 1; j < num_elems; j++)
list[j] = list[2 * j];
/* give back extra memory */
erealloc(list, NODE **, num_elems * sizeof(NODE *), "assoc_list");
}
return list;
}
お、こっちは記事通りな指定文字列。でも該当するものが見つからなかったときの
/* unrecognized */ な部分の記述、
ソートで使う関数の名前とみなしてる?
最後ってどゆことーと気になったのだけどこういう英語の文章が
The Final YAPC::Asia Tokyo — Medium
The Final YAPC::Asia Tokyo — Medium
We just announced the dates to YAPC::Asia Tokyo 2015, and that this is going to be the LAST YAPC::Asia that
we will be holding. I’m coming out of retirement as YAPC organizer to run this one final show.
To be clear what “last YAPC::Asia” means: (1) YAPC::Asia is independent of other YAPCs such as YAPC::NA,
YAPC::EU, etc, so this does not affect them. (2) Anybody is free to hold their own YAPC::Asia, but this just
means we (Japan Perl Association and myself) will not be organizing it anymore.
って牧さんのツイートがあったのね。
そっか十年やったのかー。
![機動警察パトレイバー アーリーデイズ VOLUME 2. [DVD]](http://ecx.images-amazon.com/images/I/41S5ABSX7KL._SL160_.jpg)
EMOTION the Best 機動警察パトレイバー2 the Movie [DVD]![EMOTION the Best 機動警察パトレイバー2 the Movie [DVD]](http://ecx.images-amazon.com/images/I/411j6aYUDYL._SL160_.jpg)
![月刊 まんがくらぶオリジナル 2014年 12月号 [雑誌]](http://ecx.images-amazon.com/images/I/61Xz6aTf0ZL._SL160_.jpg)
